Revert of 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 <memory>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 576 matching lines @@
 
 VideoSampleEntry::VideoSampleEntry(const VideoSampleEntry& other) = default;
 
 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;
     }
   }
 
-  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)";
-      std::unique_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 (IsFormatValidH264(format, sinf)) {
+    DVLOG(2) << __FUNCTION__
+             << " reading AVCDecoderConfigurationRecord (avcC)";
+    std::unique_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)
-    case FOURCC_HEV1:
-    case FOURCC_HVC1: {
-      DVLOG(2) << __FUNCTION__
-               << " parsing HEVCDecoderConfigurationRecord (hvcC)";
-      std::unique_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;
-    }
+  } else if (IsFormatValidHEVC(format, sinf)) {
+    DVLOG(2) << __FUNCTION__
+             << " parsing HEVCDecoderConfigurationRecord (hvcC)";
+    std::unique_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
-#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
-    case FOURCC_VP09:
-      frame_bitstream_converter = NULL;
-      video_codec = kCodecVP9;
-      // TODO(kqyang): Read VPCodecConfiguration and extract profile
-      // (crbug.com/604863).
-      break;
-#endif
-    default:
-      // Unknown/unsupported format
-      MEDIA_LOG(ERROR, reader->media_log()) << __FUNCTION__
-                                            << " unsupported video format "
-                                            << FourCCToString(actual_format);
-      return false;
+  } 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;
-  switch (actual_format) {
-    case FOURCC_AVC1:
-    case FOURCC_AVC3:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-    case FOURCC_HEV1:
-    case FOURCC_HVC1:
+  if (IsFormatValidHEVC(format, sinf))
+    return true;
 #endif
-#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
-    case FOURCC_VP09:
-#endif
-      return true;
-    default:
-      return false;
-  }
+  return IsFormatValidH264(format, sinf);
 }
 
 ElementaryStreamDescriptor::ElementaryStreamDescriptor()
     : object_type(kForbidden) {}
 
 ElementaryStreamDescriptor::ElementaryStreamDescriptor(
     const ElementaryStreamDescriptor& other) = default;
 
 ElementaryStreamDescriptor::~ElementaryStreamDescriptor() {}
 
@@ skipping 530 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