Fix SPS/PPS insertion logic in MP4StreamParser.

media/formats/mp4/avc.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp4/avc.h"
 
 #include <algorithm>
 #include <vector>
 
+#include "base/logging.h"
+#include "media/filters/h264_parser.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/box_reader.h"
 
 namespace media {
 namespace mp4 {
 
 static const uint8 kAnnexBStartCode[] = {0, 0, 0, 1};
 static const int kAnnexBStartCodeSize = 4;
 
 static bool ConvertAVCToAnnexBInPlaceForLengthSize4(std::vector<uint8>* buf) {
   const int kLengthSize = 4;
   size_t pos = 0;
   while (pos + kLengthSize < buf->size()) {
-    int nal_size = (*buf)[pos];
+    uint32 nal_size = (*buf)[pos];
     nal_size = (nal_size << 8) + (*buf)[pos+1];
     nal_size = (nal_size << 8) + (*buf)[pos+2];
     nal_size = (nal_size << 8) + (*buf)[pos+3];
+
+    if (nal_size == 0) {
+      DVLOG(1) << __FUNCTION__ << " nal_size is 0";
+      return false;
+    }
+
     std::copy(kAnnexBStartCode, kAnnexBStartCode + kAnnexBStartCodeSize,
               buf->begin() + pos);
     pos += kLengthSize + nal_size;
   }
   return pos == buf->size();
 }
 
 // static
 bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer) {
   RCHECK(length_size == 1 || length_size == 2 || length_size == 4);
 
   if (length_size == 4)
     return ConvertAVCToAnnexBInPlaceForLengthSize4(buffer);
 
   std::vector<uint8> temp;
   temp.swap(*buffer);
   buffer->reserve(temp.size() + 32);
 
   size_t pos = 0;
   while (pos + length_size < temp.size()) {
     int nal_size = temp[pos];
     if (length_size == 2) nal_size = (nal_size << 8) + temp[pos+1];
     pos += length_size;
 
+    if (nal_size == 0) {
+      DVLOG(1) << __FUNCTION__ << " nal_size is 0";
+      return false;
+    }
+
     RCHECK(pos + nal_size <= temp.size());
     buffer->insert(buffer->end(), kAnnexBStartCode,
                    kAnnexBStartCode + kAnnexBStartCodeSize);
     buffer->insert(buffer->end(), temp.begin() + pos,
                    temp.begin() + pos + nal_size);
     pos += nal_size;
   }
   return pos == temp.size();
 }
 
 // static
+bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config,
+                                std::vector<uint8>* buffer) {
+  DCHECK(AVC::IsValidAnnexB(*buffer));
+
+  scoped_ptr<H264Parser> parser(new H264Parser());
+  const uint8* start = &(*buffer)[0];
+  parser->SetStream(start, buffer->size());
+
+  H264NALU nalu;
+  if (parser->AdvanceToNextNALU(&nalu) != H264Parser::kOk)
+    return false;
+
+  std::vector<uint8>::iterator config_insert_point = buffer->begin();
+
+  if (nalu.nal_unit_type == H264NALU::kAUD) {
+    // Move insert point to just after the AUD.
+    config_insert_point += (nalu.data + nalu.size) - start;
+
+    // Move to the next NALU so the SPS/PPS checks below will catch
+    // existing SPS/PPS that may occur right after the AUD.
+    if (parser->AdvanceToNextNALU(&nalu) != H264Parser::kOk)
+      return false;
+  }
+
+  if (nalu.nal_unit_type == H264NALU::kSPS ||
+      nalu.nal_unit_type == H264NALU::kPPS) {
+    // Param sets are already in |buffer| so just use those instead
+    // since they are likely overrides for the parameters in the
+    // decoder configuration.
+    return true;
+  }
+
+  // Clear |parser| and |start| since they aren't needed anymore and
+  // will hold stale pointers once the insert happens.
+  parser.reset();
+  start = NULL;
+
+  std::vector<uint8> param_sets;
+  RCHECK(AVC::ConvertConfigToAnnexB(avc_config, &param_sets));
+
+  buffer->insert(config_insert_point,
+                 param_sets.begin(), param_sets.end());
+
+  DCHECK(AVC::IsValidAnnexB(*buffer));
+  return true;
+}
+
+// static
 bool AVC::ConvertConfigToAnnexB(
     const AVCDecoderConfigurationRecord& avc_config,
     std::vector<uint8>* buffer) {
   DCHECK(buffer->empty());
   buffer->clear();
   int total_size = 0;
   for (size_t i = 0; i < avc_config.sps_list.size(); i++)
     total_size += avc_config.sps_list[i].size() + kAnnexBStartCodeSize;
   for (size_t i = 0; i < avc_config.pps_list.size(); i++)
     total_size += avc_config.pps_list[i].size() + kAnnexBStartCodeSize;
   buffer->reserve(total_size);
 
   for (size_t i = 0; i < avc_config.sps_list.size(); i++) {
     buffer->insert(buffer->end(), kAnnexBStartCode,
                 kAnnexBStartCode + kAnnexBStartCodeSize);
     buffer->insert(buffer->end(), avc_config.sps_list[i].begin(),
                 avc_config.sps_list[i].end());
   }
 
   for (size_t i = 0; i < avc_config.pps_list.size(); i++) {
     buffer->insert(buffer->end(), kAnnexBStartCode,
                    kAnnexBStartCode + kAnnexBStartCodeSize);
     buffer->insert(buffer->end(), avc_config.pps_list[i].begin(),
                    avc_config.pps_list[i].end());
   }
   return true;
 }
 
+// Verifies AnnexB NALU order according to ISO/IEC 14496-10 Section 7.4.1.2.3
+bool AVC::IsValidAnnexB(const std::vector<uint8>& buffer) {
+  DVLOG(1) << __FUNCTION__;
+
+  if (buffer.empty())
+    return true;
+
+  H264Parser parser;
+  parser.SetStream(&buffer[0], buffer.size());
+
+  typedef enum {
+    kExpectAUD,
+    kExpectSPS,
+    kExpectSPSExt,
+    kExpectPPS,
+    kExpectSEI,
+    kExpectReserved, // nal_unit_types 14-18
+    kExpectVCL, // nal_unit_types 1-5
+    kExpectEOStream,
+    kExpectNoMoreData,
+  } NALUOrderStates;
+
+
+  H264NALU nalu;
+  NALUOrderStates order_state = kExpectAUD;
+  for (bool done = false; !done;) {
+    switch (parser.AdvanceToNextNALU(&nalu)) {
+      case H264Parser::kOk:
+        DVLOG(1) << " nal_unit_type " << nalu.nal_unit_type;
+
+        switch (nalu.nal_unit_type) {
+          case H264NALU::kAUD:
+            if (order_state > kExpectAUD) {
+              DVLOG(1) << "Unexpected AUD in order_state " << order_state;
+              return false;
+            }
+
+            order_state = kExpectSPS;
+            break;
+
+          case H264NALU::kSPS:
+            if (order_state > kExpectSPSExt) {
+              DVLOG(1) << "Unexpected SPS in order_state " << order_state;
+              return false;
+            }
+            order_state = kExpectSPSExt;
+            break;
+
+          case H264NALU::kSPSExt:
+            if (order_state != kExpectSPSExt) {
+              DVLOG(1) << "Unexpected SPS extension in order_state "
+                       << order_state;
+              return false;
+              order_state = kExpectSPS;
+            }
+            break;
+
+          case H264NALU::kPPS:
+            if (order_state > kExpectPPS) {
+              DVLOG(1) << "Unexpected PPS in order_state " << order_state;
+              return false;
+            }
+            order_state = kExpectPPS;
+            break;
+
+          case H264NALU::kSEIMessage:
+            if (order_state > kExpectSEI) {
+              DVLOG(1) << "Unexpected SEI in order_state " << order_state;
+              return false;
+            }
+
+            if (order_state < kExpectSEI)
+              order_state = kExpectSEI;
+            break;
+
+          case H264NALU::kReserved14:
+          case H264NALU::kReserved15:
+          case H264NALU::kReserved16:
+          case H264NALU::kReserved17:
+          case H264NALU::kReserved18:
+            if (order_state > kExpectReserved) {
+              DVLOG(1) << "Unexpected reserved NALU in order_state "
+                       << order_state;
+              return false;
+            }
+
+            if (order_state < kExpectReserved)
+              order_state = kExpectReserved;
+            break;
+
+          case H264NALU::kNonIDRSlice:
+          case H264NALU::kSliceDataA:
+          case H264NALU::kSliceDataB:
+          case H264NALU::kSliceDataC:
+          case H264NALU::kIDRSlice:
+            if (order_state > kExpectVCL) {
+              DVLOG(1) << "Unexpected VCL in order_state " << order_state;
+              return false;
+            }
+
+            if (order_state < kExpectVCL)
+              order_state = kExpectVCL;
+            break;
+
+          case H264NALU::kCodedSliceAux:
+            if (order_state != kExpectVCL) {
+              DVLOG(1) << "Unexpected extension in order_state " << order_state;
+              return false;
+            }
+            break;
+
+          case H264NALU::kEOSeq:
+            if (order_state != kExpectVCL) {
+              DVLOG(1) << "Unexpected EOSeq in order_state " << order_state;
+              return false;
+            }
+
+            order_state = kExpectEOStream;
+            break;
+
+          case H264NALU::kEOStream:
+            if (order_state < kExpectVCL) {
+              DVLOG(1) << "Unexpected EOStream in order_state " << order_state;
+              return false;
+            }
+
+            order_state = kExpectNoMoreData;
+            break;
+
+          case H264NALU::kFiller:
+          case H264NALU::kUnspecified:
+            if (order_state < kExpectVCL)
+              return false;
+            break;
+
+          default:
+            DCHECK_GE(nalu.nal_unit_type, 20);
+
+            if (nalu.nal_unit_type >= 20 && nalu.nal_unit_type <= 31 &&
+                order_state != kExpectVCL) {
+              DVLOG(1) << "Unexpected reserved/unspecified unit in order_state "
+                       << order_state;
+              return false;
+            }
+
+            continue;
+        };
+        break;
+
+      case H264Parser::kInvalidStream:
+      case H264Parser::kUnsupportedStream:
+        return false;
+
+      case H264Parser::kEOStream:
+        done = true;
+    }
+  }
+
+  return order_state >= kExpectVCL;
+}
+
 }  // namespace mp4
 }  // namespace media