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

media/cast/test/fake_media_source.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/cast/test/fake_media_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
@@ skipping 120 matching lines @@
   // AVFormatContext is owned by the glue.
   av_format_context_ = glue_->format_context();
   if (avformat_find_stream_info(av_format_context_, NULL) < 0) {
     LOG(ERROR) << "Cannot find stream information.";
     return;
   }
 
   // Prepare FFmpeg decoders.
   for (unsigned int i = 0; i < av_format_context_->nb_streams; ++i) {
     AVStream* av_stream = av_format_context_->streams[i];
-    AVCodecContext* av_codec_context = av_stream->codec;
+    std::unique_ptr<AVCodecContext, ScopedPtrAVFreeContext> av_codec_context(
+        AVStreamToAVCodecContext(av_stream));
+    if (!av_codec_context) {
+      LOG(ERROR) << "Cannot get a codec context for the codec: "
+                 << av_stream->codecpar->codec_id;
+      continue;
+    }
+
     AVCodec* av_codec = avcodec_find_decoder(av_codec_context->codec_id);
 
     if (!av_codec) {
       LOG(ERROR) << "Cannot find decoder for the codec: "
                  << av_codec_context->codec_id;
       continue;
     }
 
     // Number of threads for decoding.
     av_codec_context->thread_count = 2;
     av_codec_context->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
     av_codec_context->request_sample_fmt = AV_SAMPLE_FMT_S16;
 
-    if (avcodec_open2(av_codec_context, av_codec, NULL) < 0) {
+    if (avcodec_open2(av_codec_context.get(), av_codec, nullptr) < 0) {
       LOG(ERROR) << "Cannot open AVCodecContext for the codec: "
                  << av_codec_context->codec_id;
       return;
     }
 
     if (av_codec->type == AVMEDIA_TYPE_AUDIO) {
       if (av_codec_context->sample_fmt == AV_SAMPLE_FMT_S16P) {
         LOG(ERROR) << "Audio format not supported.";
         continue;
       }
       ChannelLayout layout = ChannelLayoutToChromeChannelLayout(
           av_codec_context->channel_layout,
           av_codec_context->channels);
       if (layout == CHANNEL_LAYOUT_UNSUPPORTED) {
         LOG(ERROR) << "Unsupported audio channels layout.";
         continue;
       }
       if (audio_stream_index_ != -1) {
         LOG(WARNING) << "Found multiple audio streams.";
       }
       audio_stream_index_ = static_cast<int>(i);
+      av_audio_context_ = std::move(av_codec_context);
       source_audio_params_.Reset(
-          AudioParameters::AUDIO_PCM_LINEAR,
-          layout,
-          av_codec_context->sample_rate,
-          8 * av_get_bytes_per_sample(av_codec_context->sample_fmt),
-          av_codec_context->sample_rate / kAudioPacketsPerSecond);
+          AudioParameters::AUDIO_PCM_LINEAR, layout,
+          av_audio_context_->sample_rate,
+          8 * av_get_bytes_per_sample(av_audio_context_->sample_fmt),
+          av_audio_context_->sample_rate / kAudioPacketsPerSecond);
       source_audio_params_.set_channels_for_discrete(
-          av_codec_context->channels);
+          av_audio_context_->channels);
       CHECK(source_audio_params_.IsValid());
       LOG(INFO) << "Source file has audio.";
     } else if (av_codec->type == AVMEDIA_TYPE_VIDEO) {
       VideoPixelFormat format =
           AVPixelFormatToVideoPixelFormat(av_codec_context->pix_fmt);
       if (format != PIXEL_FORMAT_YV12) {
         LOG(ERROR) << "Cannot handle non YV12 video format: " << format;
         continue;
       }
       if (video_stream_index_ != -1) {
         LOG(WARNING) << "Found multiple video streams.";
       }
       video_stream_index_ = static_cast<int>(i);
+      av_video_context_ = std::move(av_codec_context);
       if (final_fps > 0) {
         // If video is played at a manual speed audio needs to match.
         playback_rate_ = 1.0 * final_fps *
             av_stream->r_frame_rate.den / av_stream->r_frame_rate.num;
         video_frame_rate_numerator_ = final_fps;
         video_frame_rate_denominator_ = 1;
       } else {
         playback_rate_ = 1.0;
         video_frame_rate_numerator_ = av_stream->r_frame_rate.num;
         video_frame_rate_denominator_ = av_stream->r_frame_rate.den;
@@ skipping 241 matching lines @@
 void FakeMediaSource::DecodeAudio(ScopedAVPacket packet) {
   // Audio.
   AVFrame* avframe = av_frame_alloc();
 
   // Make a shallow copy of packet so we can slide packet.data as frames are
   // decoded from the packet; otherwise av_packet_unref() will corrupt memory.
   AVPacket packet_temp = *packet.get();
 
   do {
     int frame_decoded = 0;
-    int result = avcodec_decode_audio4(
-        av_audio_context(), avframe, &frame_decoded, &packet_temp);
+    int result = avcodec_decode_audio4(av_audio_context_.get(), avframe,
+                                       &frame_decoded, &packet_temp);
     CHECK(result >= 0) << "Failed to decode audio.";
     packet_temp.size -= result;
     packet_temp.data += result;
     if (!frame_decoded)
       continue;
 
     int frames_read = avframe->nb_samples;
     if (frames_read < 0)
       break;
 
     if (!audio_sent_ts_) {
       // Initialize the base time to the first packet in the file.
       // This is set to the frequency we send to the receiver.
       // Not the frequency of the source file. This is because we
       // increment the frame count by samples we sent.
       audio_sent_ts_.reset(
           new AudioTimestampHelper(output_audio_params_.sample_rate()));
       // For some files this is an invalid value.
       base::TimeDelta base_ts;
       audio_sent_ts_->SetBaseTimestamp(base_ts);
     }
 
     scoped_refptr<AudioBuffer> buffer = AudioBuffer::CopyFrom(
-        AVSampleFormatToSampleFormat(av_audio_context()->sample_fmt,
-                                     av_audio_context()->codec_id),
-        ChannelLayoutToChromeChannelLayout(av_audio_context()->channel_layout,
-                                           av_audio_context()->channels),
-        av_audio_context()->channels, av_audio_context()->sample_rate,
+        AVSampleFormatToSampleFormat(av_audio_context_->sample_fmt,
+                                     av_audio_context_->codec_id),
+        ChannelLayoutToChromeChannelLayout(av_audio_context_->channel_layout,
+                                           av_audio_context_->channels),
+        av_audio_context_->channels, av_audio_context_->sample_rate,
         frames_read, &avframe->data[0],
-        PtsToTimeDelta(avframe->pkt_pts, av_audio_stream()->time_base));
+        PtsToTimeDelta(avframe->pts, av_audio_stream()->time_base));
     audio_algo_.EnqueueBuffer(buffer);
     av_frame_unref(avframe);
   } while (packet_temp.size > 0);
   av_frame_free(&avframe);
 
   const int frames_needed_to_scale =
-      playback_rate_ * av_audio_context()->sample_rate /
-      kAudioPacketsPerSecond;
+      playback_rate_ * av_audio_context_->sample_rate / kAudioPacketsPerSecond;
   while (frames_needed_to_scale <= audio_algo_.frames_buffered()) {
     if (!audio_algo_.FillBuffer(audio_fifo_input_bus_.get(), 0,
                                 audio_fifo_input_bus_->frames(),
                                 playback_rate_)) {
       // Nothing can be scaled. Decode some more.
       return;
     }
 
     // Prevent overflow of audio data in the FIFO.
     if (audio_fifo_input_bus_->frames() + audio_fifo_->frames()
@@ skipping 14 matching lines @@
         output_audio_params_.sample_rate() / kAudioPacketsPerSecond));
     audio_converter_->Convert(resampled_bus.get());
     audio_bus_queue_.push(resampled_bus.release());
   }
 }
 
 void FakeMediaSource::DecodeVideo(ScopedAVPacket packet) {
   // Video.
   int got_picture;
   AVFrame* avframe = av_frame_alloc();
-  CHECK(avcodec_decode_video2(
-      av_video_context(), avframe, &got_picture, packet.get()) >= 0)
+  CHECK(avcodec_decode_video2(av_video_context_.get(), avframe, &got_picture,
+                              packet.get()) >= 0)
       << "Video decode error.";
   if (!got_picture) {
     av_frame_free(&avframe);
     return;
   }
-  gfx::Size size(av_video_context()->width, av_video_context()->height);
+  gfx::Size size(av_video_context_->width, av_video_context_->height);
 
   if (!video_first_pts_set_) {
-    video_first_pts_ = avframe->pkt_pts;
+    video_first_pts_ = avframe->pts;
     video_first_pts_set_ = true;
   }
   const AVRational& time_base = av_video_stream()->time_base;
   base::TimeDelta timestamp =
-      PtsToTimeDelta(avframe->pkt_pts - video_first_pts_, time_base);
+      PtsToTimeDelta(avframe->pts - video_first_pts_, time_base);
   if (timestamp < last_video_frame_timestamp_) {
     // Stream has rewound.  Rebase |video_first_pts_|.
     const AVRational& frame_rate = av_video_stream()->r_frame_rate;
     timestamp = last_video_frame_timestamp_ +
         (base::TimeDelta::FromSeconds(1) * frame_rate.den / frame_rate.num);
     const int64_t adjustment_pts = TimeDeltaToPts(timestamp, time_base);
-    video_first_pts_ = avframe->pkt_pts - adjustment_pts;
+    video_first_pts_ = avframe->pts - adjustment_pts;
   }
 
   scoped_refptr<media::VideoFrame> video_frame =
       VideoFrame::WrapExternalYuvData(
           media::PIXEL_FORMAT_YV12, size, gfx::Rect(size), size,
           avframe->linesize[0], avframe->linesize[1], avframe->linesize[2],
           avframe->data[0], avframe->data[1], avframe->data[2], timestamp);
   if (!video_frame)
     return;
   video_frame_queue_.push(video_frame);
@@ skipping 46 matching lines @@
 }
 
 AVStream* FakeMediaSource::av_audio_stream() {
   return av_format_context_->streams[audio_stream_index_];
 }
 
 AVStream* FakeMediaSource::av_video_stream() {
   return av_format_context_->streams[video_stream_index_];
 }
 
-AVCodecContext* FakeMediaSource::av_audio_context() {
-  return av_audio_stream()->codec;
-}
-
-AVCodecContext* FakeMediaSource::av_video_context() {
-  return av_video_stream()->codec;
-}
-
 }  // namespace cast
 }  // namespace media