Fix SPS/PPS insertion logic in MP4StreamParser.

media/formats/mp4/avc.cc

Index: media/formats/mp4/avc.cc
diff --git a/media/formats/mp4/avc.cc b/media/formats/mp4/avc.cc
index 6b670feba3c5dbcd03390b66baa076c81a26b4dd..f6617ea1810eb88276f32d6d773e9b296fa2529f 100644
--- a/media/formats/mp4/avc.cc
+++ b/media/formats/mp4/avc.cc
@@ -7,6 +7,8 @@
 #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"
 
@@ -20,10 +22,16 @@ 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;
@@ -48,6 +56,11 @@ bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer) {
     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);
@@ -59,6 +72,54 @@ bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer) {
 }
 
 // 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) {
@@ -87,5 +148,166 @@ bool AVC::ConvertConfigToAnnexB(
   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