Log AVERROR messages from FFmpegDemuxer in chrome://media-internals.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2012 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/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <utility>
@@ skipping 229 matching lines @@
         !video_config->IsValidConfig()) {
       MEDIA_LOG(ERROR, media_log)
           << "FFmpegDemuxer: failed creating video stream";
       return nullptr;
     }
 
     MEDIA_LOG(INFO, media_log) << "FFmpegDemuxer: created video stream, config "
                                << video_config->AsHumanReadableString();
   }
 
-  return base::WrapUnique(new FFmpegDemuxerStream(
-      demuxer, stream, std::move(audio_config), std::move(video_config)));
+  return base::WrapUnique(
+      new FFmpegDemuxerStream(demuxer, stream, std::move(audio_config),
+                              std::move(video_config), media_log));
 }
 
 static void UnmarkEndOfStreamAndClearError(AVFormatContext* format_context) {
   format_context->pb->eof_reached = 0;
   format_context->pb->error = 0;
 }
 
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
     std::unique_ptr<AudioDecoderConfig> audio_config,
-    std::unique_ptr<VideoDecoderConfig> video_config)
+    std::unique_ptr<VideoDecoderConfig> video_config,
+    scoped_refptr<MediaLog> media_log)
     : demuxer_(demuxer),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       stream_(stream),
       start_time_(kNoTimestamp),
       audio_config_(audio_config.release()),
       video_config_(video_config.release()),
+      media_log_(std::move(media_log)),
       type_(UNKNOWN),
       liveness_(LIVENESS_UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp),
       last_packet_duration_(kNoTimestamp),
       video_rotation_(VIDEO_ROTATION_0),
       is_enabled_(true),
       waiting_for_keyframe_(false),
       aborted_(false),
       fixup_negative_timestamps_(false) {
@@ skipping 189 matching lines @@
     DVLOG(1) << "FFmpeg returned a buffer with a negative duration! "
              << packet->duration;
     buffer->set_duration(kNoTimestamp);
   }
 
   // Note: If pts is AV_NOPTS_VALUE, stream_timestamp will be kNoTimestamp.
   const base::TimeDelta stream_timestamp =
       ConvertStreamTimestamp(stream_->time_base, packet->pts);
 
   if (stream_timestamp == kNoTimestamp) {
+    MEDIA_LOG(ERROR, media_log_) << "FFmpegDemuxer: PTS is not defined";
     demuxer_->NotifyDemuxerError(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   const bool is_audio = type() == AUDIO;
 
   // If this file has negative timestamps don't rebase any other stream types
   // against the negative starting time.
   base::TimeDelta start_time = demuxer_->start_time();
   if (fixup_negative_timestamps_ && !is_audio &&
       start_time < base::TimeDelta()) {
     start_time = base::TimeDelta();
   }
 
   // Don't rebase timestamps for positive start times, the HTML Media Spec
   // details this in section "4.8.10.6 Offsets into the media resource." We
   // will still need to rebase timestamps before seeking with FFmpeg though.
   if (start_time > base::TimeDelta())
     start_time = base::TimeDelta();
 
   buffer->set_timestamp(stream_timestamp - start_time);
 
   // Only allow negative timestamps past if we know they'll be fixed up by the
   // code paths below; otherwise they should be treated as a parse error.
   if (!fixup_negative_timestamps_ && buffer->timestamp() < base::TimeDelta()) {
+    MEDIA_LOG(DEBUG, media_log_)
+        << "FFmpegDemuxer: unfixable negative timestamp";
     demuxer_->NotifyDemuxerError(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // If enabled, and no codec delay is present, mark audio packets with negative
   // timestamps for post-decode discard. If codec delay is present, discard is
   // handled by the decoder using that value.
   if (fixup_negative_timestamps_ && is_audio &&
       stream_timestamp < base::TimeDelta() &&
       buffer->duration() != kNoTimestamp &&
@@ skipping 1202 matching lines @@
   DCHECK(pending_read_);
   pending_read_ = false;
 
   if (stopped_ || !pending_seek_cb_.is_null())
     return;
 
   // Consider the stream as ended if:
   // - either underlying ffmpeg returned an error
   // - or FFMpegDemuxer reached the maximum allowed memory usage.
   if (result < 0 || IsMaxMemoryUsageReached()) {
-    DVLOG(1) << __func__ << " result=" << result
-             << " IsMaxMemoryUsageReached=" << IsMaxMemoryUsageReached();
+    if (result < 0) {
+      MEDIA_LOG(DEBUG, media_log_)
+          << GetDisplayName()
+          << ": av_read_frame(): " << AVErrorToString(result);
+    } else {
+      MEDIA_LOG(DEBUG, media_log_)
+          << GetDisplayName() << ": memory limit exceeded";
+    }
+
     // Update the duration based on the highest elapsed time across all streams.
     base::TimeDelta max_duration;
     for (const auto& stream : streams_) {
       if (!stream)
         continue;
 
       base::TimeDelta duration = stream->duration();
       if (duration != kNoTimestamp && duration > max_duration)
         max_duration = duration;
     }
@@ skipping 93 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media