Implement support for vp9 in ISO-BMFF

media/formats/mp4/box_definitions.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/box_definitions.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "media/base/video_types.h"
@@ skipping 460 matching lines @@
 
 VideoSampleEntry::~VideoSampleEntry() {}
 FourCC VideoSampleEntry::BoxType() const {
   DCHECK(false) << "VideoSampleEntry should be parsed according to the "
                 << "handler type recovered in its Media ancestor.";
   return FOURCC_NULL;
 }
 
 namespace {
 
-bool IsFormatValidH264(const FourCC& format,
-                       const ProtectionSchemeInfo& sinf) {
-  return format == FOURCC_AVC1 || format == FOURCC_AVC3 ||
-      (format == FOURCC_ENCV && (sinf.format.format == FOURCC_AVC1 ||
-                                 sinf.format.format == FOURCC_AVC3));
+bool IsFormatValidH264(FourCC format) {
+  return format == FOURCC_AVC1 || format == FOURCC_AVC3;
 }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-bool IsFormatValidHEVC(const FourCC& format,
-                       const ProtectionSchemeInfo& sinf) {
-  return format == FOURCC_HEV1 || format == FOURCC_HVC1 ||
-      (format == FOURCC_ENCV && (sinf.format.format == FOURCC_HEV1 ||
-                                 sinf.format.format == FOURCC_HVC1));
+bool IsFormatValidHEVC(FourCC format) {
+  return format == FOURCC_HEV1 || format == FOURCC_HVC1;
 }
 #endif
 
+bool IsFormatValidVpx(FourCC format) {
+  return format == FOURCC_VP08 || format == FOURCC_VP09;
+}
+
 }
 
 bool VideoSampleEntry::Parse(BoxReader* reader) {
   format = reader->type();
   RCHECK(reader->SkipBytes(6) &&
          reader->Read2(&data_reference_index) &&
          reader->SkipBytes(16) &&
          reader->Read2(&width) &&
          reader->Read2(&height) &&
          reader->SkipBytes(50));
 
   RCHECK(reader->ScanChildren() &&
          reader->MaybeReadChild(&pixel_aspect));
 
   if (format == FOURCC_ENCV) {
     // Continue scanning until a recognized protection scheme is found, or until
     // we run out of protection schemes.
     while (sinf.type.type != FOURCC_CENC) {
       if (!reader->ReadChild(&sinf))
         return false;
     }
   }
 
-  if (IsFormatValidH264(format, sinf)) {
+  const FourCC actual_format =
+      format == FOURCC_ENCV ? sinf.format.format : format;
+  if (IsFormatValidH264(actual_format)) {
     DVLOG(2) << __FUNCTION__
              << " reading AVCDecoderConfigurationRecord (avcC)";
     scoped_ptr<AVCDecoderConfigurationRecord> avcConfig(
         new AVCDecoderConfigurationRecord());
     RCHECK(reader->ReadChild(avcConfig.get()));
     frame_bitstream_converter =
         make_scoped_refptr(new AVCBitstreamConverter(std::move(avcConfig)));
     video_codec = kCodecH264;
     video_codec_profile = H264PROFILE_MAIN;
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  } else if (IsFormatValidHEVC(format, sinf)) {
+  } else if (IsFormatValidHEVC(actual_format)) {
     DVLOG(2) << __FUNCTION__
              << " parsing HEVCDecoderConfigurationRecord (hvcC)";
     scoped_ptr<HEVCDecoderConfigurationRecord> hevcConfig(
         new HEVCDecoderConfigurationRecord());
     RCHECK(reader->ReadChild(hevcConfig.get()));
     frame_bitstream_converter =
         make_scoped_refptr(new HEVCBitstreamConverter(std::move(hevcConfig)));
     video_codec = kCodecHEVC;
 #endif
+  } else if (IsFormatValidVpx(actual_format)) {
+    frame_bitstream_converter = NULL;
+    switch (actual_format) {
+      case FOURCC_VP08:
+        video_codec = kCodecVP8;
+        video_codec_profile = VP8PROFILE_ANY;
+        break;
+      case FOURCC_VP09:
+        video_codec = kCodecVP9;
+        video_codec_profile = VP9PROFILE_ANY;
+        break;
+      default:
+        NOTREACHED() << "Unexpected format " << actual_format;
+    }
   } else {
     // Unknown/unsupported format
     MEDIA_LOG(ERROR, reader->media_log()) << __FUNCTION__
                                           << " unsupported video format "
                                           << FourCCToString(format);
     return false;
   }
 
   return true;
 }
 
 bool VideoSampleEntry::IsFormatValid() const {
+  const FourCC actual_format =
+      format == FOURCC_ENCV ? sinf.format.format : format;
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (IsFormatValidHEVC(format, sinf))
+  if (IsFormatValidHEVC(actual_format))
     return true;
 #endif
-  return IsFormatValidH264(format, sinf);
+  if (IsFormatValidH264(actual_format))
+    return true;
+  if (IsFormatValidVpx(actual_format))
+    return true;
+  return false;
 }
 
 ElementaryStreamDescriptor::ElementaryStreamDescriptor()
     : object_type(kForbidden) {}
 
 ElementaryStreamDescriptor::~ElementaryStreamDescriptor() {}
 
 FourCC ElementaryStreamDescriptor::BoxType() const {
   return FOURCC_ESDS;
 }
@@ skipping 474 matching lines @@
 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
     size_t i) const {
   if (i >= sample_depends_on_.size())
     return kSampleDependsOnUnknown;
 
   return sample_depends_on_[i];
 }
 
 }  // namespace mp4
 }  // namespace media