Deprecate LogCB in favor of using MediaLog

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 30 matching lines @@
 MP4StreamParser::~MP4StreamParser() {}
 
 void MP4StreamParser::Init(
     const InitCB& init_cb,
     const NewConfigCB& config_cb,
     const NewBuffersCB& new_buffers_cb,
     bool /* ignore_text_tracks */,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewMediaSegmentCB& new_segment_cb,
     const base::Closure& end_of_segment_cb,
-    const LogCB& log_cb) {
+    const scoped_refptr<MediaLog>& media_log) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!new_buffers_cb.is_null());
   DCHECK(!encrypted_media_init_data_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingBoxes);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   new_buffers_cb_ = new_buffers_cb;
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
-  log_cb_ = log_cb;
+  media_log_ = media_log;
 }
 
 void MP4StreamParser::Reset() {
   queue_.Reset();
   runs_.reset();
   moof_head_ = 0;
   mdat_tail_ = 0;
 }
 
 void MP4StreamParser::Flush() {
@@ skipping 57 matching lines @@
   return true;
 }
 
 bool MP4StreamParser::ParseBox(bool* err) {
   const uint8* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(buf, size, log_cb_, err));
+      BoxReader::ReadTopLevelBox(buf, size, media_log_, err));
   if (reader.get() == NULL) return false;
 
   if (reader->type() == FOURCC_MOOV) {
     *err = !ParseMoov(reader.get());
   } else if (reader->type() == FOURCC_MOOF) {
     moof_head_ = queue_.head();
     *err = !ParseMoof(reader.get());
 
     // Set up first mdat offset for ReadMDATsUntil().
     mdat_tail_ = queue_.head() + reader->size();
@@ skipping 53 matching lines @@
       // It is not uncommon to find otherwise-valid files with incorrect sample
       // description indices, so we fail gracefully in that case.
       if (desc_idx >= samp_descr.audio_entries.size())
         desc_idx = 0;
       const AudioSampleEntry& entry = samp_descr.audio_entries[desc_idx];
       const AAC& aac = entry.esds.aac;
 
       if (!(entry.format == FOURCC_MP4A ||
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
-        MEDIA_LOG(ERROR, log_cb_) << "Unsupported audio format 0x" << std::hex
-                                  << entry.format << " in stsd box.";
+        MEDIA_LOG(ERROR, media_log_) << "Unsupported audio format 0x"
+                                     << std::hex << entry.format
+                                     << " in stsd box.";
         return false;
       }
 
       uint8 audio_type = entry.esds.object_type;
       DVLOG(1) << "audio_type " << std::hex << static_cast<int>(audio_type);
       if (audio_object_types_.find(audio_type) == audio_object_types_.end()) {
-        MEDIA_LOG(ERROR, log_cb_) << "audio object type 0x" << std::hex
-                                  << audio_type
-                                  << " does not match what is specified in the"
-                                  << " mimetype.";
+        MEDIA_LOG(ERROR, media_log_)
+            << "audio object type 0x" << std::hex << audio_type
+            << " does not match what is specified in the"
+            << " mimetype.";
         return false;
       }
 
       AudioCodec codec = kUnknownAudioCodec;
       ChannelLayout channel_layout = CHANNEL_LAYOUT_NONE;
       int sample_per_second = 0;
       std::vector<uint8> extra_data;
       // Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
       // supported MPEG2 AAC varients.
       if (ESDescriptor::IsAAC(audio_type)) {
         codec = kCodecAAC;
         channel_layout = aac.GetChannelLayout(has_sbr_);
         sample_per_second = aac.GetOutputSamplesPerSecond(has_sbr_);
 #if defined(OS_ANDROID)
         extra_data = aac.codec_specific_data();
 #endif
       } else {
-        MEDIA_LOG(ERROR, log_cb_) << "Unsupported audio object type 0x"
-                                  << std::hex << audio_type << " in esds.";
+        MEDIA_LOG(ERROR, media_log_) << "Unsupported audio object type 0x"
+                                     << std::hex << audio_type << " in esds.";
         return false;
       }
 
       SampleFormat sample_format;
       if (entry.samplesize == 8) {
         sample_format = kSampleFormatU8;
       } else if (entry.samplesize == 16) {
         sample_format = kSampleFormatS16;
       } else if (entry.samplesize == 32) {
         sample_format = kSampleFormatS32;
@@ skipping 12 matching lines @@
       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()) {
-        MEDIA_LOG(ERROR, log_cb_) << "Unsupported video format 0x" << std::hex
-                                  << entry.format << " in stsd box.";
+        MEDIA_LOG(ERROR, media_log_) << "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;
@@ skipping 40 matching lines @@
     OnEncryptedMediaInitData(moov_->pssh);
 
   return true;
 }
 
 bool MP4StreamParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   if (!runs_)
-    runs_.reset(new TrackRunIterator(moov_.get(), log_cb_));
+    runs_.reset(new TrackRunIterator(moov_.get(), media_log_));
   RCHECK(runs_->Init(moof));
   RCHECK(ComputeHighestEndOffset(moof));
 
   if (!moof.pssh.empty())
     OnEncryptedMediaInitData(moof.pssh);
 
   new_segment_cb_.Run();
   ChangeState(kWaitingForSampleData);
   return true;
 }
@@ skipping 132 matching lines @@
       *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,
                           &frame_buf, &subsamples)) {
-      MEDIA_LOG(ERROR, log_cb_) << "Failed to prepare AVC sample for decode";
+      MEDIA_LOG(ERROR, media_log_) << "Failed to prepare AVC 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, log_cb_) << "Failed to prepare AAC sample for decode";
+      MEDIA_LOG(ERROR, media_log_) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (decrypt_config) {
     if (!subsamples.empty()) {
     // Create a new config with the updated subsamples.
     decrypt_config.reset(new DecryptConfig(
         decrypt_config->key_id(),
@@ skipping 65 matching lines @@
 bool MP4StreamParser::ReadAndDiscardMDATsUntil(int64 max_clear_offset) {
   bool err = false;
   int64 upper_bound = std::min(max_clear_offset, queue_.tail());
   while (mdat_tail_ < upper_bound) {
     const uint8* buf = NULL;
     int size = 0;
     queue_.PeekAt(mdat_tail_, &buf, &size);
 
     FourCC type;
     int box_sz;
-    if (!BoxReader::StartTopLevelBox(buf, size, log_cb_,
-                                     &type, &box_sz, &err))
+    if (!BoxReader::StartTopLevelBox(buf, size, media_log_, &type, &box_sz,
+                                     &err))
       break;
 
     if (type != FOURCC_MDAT) {
-      MEDIA_LOG(DEBUG, log_cb_) << "Unexpected box type while parsing MDATs: "
-                                << FourCCToString(type);
+      MEDIA_LOG(DEBUG, media_log_)
+          << "Unexpected box type while parsing MDATs: "
+          << FourCCToString(type);
     }
     mdat_tail_ += box_sz;
   }
   queue_.Trim(std::min(mdat_tail_, upper_bound));
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 bool MP4StreamParser::HaveEnoughDataToEnqueueSamples() {
   DCHECK_EQ(state_, kWaitingForSampleData);
   // For muxed content, make sure we have data up to |highest_end_offset_|
   // so we can ensure proper enqueuing behavior. Otherwise assume we have enough
   // data and allow per sample offset checks to meter sample enqueuing.
   // TODO(acolwell): Fix trun box handling so we don't have to special case
   // muxed content.
   return !(has_audio_ && has_video_ &&
            queue_.tail() < highest_end_offset_ + moof_head_);
 }
 
 bool MP4StreamParser::ComputeHighestEndOffset(const MovieFragment& moof) {
   highest_end_offset_ = 0;
 
-  TrackRunIterator runs(moov_.get(), log_cb_);
+  TrackRunIterator runs(moov_.get(), media_log_);
   RCHECK(runs.Init(moof));
 
   while (runs.IsRunValid()) {
     int64 aux_info_end_offset = runs.aux_info_offset() + runs.aux_info_size();
     if (aux_info_end_offset > highest_end_offset_)
       highest_end_offset_ = aux_info_end_offset;
 
     while (runs.IsSampleValid()) {
       int64 sample_end_offset = runs.sample_offset() + runs.sample_size();
       if (sample_end_offset > highest_end_offset_)
         highest_end_offset_ = sample_end_offset;
 
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media