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"
@@ skipping 286 matching lines @@
         natural_size =
             GetNaturalSize(visible_rect.size(), entry.pixel_aspect.h_spacing,
                            entry.pixel_aspect.v_spacing);
       } else if (track->header.width && track->header.height) {
         natural_size =
             gfx::Size(track->header.width, track->header.height);
       }
 
       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, PIXEL_FORMAT_YV12,
-                              COLOR_SPACE_HD_REC709, coded_size, visible_rect,
-                              natural_size,
+      video_config.Initialize(entry.video_codec, entry.video_codec_profile,

[wolenetz, 2015/09/02 20:43:18]

nit: if we don't already DVLOG(1) entry.video_codec, this CL seems like a good
time to do that.

[servolk, 2015/09/03 00:17:51]

We already log codec info into media_log when parsing avcC/hvcC boxes, that
should probably sufficient (and we have more detailed information there, so if
we want more details we should expand logging there, instead of adding it here).

[wolenetz, 2015/09/08 19:53:10]

Acknowledged.

+                              PIXEL_FORMAT_YV12, COLOR_SPACE_HD_REC709,
+                              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_);
       has_video_ = true;
       video_track_id_ = track->header.track_id;
     }
   }
 
   RCHECK(config_cb_.Run(audio_config, video_config, TextTrackConfigMap()));
 
@@ skipping 150 matching lines @@
       return false;
     }
     subsamples = decrypt_config->subsamples();
   }
 
   std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
   if (video) {
     DCHECK(runs_->video_description().frame_bitstream_converter);
     if (!runs_->video_description().frame_bitstream_converter->ConvertFrame(
         &frame_buf, runs_->is_keyframe(), &subsamples)) {
-      MEDIA_LOG(ERROR, media_log_) << "Failed to prepare AVC sample for decode";
+      MEDIA_LOG(ERROR, media_log_)
+          << "Failed to prepare video sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (audio) {
     if (ESDescriptor::IsAAC(runs_->audio_description().esds.object_type) &&
         !PrepareAACBuffer(runs_->audio_description().esds.aac,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(ERROR, media_log_) << "Failed to prepare AAC sample for decode";
@@ skipping 128 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media