Fix AnnexB validation logic to work with encrypted content.

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"
@@ skipping 58 matching lines @@
                    temp.begin() + pos + nal_size);
     pos += nal_size;
   }
   return pos == temp.size();
 }
 
 // static
 bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config,
                                 std::vector<uint8>* buffer,
                                 std::vector<SubsampleEntry>* subsamples) {
-  DCHECK(AVC::IsValidAnnexB(*buffer));
+  DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
 
   scoped_ptr<H264Parser> parser(new H264Parser());
   const uint8* start = &(*buffer)[0];
-  parser->SetStream(start, buffer->size());
+  parser->SetStream(start, buffer->size(), *subsamples);
 
   H264NALU nalu;
   if (parser->AdvanceToNextNALU(&nalu) != H264Parser::kOk)
     return false;
 
   std::vector<uint8>::iterator config_insert_point = buffer->begin();
   std::vector<SubsampleEntry>::iterator subsamples_insert_point =
       subsamples->begin();
 
   if (nalu.nal_unit_type == H264NALU::kAUD) {
@@ skipping 25 matching lines @@
 
   if (!subsamples->empty()) {
     subsamples->insert(subsamples_insert_point,
                        config_subsamples.begin(),
                        config_subsamples.end());
   }
 
   buffer->insert(config_insert_point,
                  param_sets.begin(), param_sets.end());
 
-  DCHECK(AVC::IsValidAnnexB(*buffer));
+  DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
   return true;
 }
 
 // static
 bool AVC::ConvertConfigToAnnexB(
     const AVCDecoderConfigurationRecord& avc_config,
     std::vector<uint8>* buffer,
     std::vector<SubsampleEntry>* subsamples) {
   DCHECK(buffer->empty());
   buffer->clear();
@@ skipping 24 matching lines @@
 
     SubsampleEntry entry;
     entry.clear_bytes = kAnnexBStartCodeSize + avc_config.pps_list[i].size();
     entry.cypher_bytes = 0;
     subsamples->push_back(entry);
   }
   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) {
-  return IsValidAnnexB(&buffer[0], buffer.size());
+bool AVC::IsValidAnnexB(const std::vector<uint8>& buffer,
+                        const std::vector<SubsampleEntry>& subsamples) {
+  return IsValidAnnexB(&buffer[0], buffer.size(), subsamples);
 }
 
-bool AVC::IsValidAnnexB(const uint8* buffer, size_t size) {
+bool AVC::IsValidAnnexB(const uint8* buffer, size_t size,
+                        const std::vector<SubsampleEntry>& subsamples) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(buffer);
 
   if (size == 0)
     return true;
 
   H264Parser parser;
-  parser.SetStream(buffer, size);
+  parser.SetStream(buffer, size, subsamples);
 
   typedef enum {
     kAUDAllowed,
     kBeforeFirstVCL,  // VCL == nal_unit_types 1-5
     kAfterFirstVCL,
     kEOStreamAllowed,
     kNoMoreDataAllowed,
   } NALUOrderState;
 
   H264NALU nalu;
@@ skipping 101 matching lines @@
         NOTREACHED() << "AdvanceToNextNALU() returned kUnsupportedStream!";
         return false;
 
       case H264Parser::kEOStream:
         done = true;
     }
   }
 
   return order_state >= kAfterFirstVCL;
 }
+/*
+AVC::NALUIterator::NALUIterator(const uint8* buffer, size_t size,

[xhwang, 2014/07/10 06:23:01]

Remove?

[acolwell GONE FROM CHROMIUM, 2014/07/15 22:10:44]

Oops. Done.

+                                const std::vector<SubsampleEntry>& subsamples)
+    : buffer_(buffer),
+      subsamples_(subsamples),
+      subsample_index_(0),
+      subsample_offset_(0) {
+  parser_.SetStream(buffer, size);
+}
 
+AVC::NALUIterator::Result AVC::NALUIterator::AdvanceToNextNALU(H264NALU* nalu) {
+  for (;;) {
+    switch (parser_.AdvanceToNextNALU(nalu)) {
+      case H264Parser::kOk : {
+        if (subsamples_.empty())
+          return NALUIterator::OK;
+
+        // Compute the offset of they type field.
+        size_t nalu_type_offset = (nalu->data - buffer_);
+        bool is_inside_encrypted_section = false;
+        for(;;) {
+          if (subsample_index_ >= subsamples_.size()) {
+            DVLOG(1) << "Went beyond the end of the subsample info.";
+            return NALUIterator::ERROR;
+          }
+
+          size_t encrypted_start_offset =
+              subsample_offset_ + subsamples_[subsample_index_].clear_bytes;
+          size_t subsample_end_offset = encrypted_start_offset +
+              subsamples_[subsample_index_].cypher_bytes;
+
+          if (nalu_type_offset >= subsample_end_offset) {
+            // |nalu_type_offset| is beyond the current subsample. Move
+            // on to the next one.
+            subsample_offset_ = subsample_end_offset;
+            subsample_index_++;
+            continue;
+          }
+
+          is_inside_encrypted_section =
+              (nalu_type_offset >= encrypted_start_offset &&
+               nalu_type_offset < subsample_end_offset);
+          break;
+        }
+
+        if (is_inside_encrypted_section) {
+          DVLOG(1) << "Detected a start code inside an encrypted section."
+                   << " Looking for the next start code.";
+          continue;
+        }
+
+        return NALUIterator::OK;
+      } break;
+
+      case H264Parser::kInvalidStream:
+        return NALUIterator::ERROR;
+
+      case H264Parser::kUnsupportedStream:
+        return NALUIterator::ERROR;
+
+      case H264Parser::kEOStream:
+        return END_OF_STREAM;
+    }
+  }
+
+  return NALUIterator::OK;
+}
+*/
 }  // namespace mp4
 }  // namespace media