Introduce Dolby Vision video codec and Demuxer support

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 <memory>
 #include <utility>
 
@@ skipping 89 matching lines @@
     buffer->insert(buffer->end(), temp.begin() + pos,
                    temp.begin() + pos + nal_length);
     pos += nal_length;
   }
   return pos == temp.size();
 }
 
 // static
 bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config,
                                 std::vector<uint8_t>* buffer,
-                                std::vector<SubsampleEntry>* subsamples) {
-  DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
+                                std::vector<SubsampleEntry>* subsamples,
+                                bool annexb_validation) {
+  if (annexb_validation)
+    DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
 
   std::unique_ptr<H264Parser> parser(new H264Parser());
   const uint8_t* start = &(*buffer)[0];
   parser->SetEncryptedStream(start, buffer->size(), *subsamples);
 
   H264NALU nalu;
   if (parser->AdvanceToNextNALU(&nalu) != H264Parser::kOk)
     return false;
 
   std::vector<uint8_t>::iterator config_insert_point = buffer->begin();
@@ skipping 14 matching lines @@
   if (subsamples && !subsamples->empty()) {
     int subsample_index = FindSubsampleIndex(*buffer, subsamples,
                                              &(*config_insert_point));
     // Update the size of the subsample where SPS/PPS is to be inserted.
     (*subsamples)[subsample_index].clear_bytes += param_sets.size();
   }
 
   buffer->insert(config_insert_point,
                  param_sets.begin(), param_sets.end());
 
-  DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
+  if (annexb_validation)
+    DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples));
   return true;
 }
 
 // static
 bool AVC::ConvertConfigToAnnexB(const AVCDecoderConfigurationRecord& avc_config,
                                 std::vector<uint8_t>* buffer) {
   DCHECK(buffer->empty());
   buffer->clear();
   int total_size = 0;
   for (size_t i = 0; i < avc_config.sps_list.size(); i++)
@@ skipping 152 matching lines @@
       case H264Parser::kEOStream:
         done = true;
     }
   }
 
   return order_state >= kAfterFirstVCL;
 }
 
 AVCBitstreamConverter::AVCBitstreamConverter(
     std::unique_ptr<AVCDecoderConfigurationRecord> avc_config)
-    : avc_config_(std::move(avc_config)) {
+    : avc_config_(std::move(avc_config)), post_annexb_validation_(true) {
   DCHECK(avc_config_);
 }
 
 AVCBitstreamConverter::~AVCBitstreamConverter() {
 }
 
 bool AVCBitstreamConverter::ConvertFrame(
     std::vector<uint8_t>* frame_buf,
     bool is_keyframe,
     std::vector<SubsampleEntry>* subsamples) const {
   // Convert the AVC NALU length fields to Annex B headers, as expected by
   // decoding libraries. Since this may enlarge the size of the buffer, we also
   // update the clear byte count for each subsample if encryption is used to
   // account for the difference in size between the length prefix and Annex B
   // start code.
   RCHECK(AVC::ConvertFrameToAnnexB(avc_config_->length_size, frame_buf,
                                    subsamples));
 
   if (is_keyframe) {
     // If this is a keyframe, we (re-)inject SPS and PPS headers at the start of
     // a frame. If subsample info is present, we also update the clear byte
     // count for that first subsample.
-    RCHECK(AVC::InsertParamSetsAnnexB(*avc_config_, frame_buf, subsamples));
+    RCHECK(AVC::InsertParamSetsAnnexB(*avc_config_, frame_buf, subsamples,
+                                      post_annexb_validation_));
   }
 
   DCHECK(AVC::IsValidAnnexB(*frame_buf, *subsamples));
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media