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->SetEncryptedStream(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.SetEncryptedStream(buffer, size, subsamples);
 
   typedef enum {
     kAUDAllowed,
     kBeforeFirstVCL,  // VCL == nal_unit_types 1-5
     kAfterFirstVCL,
     kEOStreamAllowed,
     kNoMoreDataAllowed,
   } NALUOrderState;
 
   H264NALU nalu;
@@ skipping 18 matching lines @@
           case H264NALU::kReserved14:
           case H264NALU::kReserved15:
           case H264NALU::kReserved16:
           case H264NALU::kReserved17:
           case H264NALU::kReserved18:
           case H264NALU::kPPS:
           case H264NALU::kSPS:
             if (order_state > kBeforeFirstVCL) {
               DVLOG(1) << "Unexpected NALU type " << nalu.nal_unit_type
                        << " in order_state " << order_state;
+

[xhwang, 2014/07/29 18:28:52]

extra line not needed?

[acolwell GONE FROM CHROMIUM, 2014/07/29 19:09:26]

Done.

               return false;
             }
             order_state = kBeforeFirstVCL;
             break;
 
           case H264NALU::kSPSExt:
             if (last_nalu_type != H264NALU::kSPS) {
               DVLOG(1) << "SPS extension does not follow an SPS.";
               return false;
             }
@@ skipping 63 matching lines @@
         NOTREACHED() << "AdvanceToNextNALU() returned kUnsupportedStream!";
         return false;
 
       case H264Parser::kEOStream:
         done = true;
     }
   }
 
   return order_state >= kAfterFirstVCL;
 }
-
 }  // namespace mp4
 }  // namespace media