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 "base/strings/string_number_conversions.h"
@@ skipping 457 matching lines @@
       video_codec(kUnknownVideoCodec),
       video_codec_profile(VIDEO_CODEC_PROFILE_UNKNOWN) {}
 
 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));
-}
-
-#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));
-}
-#endif
-
-}
-
 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)) {
-    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;
+  const FourCC actual_format =
+      format == FOURCC_ENCV ? sinf.format.format : format;
+  switch (actual_format) {
+    case FOURCC_AVC1:
+    case FOURCC_AVC3: {
+      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;
+      break;
+    }
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  } else if (IsFormatValidHEVC(format, sinf)) {
-    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;
+    case FOURCC_HEV1:
+    case FOURCC_HVC1: {
+      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;
+      break;
+    }
 #endif
-  } else {
-    // Unknown/unsupported format
-    MEDIA_LOG(ERROR, reader->media_log()) << __FUNCTION__
-                                          << " unsupported video format "
-                                          << FourCCToString(format);
-    return false;
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+    case FOURCC_VP09:
+      frame_bitstream_converter = NULL;
+      video_codec = kCodecVP9;
+      video_codec_profile = VP9PROFILE_ANY;
+      break;
+#endif
+    default:
+      // Unknown/unsupported format
+      MEDIA_LOG(ERROR, reader->media_log()) << __FUNCTION__
+                                            << " unsupported video format "
+                                            << FourCCToString(actual_format);
+      return false;
   }
 
   return true;
 }
 
 bool VideoSampleEntry::IsFormatValid() const {
+  const FourCC actual_format =
+      format == FOURCC_ENCV ? sinf.format.format : format;
+  switch (actual_format) {
+    case FOURCC_AVC1:
+    case FOURCC_AVC3:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (IsFormatValidHEVC(format, sinf))
-    return true;
+    case FOURCC_HEV1:
+    case FOURCC_HVC1:
 #endif
-  return IsFormatValidH264(format, sinf);
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+    case FOURCC_VP09:
+#endif
+      return true;
+    default:
+      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