Implemented HEVC video demuxing and parsing

media/formats/mp4/mp4_stream_parser.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/mp4_stream_parser.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
-#include "media/base/video_util.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/box_reader.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mpeg/adts_constants.h"
 
+#if defined(USE_PROPRIETARY_CODECS) && defined(ENABLE_HEVC_DEMUXING)
+#include "media/formats/mp4/hevc.h"
+#endif
+
 namespace media {
 namespace mp4 {
 
 MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
                                  bool has_sbr)
     : state_(kWaitingForInit),
       moof_head_(0),
       mdat_tail_(0),
       highest_end_offset_(0),
       has_audio_(false),
@@ skipping 240 matching lines @@
           0);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
     if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
       const VideoSampleEntry& entry = samp_descr.video_entries[desc_idx];
 
-      if (!entry.IsFormatValid()) {
+      video_config = entry.GetVideoDecoderConfig();
+      if (!video_config.IsValidConfig()) {
         MEDIA_LOG(ERROR, log_cb_) << "Unsupported video format 0x" << std::hex
                                   << entry.format << " in stsd box.";
         return false;
       }
 
-      // TODO(strobe): Recover correct crop box
-      gfx::Size coded_size(entry.width, entry.height);
-      gfx::Rect visible_rect(coded_size);
-      gfx::Size natural_size = GetNaturalSize(visible_rect.size(),
-                                              entry.pixel_aspect.h_spacing,
-                                              entry.pixel_aspect.v_spacing);
       is_video_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_video_track_encrypted_: " << is_video_track_encrypted_;
-      video_config.Initialize(kCodecH264, H264PROFILE_MAIN, VideoFrame::YV12,
-                              VideoFrame::COLOR_SPACE_UNSPECIFIED, coded_size,
-                              visible_rect, natural_size,
-                              // No decoder-specific buffer needed for AVC;
-                              // SPS/PPS are embedded in the video stream
-                              NULL, 0, is_video_track_encrypted_, false);
       has_video_ = true;
       video_track_id_ = track->header.track_id;
     }
   }
 
   RCHECK(config_cb_.Run(audio_config, video_config, TextTrackConfigMap()));
 
   StreamParser::InitParameters params(kInfiniteDuration());
   if (moov_->extends.header.fragment_duration > 0) {
     params.duration = TimeDeltaFromRational(
@@ skipping 84 matching lines @@
     // 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));
   }
 
   DCHECK(AVC::IsValidAnnexB(*frame_buf, *subsamples));
   return true;
 }
 
+#if defined(USE_PROPRIETARY_CODECS) && defined(ENABLE_HEVC_DEMUXING)
+bool MP4StreamParser::PrepareHEVCBuffer(
+    const HEVCDecoderConfigurationRecord& hevc_config,
+    std::vector<uint8>* frame_buf,
+    std::vector<SubsampleEntry>* subsamples) const {
+  DVLOG(2) << __FUNCTION__ << " size=" << frame_buf->size();
+  RCHECK(AVC::ConvertFrameToAnnexB(hevc_config.lengthSizeMinusOne + 1,
+                                   frame_buf));
+  if (!subsamples->empty()) {
+    const int nalu_size_diff = 4 - (hevc_config.lengthSizeMinusOne + 1);
+    size_t expected_size = runs_->sample_size() +
+        subsamples->size() * nalu_size_diff;
+    RCHECK(frame_buf->size() == expected_size);
+    for (size_t i = 0; i < subsamples->size(); i++)
+      (*subsamples)[i].clear_bytes += nalu_size_diff;
+  }
+
+  if (runs_->is_keyframe()) {
+    // If this is a keyframe, we (re-)inject HEVC params headers at the start of
+    // a frame. If subsample info is present, we also update the clear byte
+    // count for that first subsample.
+    RCHECK(HEVC::InsertParamSetsAnnexB(hevc_config, frame_buf, subsamples));
+  }
+
+  DCHECK(HEVC::IsValidAnnexB(*frame_buf, *subsamples));
+  return true;
+}
+#endif
+
 bool MP4StreamParser::PrepareAACBuffer(
     const AAC& aac_config, std::vector<uint8>* frame_buf,
     std::vector<SubsampleEntry>* subsamples) const {
   // Append an ADTS header to every audio sample.
   RCHECK(aac_config.ConvertEsdsToADTS(frame_buf));
 
   // As above, adjust subsample information to account for the headers. AAC is
   // not required to use subsample encryption, so we may need to add an entry.
   if (subsamples->empty()) {
     subsamples->push_back(SubsampleEntry(
@@ skipping 70 matching lines @@
     decrypt_config = runs_->GetDecryptConfig();
     if (!decrypt_config) {
       *err = true;
       return false;
     }
     subsamples = decrypt_config->subsamples();
   }
 
   std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
   if (video) {
-    if (!PrepareAVCBuffer(runs_->video_description().avcc,
+    VideoCodec codec =
+        runs_->video_description().GetVideoDecoderConfig().codec();
+    if (codec == kCodecH264 &&
+        !PrepareAVCBuffer(runs_->video_description().avcConfig,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(ERROR, log_cb_) << "Failed to prepare AVC sample for decode";
       *err = true;
       return false;
     }
+#if defined(USE_PROPRIETARY_CODECS) && defined(ENABLE_HEVC_DEMUXING)
+    if (codec == kCodecHEVC &&
+        !PrepareHEVCBuffer(runs_->video_description().hevcConfig,
+                           &frame_buf, &subsamples)) {
+      MEDIA_LOG(ERROR, log_cb_) << "Failed to prepare HEVC sample for decode";
+      *err = true;
+      return false;
+    }
+#endif
   }
 
   if (audio) {
     if (ESDescriptor::IsAAC(runs_->audio_description().esds.object_type) &&
         !PrepareAACBuffer(runs_->audio_description().esds.aac,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(ERROR, log_cb_) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
@@ skipping 128 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media