Roll src/third_party/ffmpeg/ 3c7a09882..cdf4accee (3188 commits).

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 165 matching lines @@
 
   // Note the PRESUBMIT_IGNORE_UMA_MAX below, this silences the PRESUBMIT.py
   // check for uma enum max usage, since we're abusing
   // UMA_HISTOGRAM_ENUMERATION to report a discrete value.
   UMA_HISTOGRAM_ENUMERATION("Media.VideoColorRange", color_range,
                             AVCOL_RANGE_NB);  // PRESUBMIT_IGNORE_UMA_MAX
 }
 
 static const char kCodecNone[] = "none";
 
-static const char* GetCodecName(const AVCodecContext* context) {
-  if (context->codec_descriptor)
-    return context->codec_descriptor->name;
-  const AVCodecDescriptor* codec_descriptor =
-      avcodec_descriptor_get(context->codec_id);
+static const char* GetCodecName(enum AVCodecID id) {
+  const AVCodecDescriptor* codec_descriptor = avcodec_descriptor_get(id);
   // If the codec name can't be determined, return none for tracking.
   return codec_descriptor ? codec_descriptor->name : kCodecNone;
 }
 
 static void SetTimeProperty(MediaLogEvent* event,
                             const std::string& key,
                             base::TimeDelta value) {
   if (value == kInfiniteDuration)
     event->params.SetString(key, "kInfiniteDuration");
   else if (value == kNoTimestamp)
     event->params.SetString(key, "kNoTimestamp");
   else
     event->params.SetDouble(key, value.InSecondsF());
 }
 
 std::unique_ptr<FFmpegDemuxerStream> FFmpegDemuxerStream::Create(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
     const scoped_refptr<MediaLog>& media_log) {
   if (!demuxer || !stream)
     return nullptr;
 
   std::unique_ptr<FFmpegDemuxerStream> demuxer_stream;
   std::unique_ptr<AudioDecoderConfig> audio_config;
   std::unique_ptr<VideoDecoderConfig> video_config;
 
-  if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+  if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
     audio_config.reset(new AudioDecoderConfig());
 
     // IsValidConfig() checks that the codec is supported and that the channel
     // layout and sample format are valid.
     //
     // TODO(chcunningham): Change AVStreamToAudioDecoderConfig to check
     // IsValidConfig internally and return a null scoped_ptr if not valid.
     if (!AVStreamToAudioDecoderConfig(stream, audio_config.get()) ||
         !audio_config->IsValidConfig()) {
       MEDIA_LOG(ERROR, media_log)
           << "FFmpegDemuxer: failed creating audio stream";
       return nullptr;
     }
 
     MEDIA_LOG(INFO, media_log) << "FFmpegDemuxer: created audio stream, config "
                                << audio_config->AsHumanReadableString();
-  } else if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+  } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
     video_config.reset(new VideoDecoderConfig());
 
     // IsValidConfig() checks that the codec is supported and that the channel
     // layout and sample format are valid.
     //
     // TODO(chcunningham): Change AVStreamToVideoDecoderConfig to check
     // IsValidConfig internally and return a null scoped_ptr if not valid.
     if (!AVStreamToVideoDecoderConfig(stream, video_config.get()) ||
         !video_config->IsValidConfig()) {
       MEDIA_LOG(ERROR, media_log)
@@ skipping 36 matching lines @@
       is_enabled_(true),
       waiting_for_keyframe_(false),
       fixup_negative_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
   int rotation = 0;
   AVDictionaryEntry* rotation_entry = NULL;
 
   // Determine our media format.
-  switch (stream->codec->codec_type) {
+  switch (stream->codecpar->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       DCHECK(audio_config_.get() && !video_config_.get());
       type_ = AUDIO;
       is_encrypted = audio_config_->is_encrypted();
       break;
     case AVMEDIA_TYPE_VIDEO:
       DCHECK(video_config_.get() && !audio_config_.get());
       type_ = VIDEO;
       is_encrypted = video_config_->is_encrypted();
 
@@ skipping 194 matching lines @@
     if (start_time > base::TimeDelta())
       start_time = base::TimeDelta();
 
     buffer->set_timestamp(stream_timestamp - start_time);
 
     // If enabled, and no codec delay is present, mark audio packets with
     // negative timestamps for post-decode discard.
     if (fixup_negative_timestamps_ && is_audio &&
         stream_timestamp < base::TimeDelta() &&
         buffer->duration() != kNoTimestamp) {
-      if (!stream_->codec->delay) {
+      if (!audio_decoder_config().codec_delay()) {
         DCHECK_EQ(buffer->discard_padding().first, base::TimeDelta());
 
         if (stream_timestamp + buffer->duration() < base::TimeDelta()) {
           DCHECK_EQ(buffer->discard_padding().second, base::TimeDelta());
 
           // Discard the entire packet if it's entirely before zero.
           buffer->set_discard_padding(
               std::make_pair(kInfiniteDuration, base::TimeDelta()));
         } else {
           // Only discard part of the frame if it overlaps zero.
@@ skipping 144 matching lines @@
 
 void FFmpegDemuxerStream::ResetBitstreamConverter() {
 #if defined(USE_PROPRIETARY_CODECS)
   if (bitstream_converter_)
     InitBitstreamConverter();
 #endif  // defined(USE_PROPRIETARY_CODECS)
 }
 
 void FFmpegDemuxerStream::InitBitstreamConverter() {
 #if defined(USE_PROPRIETARY_CODECS)
-  switch (stream_->codec->codec_id) {
+  switch (stream_->codecpar->codec_id) {
     case AV_CODEC_ID_H264:
       // Clear |extra_data| so that future (fallback) decoders will know that
       // conversion is forcibly enabled on this stream.
       //
       // TODO(sandersd): Ideally we would convert |extra_data| to concatenated
       // SPS/PPS data, but it's too late to be useful because Initialize() was
       // already called on GpuVideoDecoder, which is the only path that would
       // consume that data.
       if (video_config_)
         video_config_->SetExtraData(std::vector<uint8_t>());
       bitstream_converter_.reset(
-          new FFmpegH264ToAnnexBBitstreamConverter(stream_->codec));
+          new FFmpegH264ToAnnexBBitstreamConverter(stream_->codecpar));
       break;
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
     case AV_CODEC_ID_HEVC:
       bitstream_converter_.reset(
-          new FFmpegH265ToAnnexBBitstreamConverter(stream_->codec));
+          new FFmpegH265ToAnnexBBitstreamConverter(stream_->codecpar));
       break;
 #endif
     case AV_CODEC_ID_AAC:
       bitstream_converter_.reset(
-          new FFmpegAACBitstreamConverter(stream_->codec));
+          new FFmpegAACBitstreamConverter(stream_->codecpar));
       break;
     default:
       break;
   }
 #endif  // defined(USE_PROPRIETARY_CODECS)
 }
 
 bool FFmpegDemuxerStream::SupportsConfigChanges() { return false; }
 
 AudioDecoderConfig FFmpegDemuxerStream::audio_decoder_config() {
@@ skipping 404 matching lines @@
 static int CalculateBitrate(AVFormatContext* format_context,
                             const base::TimeDelta& duration,
                             int64_t filesize_in_bytes) {
   // If there is a bitrate set on the container, use it.
   if (format_context->bit_rate > 0)
     return format_context->bit_rate;
 
   // Then try to sum the bitrates individually per stream.
   int bitrate = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
-    AVCodecContext* codec_context = format_context->streams[i]->codec;
-    bitrate += codec_context->bit_rate;
+    AVCodecParameters* codec_parameters = format_context->streams[i]->codecpar;
+    bitrate += codec_parameters->bit_rate;
   }
   if (bitrate > 0)
     return bitrate;
 
   // See if we can approximate the bitrate as long as we have a filesize and
   // valid duration.
   if (duration.InMicroseconds() <= 0 || duration == kInfiniteDuration ||
       filesize_in_bytes == 0) {
     return 0;
   }
@@ skipping 90 matching lines @@
 
   // If available, |start_time_| will be set to the lowest stream start time.
   start_time_ = kInfiniteDuration;
 
   base::TimeDelta max_duration;
   int detected_audio_track_count = 0;
   int detected_video_track_count = 0;
   int detected_text_track_count = 0;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
-    const AVCodecContext* codec_context = stream->codec;
-    const AVMediaType codec_type = codec_context->codec_type;
+    const AVCodecParameters* codec_parameters = stream->codecpar;
+    const AVMediaType codec_type = codec_parameters->codec_type;
+    const AVCodecID codec_id = codec_parameters->codec_id;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       // Log the codec detected, whether it is supported or not, and whether or
       // not we have already detected a supported codec in another stream.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodecHash",
-                                  HashCodecName(GetCodecName(codec_context)));
+                                  HashCodecName(GetCodecName(codec_id)));
       detected_audio_track_count++;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       // Log the codec detected, whether it is supported or not, and whether or
       // not we have already detected a supported codec in another stream.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodecHash",
-                                  HashCodecName(GetCodecName(codec_context)));
+                                  HashCodecName(GetCodecName(codec_id)));
       detected_video_track_count++;
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-      if (stream->codec->codec_id == AV_CODEC_ID_HEVC) {
+      if (codec_id == AV_CODEC_ID_HEVC) {
         // If ffmpeg is built without HEVC parser/decoder support, it will be
         // able to demux HEVC based solely on container-provided information,
         // but unable to get some of the parameters without parsing the stream
         // (e.g. coded size needs to be read from SPS, pixel format is typically
         // deduced from decoder config in hvcC box). These are not really needed
         // when using external decoder (e.g. hardware decoder), so override them
-        // here, to make sure this translates into a valid VideoDecoderConfig.
-        if (stream->codec->coded_width == 0 &&
-            stream->codec->coded_height == 0) {
-          DCHECK(stream->codec->width > 0);
-          DCHECK(stream->codec->height > 0);
-          stream->codec->coded_width = stream->codec->width;
-          stream->codec->coded_height = stream->codec->height;
-        }
-        if (stream->codec->pix_fmt == AV_PIX_FMT_NONE) {
-          stream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
-        }
+        // to make sure this translates into a valid VideoDecoderConfig. Coded
+        // size is overridden in AVStreamToVideoDecoderConfig().
+        if (stream->codecpar->format == AV_PIX_FMT_NONE)
+          stream->codecpar->format = AV_PIX_FMT_YUV420P;
       }
 #endif
     } else if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
       detected_text_track_count++;
-      if (codec_context->codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
+      if (codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
         continue;
       }
     } else {
       continue;
     }
 
     // Attempt to create a FFmpegDemuxerStream from the AVStream. This will
     // return nullptr if the AVStream is invalid. Validity checks will verify
     // things like: codec, channel layout, sample/pixel format, etc...
     std::unique_ptr<FFmpegDemuxerStream> demuxer_stream =
         FFmpegDemuxerStream::Create(this, stream, media_log_);
     if (demuxer_stream.get()) {
       streams_[i] = std::move(demuxer_stream);
     } else {
       if (codec_type == AVMEDIA_TYPE_AUDIO) {
         MEDIA_LOG(INFO, media_log_)
             << GetDisplayName()
             << ": skipping invalid or unsupported audio track";
       } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
         MEDIA_LOG(INFO, media_log_)
             << GetDisplayName()
             << ": skipping invalid or unsupported video track";
       }
 
       // This AVStream does not successfully convert.
       continue;
     }
 
     StreamParser::TrackId track_id = stream->id;
-
-    if ((codec_type == AVMEDIA_TYPE_AUDIO &&
-         media_tracks->getAudioConfig(track_id).IsValidConfig()) ||
-        (codec_type == AVMEDIA_TYPE_VIDEO &&
-         media_tracks->getVideoConfig(track_id).IsValidConfig())) {
-      MEDIA_LOG(INFO, media_log_)
-          << GetDisplayName()
-          << ": skipping duplicate media stream id=" << track_id;
-      continue;
-    }
-
     std::string track_label = streams_[i]->GetMetadata("handler_name");
     std::string track_language = streams_[i]->GetMetadata("language");
 
     // Some metadata is named differently in FFmpeg for webm files.
     if (strstr(format_context->iformat->name, "webm") ||
         strstr(format_context->iformat->name, "matroska")) {
       // TODO(servolk): FFmpeg doesn't set stream->id correctly for webm files.
       // Need to fix that and use it as track id. crbug.com/323183
       track_id =
           static_cast<StreamParser::TrackId>(media_tracks->tracks().size() + 1);
       track_label = streams_[i]->GetMetadata("title");
     }
 
+    if ((codec_type == AVMEDIA_TYPE_AUDIO &&
+         media_tracks->getAudioConfig(track_id).IsValidConfig()) ||
+        (codec_type == AVMEDIA_TYPE_VIDEO &&
+         media_tracks->getVideoConfig(track_id).IsValidConfig())) {
+      MEDIA_LOG(INFO, media_log_)
+          << GetDisplayName()
+          << ": skipping duplicate media stream id=" << track_id;
+      continue;
+    }
+
     // Note when we find our audio/video stream (we only want one of each) and
     // record src= playback UMA stats for the stream's decoder config.
     MediaTrack* media_track = nullptr;
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       AudioDecoderConfig audio_config = streams_[i]->audio_decoder_config();
       RecordAudioCodecStats(audio_config);
 
       media_track = media_tracks->AddAudioTrack(audio_config, track_id, "main",
                                                 track_label, track_language);
       media_track->set_id(base::UintToString(track_id));
       DCHECK(track_id_to_demux_stream_map_.find(media_track->id()) ==
              track_id_to_demux_stream_map_.end());
       track_id_to_demux_stream_map_[media_track->id()] = streams_[i].get();
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       VideoDecoderConfig video_config = streams_[i]->video_decoder_config();
 
-      RecordVideoCodecStats(video_config, stream->codec->color_range,
+      RecordVideoCodecStats(video_config, stream->codecpar->color_range,
                             media_log_.get());
 
       media_track = media_tracks->AddVideoTrack(video_config, track_id, "main",
                                                 track_label, track_language);
       media_track->set_id(base::UintToString(track_id));
       DCHECK(track_id_to_demux_stream_map_.find(media_track->id()) ==
              track_id_to_demux_stream_map_.end());
       track_id_to_demux_stream_map_[media_track->id()] = streams_[i].get();
     }
 
@@ skipping 52 matching lines @@
   // http://xiph.org/vorbis/doc/Vorbis_I_spec.html
   //
   // FFmpeg's use of negative timestamps for opus pre-skip is nonstandard, but
   // for more information on pre-skip see section 4.2 of the Ogg Opus spec:
   // https://tools.ietf.org/html/draft-ietf-codec-oggopus-08#section-4.2
   for (const auto& stream : streams_) {
     if (!stream || stream->type() != DemuxerStream::AUDIO)
       continue;
     const AVStream* audio_stream = stream->av_stream();
     DCHECK(audio_stream);
-    if (audio_stream->codec->codec_id == AV_CODEC_ID_OPUS ||
+    if (audio_stream->codecpar->codec_id == AV_CODEC_ID_OPUS ||
         (strcmp(format_context->iformat->name, "ogg") == 0 &&
-         audio_stream->codec->codec_id == AV_CODEC_ID_VORBIS)) {
+         audio_stream->codecpar->codec_id == AV_CODEC_ID_VORBIS)) {
       for (size_t i = 0; i < streams_.size(); ++i) {
         if (!streams_[i])
           continue;
         streams_[i]->enable_negative_timestamp_fixups();
 
         // Fixup the seeking information to avoid selecting the audio stream
         // simply because it has a lower starting time.
         if (streams_[i]->av_stream() == audio_stream &&
             streams_[i]->start_time() < base::TimeDelta()) {
           streams_[i]->set_start_time(base::TimeDelta());
@@ skipping 59 matching lines @@
   int video_track_count = 0;
   for (size_t i = 0; i < streams_.size(); ++i) {
     FFmpegDemuxerStream* stream = streams_[i].get();
     if (!stream)
       continue;
     if (stream->type() == DemuxerStream::AUDIO) {
       ++audio_track_count;
       std::string suffix = "";
       if (audio_track_count > 1)
         suffix = "_track" + base::IntToString(audio_track_count);
-      const AVCodecContext* audio_codec = avctx->streams[i]->codec;
+      const AVCodecParameters* audio_parameters = avctx->streams[i]->codecpar;
       const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
-      params.SetString("audio_codec_name" + suffix, GetCodecName(audio_codec));
-      params.SetInteger("audio_channels_count" + suffix, audio_codec->channels);
+      params.SetString("audio_codec_name" + suffix,
+                       GetCodecName(audio_parameters->codec_id));
+      params.SetInteger("audio_channels_count" + suffix,
+                        audio_parameters->channels);
       params.SetString("audio_sample_format" + suffix,
                        SampleFormatToString(audio_config.sample_format()));
       params.SetInteger("audio_samples_per_second" + suffix,
                         audio_config.samples_per_second());
     } else if (stream->type() == DemuxerStream::VIDEO) {
       ++video_track_count;
       std::string suffix = "";
       if (video_track_count > 1)
         suffix = "_track" + base::IntToString(video_track_count);
-      const AVCodecContext* video_codec = avctx->streams[i]->codec;
+      const AVStream* video_av_stream = avctx->streams[i];
+      const AVCodecParameters* video_parameters = video_av_stream->codecpar;
       const VideoDecoderConfig& video_config = stream->video_decoder_config();
-      params.SetString("video_codec_name" + suffix, GetCodecName(video_codec));
-      params.SetInteger("width" + suffix, video_codec->width);
-      params.SetInteger("height" + suffix, video_codec->height);
-      params.SetInteger("coded_width" + suffix, video_codec->coded_width);
-      params.SetInteger("coded_height" + suffix, video_codec->coded_height);
-      params.SetString("time_base" + suffix,
-                       base::StringPrintf("%d/%d", video_codec->time_base.num,
-                                          video_codec->time_base.den));
+      params.SetString("video_codec_name" + suffix,
+                       GetCodecName(video_parameters->codec_id));
+      params.SetInteger("width" + suffix, video_parameters->width);
+      params.SetInteger("height" + suffix, video_parameters->height);
+
+      // AVCodecParameters has no coded size fields. We gather this information
+      // during video FFmpegDemuxerStream's VideoDecoderConfig setup.
+      params.SetInteger("coded_width" + suffix,
+                        video_config.coded_size().width());
+      params.SetInteger("coded_height" + suffix,
+                        video_config.coded_size().height());
+
+      // AVCodecParameters has no time_base field. We use the one from AVStream
+      // here.
+      params.SetString(
+          "time_base" + suffix,
+          base::StringPrintf("%d/%d", video_av_stream->time_base.num,
+                             video_av_stream->time_base.den));
+
       params.SetString("video_format" + suffix,
                        VideoPixelFormatToString(video_config.format()));
       params.SetBoolean("video_is_encrypted" + suffix,
                         video_config.is_encrypted());
     }
   }
   params.SetBoolean("found_audio_stream", (audio_track_count > 0));
   params.SetBoolean("found_video_stream", (video_track_count > 0));
   SetTimeProperty(metadata_event.get(), "max_duration", max_duration);
   SetTimeProperty(metadata_event.get(), "start_time", start_time_);
@@ skipping 261 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media