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

media/filters/audio_file_reader.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/audio_file_reader.h"
 
 #include <stddef.h>
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/time/time.h"
 #include "media/base/audio_bus.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 // AAC(M4A) decoding specific constants.
 static const int kAACPrimingFrameCount = 2112;
 static const int kAACRemainderFrameCount = 519;
 
 AudioFileReader::AudioFileReader(FFmpegURLProtocol* protocol)
-    : codec_context_(NULL),
-      stream_index_(0),
+    : stream_index_(0),
       protocol_(protocol),
       audio_codec_(kUnknownAudioCodec),
       channels_(0),
       sample_rate_(0),
       av_sample_format_(0) {}
 
 AudioFileReader::~AudioFileReader() {
   Close();
 }
 
 bool AudioFileReader::Open() {
   if (!OpenDemuxer())
     return false;
   return OpenDecoder();
 }
 
 bool AudioFileReader::OpenDemuxer() {
   glue_.reset(new FFmpegGlue(protocol_));
   AVFormatContext* format_context = glue_->format_context();
 
   // Open FFmpeg AVFormatContext.
   if (!glue_->OpenContext()) {
     DLOG(WARNING) << "AudioFileReader::Open() : error in avformat_open_input()";
     return false;
   }
 
-  // Get the codec context.
-  codec_context_ = NULL;
+  // Find the first audio stream, if any.
+  codec_context_.reset();
+  bool found_stream = false;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
-    AVCodecContext* c = format_context->streams[i]->codec;
-    if (c->codec_type == AVMEDIA_TYPE_AUDIO) {
-      codec_context_ = c;
+    if (format_context->streams[i]->codecpar->codec_type ==
+        AVMEDIA_TYPE_AUDIO) {
       stream_index_ = i;
+      found_stream = true;
       break;
     }
   }
 
-  // Get the codec.
-  if (!codec_context_)
+  if (!found_stream)
     return false;
 
   const int result = avformat_find_stream_info(format_context, NULL);
   if (result < 0) {
     DLOG(WARNING)
         << "AudioFileReader::Open() : error in avformat_find_stream_info()";
     return false;
   }
 
+  // Get the codec context.
+  codec_context_ =
+      AVStreamToAVCodecContext(format_context->streams[stream_index_]);
+  if (!codec_context_)
+    return false;
+
+  DCHECK_EQ(codec_context_->codec_type, AVMEDIA_TYPE_AUDIO);
   return true;
 }
 
 bool AudioFileReader::OpenDecoder() {
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (codec) {
     // MP3 decodes to S16P which we don't support, tell it to use S16 instead.
     if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P)
       codec_context_->request_sample_fmt = AV_SAMPLE_FMT_S16;
 
-    const int result = avcodec_open2(codec_context_, codec, NULL);
+    const int result = avcodec_open2(codec_context_.get(), codec, nullptr);
     if (result < 0) {
       DLOG(WARNING) << "AudioFileReader::Open() : could not open codec -"
                     << " result: " << result;
       return false;
     }
 
     // Ensure avcodec_open2() respected our format request.
     if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P) {
       DLOG(ERROR) << "AudioFileReader::Open() : unable to configure a"
                   << " supported sample format - "
@@ skipping 15 matching lines @@
 
   // Store initial values to guard against midstream configuration changes.
   channels_ = codec_context_->channels;
   audio_codec_ = CodecIDToAudioCodec(codec_context_->codec_id);
   sample_rate_ = codec_context_->sample_rate;
   av_sample_format_ = codec_context_->sample_fmt;
   return true;
 }
 
 void AudioFileReader::Close() {
-  // |codec_context_| is a stream inside glue_->format_context(), so it is
-  // closed when |glue_| is disposed.
+  codec_context_.reset();
   glue_.reset();
-  codec_context_ = NULL;
 }
 
 int AudioFileReader::Read(AudioBus* audio_bus) {
   DCHECK(glue_.get() && codec_context_) <<
       "AudioFileReader::Read() : reader is not opened!";
 
   DCHECK_EQ(audio_bus->channels(), channels());
   if (audio_bus->channels() != channels())
     return 0;
 
@@ skipping 10 matching lines @@
   while (current_frame < audio_bus->frames() && continue_decoding &&
          ReadPacket(&packet)) {
     // 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;
     do {
       // Reset frame to default values.
       av_frame_unref(av_frame.get());
 
       int frame_decoded = 0;
-      int result = avcodec_decode_audio4(
-          codec_context_, av_frame.get(), &frame_decoded, &packet_temp);
+      int result = avcodec_decode_audio4(codec_context_.get(), av_frame.get(),
+                                         &frame_decoded, &packet_temp);
 
       if (result < 0) {
         DLOG(WARNING)
             << "AudioFileReader::Read() : error in avcodec_decode_audio4() -"
             << result;
         break;
       }
 
       // Update packet size and data pointer in case we need to call the decoder
       // with the remaining bytes from this packet.
@@ skipping 122 matching lines @@
     if (output_packet->stream_index != stream_index_) {
       av_packet_unref(output_packet);
       continue;
     }
     return true;
   }
   return false;
 }
 
 bool AudioFileReader::SeekForTesting(base::TimeDelta seek_time) {
-  return av_seek_frame(glue_->format_context(),
-                       stream_index_,
-                       ConvertToTimeBase(codec_context_->time_base, seek_time),
-                       AVSEEK_FLAG_BACKWARD) >= 0;
+  // Use the AVStream's time_base, since |codec_context_| does not have
+  // time_base populated until after OpenDecoder().
+  return av_seek_frame(
+             glue_->format_context(), stream_index_,
+             ConvertToTimeBase(GetAVStreamForTesting()->time_base, seek_time),
+             AVSEEK_FLAG_BACKWARD) >= 0;
 }
 
 const AVStream* AudioFileReader::GetAVStreamForTesting() const {
   return glue_->format_context()->streams[stream_index_];
 }
 
 }  // namespace media