Home | History | Annotate | Download | only in filters 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/filters/audio_file_reader.h"
      6 
      7 #include <cmath>
      8 
      9 #include "base/logging.h"
     10 #include "base/time/time.h"
     11 #include "media/base/audio_bus.h"
     12 #include "media/ffmpeg/ffmpeg_common.h"
     13 #include "media/filters/ffmpeg_glue.h"
     14 
     15 namespace media {
     16 
     17 AudioFileReader::AudioFileReader(FFmpegURLProtocol* protocol)
     18     : codec_context_(NULL),
     19       stream_index_(0),
     20       protocol_(protocol),
     21       channels_(0),
     22       sample_rate_(0),
     23       end_padding_(0),
     24       av_sample_format_(0) {
     25 }
     26 
     27 AudioFileReader::~AudioFileReader() {
     28   Close();
     29 }
     30 
     31 bool AudioFileReader::Open() {
     32   if (!OpenDemuxer())
     33     return false;
     34   return OpenDecoder();
     35 }
     36 
     37 bool AudioFileReader::OpenDemuxer() {
     38   glue_.reset(new FFmpegGlue(protocol_));
     39   AVFormatContext* format_context = glue_->format_context();
     40 
     41   // Open FFmpeg AVFormatContext.
     42   if (!glue_->OpenContext()) {
     43     DLOG(WARNING) << "AudioFileReader::Open() : error in avformat_open_input()";
     44     return false;
     45   }
     46 
     47   // Get the codec context.
     48   codec_context_ = NULL;
     49   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     50     AVCodecContext* c = format_context->streams[i]->codec;
     51     if (c->codec_type == AVMEDIA_TYPE_AUDIO) {
     52       codec_context_ = c;
     53       stream_index_ = i;
     54       break;
     55     }
     56   }
     57 
     58   // Get the codec.
     59   if (!codec_context_)
     60     return false;
     61 
     62   const int result = avformat_find_stream_info(format_context, NULL);
     63   if (result < 0) {
     64     DLOG(WARNING)
     65         << "AudioFileReader::Open() : error in avformat_find_stream_info()";
     66     return false;
     67   }
     68 
     69   // Attempt to extract end padding for mp3 files.
     70   if (strcmp(format_context->iformat->name, "mp3") == 0 &&
     71       (av_opt_get_int(format_context->priv_data, "end_pad", 0, &end_padding_) <
     72            0 ||
     73        end_padding_ < 0)) {
     74     end_padding_ = 0;
     75   }
     76   return true;
     77 }
     78 
     79 bool AudioFileReader::OpenDecoder() {
     80   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
     81   if (codec) {
     82     // MP3 decodes to S16P which we don't support, tell it to use S16 instead.
     83     if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P)
     84       codec_context_->request_sample_fmt = AV_SAMPLE_FMT_S16;
     85 
     86     const int result = avcodec_open2(codec_context_, codec, NULL);
     87     if (result < 0) {
     88       DLOG(WARNING) << "AudioFileReader::Open() : could not open codec -"
     89                     << " result: " << result;
     90       return false;
     91     }
     92 
     93     // Ensure avcodec_open2() respected our format request.
     94     if (codec_context_->sample_fmt == AV_SAMPLE_FMT_S16P) {
     95       DLOG(ERROR) << "AudioFileReader::Open() : unable to configure a"
     96                   << " supported sample format - "
     97                   << codec_context_->sample_fmt;
     98       return false;
     99     }
    100   } else {
    101     DLOG(WARNING) << "AudioFileReader::Open() : could not find codec.";
    102     return false;
    103   }
    104 
    105   // Verify the channel layout is supported by Chrome.  Acts as a sanity check
    106   // against invalid files.  See http://crbug.com/171962
    107   if (ChannelLayoutToChromeChannelLayout(
    108           codec_context_->channel_layout, codec_context_->channels) ==
    109       CHANNEL_LAYOUT_UNSUPPORTED) {
    110     return false;
    111   }
    112 
    113   // Store initial values to guard against midstream configuration changes.
    114   channels_ = codec_context_->channels;
    115   sample_rate_ = codec_context_->sample_rate;
    116   av_sample_format_ = codec_context_->sample_fmt;
    117   return true;
    118 }
    119 
    120 void AudioFileReader::Close() {
    121   // |codec_context_| is a stream inside glue_->format_context(), so it is
    122   // closed when |glue_| is disposed.
    123   glue_.reset();
    124   codec_context_ = NULL;
    125 }
    126 
    127 int AudioFileReader::Read(AudioBus* audio_bus) {
    128   DCHECK(glue_.get() && codec_context_) <<
    129       "AudioFileReader::Read() : reader is not opened!";
    130 
    131   DCHECK_EQ(audio_bus->channels(), channels());
    132   if (audio_bus->channels() != channels())
    133     return 0;
    134 
    135   size_t bytes_per_sample = av_get_bytes_per_sample(codec_context_->sample_fmt);
    136 
    137   // Holds decoded audio.
    138   scoped_ptr<AVFrame, ScopedPtrAVFreeFrame> av_frame(av_frame_alloc());
    139 
    140   // Read until we hit EOF or we've read the requested number of frames.
    141   AVPacket packet;
    142   int current_frame = 0;
    143   bool continue_decoding = true;
    144 
    145   while (current_frame < audio_bus->frames() && continue_decoding &&
    146          ReadPacket(&packet)) {
    147     // Make a shallow copy of packet so we can slide packet.data as frames are
    148     // decoded from the packet; otherwise av_free_packet() will corrupt memory.
    149     AVPacket packet_temp = packet;
    150     do {
    151       // Reset frame to default values.
    152       av_frame_unref(av_frame.get());
    153 
    154       int frame_decoded = 0;
    155       int result = avcodec_decode_audio4(
    156           codec_context_, av_frame.get(), &frame_decoded, &packet_temp);
    157 
    158       if (result < 0) {
    159         DLOG(WARNING)
    160             << "AudioFileReader::Read() : error in avcodec_decode_audio4() -"
    161             << result;
    162         break;
    163       }
    164 
    165       // Update packet size and data pointer in case we need to call the decoder
    166       // with the remaining bytes from this packet.
    167       packet_temp.size -= result;
    168       packet_temp.data += result;
    169 
    170       if (!frame_decoded)
    171         continue;
    172 
    173       // Determine the number of sample-frames we just decoded.  Check overflow.
    174       int frames_read = av_frame->nb_samples;
    175       if (frames_read < 0) {
    176         continue_decoding = false;
    177         break;
    178       }
    179 
    180 #ifdef CHROMIUM_NO_AVFRAME_CHANNELS
    181       int channels = av_get_channel_layout_nb_channels(
    182           av_frame->channel_layout);
    183 #else
    184       int channels = av_frame->channels;
    185 #endif
    186       if (av_frame->sample_rate != sample_rate_ ||
    187           channels != channels_ ||
    188           av_frame->format != av_sample_format_) {
    189         DLOG(ERROR) << "Unsupported midstream configuration change!"
    190                     << " Sample Rate: " << av_frame->sample_rate << " vs "
    191                     << sample_rate_
    192                     << ", Channels: " << channels << " vs "
    193                     << channels_
    194                     << ", Sample Format: " << av_frame->format << " vs "
    195                     << av_sample_format_;
    196 
    197         // This is an unrecoverable error, so bail out.
    198         continue_decoding = false;
    199         break;
    200       }
    201 
    202       // Truncate, if necessary, if the destination isn't big enough.
    203       if (current_frame + frames_read > audio_bus->frames()) {
    204         DLOG(ERROR) << "Truncating decoded data due to output size.";
    205         frames_read = audio_bus->frames() - current_frame;
    206       }
    207 
    208       // Deinterleave each channel and convert to 32bit floating-point with
    209       // nominal range -1.0 -> +1.0.  If the output is already in float planar
    210       // format, just copy it into the AudioBus.
    211       if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
    212         float* decoded_audio_data = reinterpret_cast<float*>(av_frame->data[0]);
    213         int channels = audio_bus->channels();
    214         for (int ch = 0; ch < channels; ++ch) {
    215           float* bus_data = audio_bus->channel(ch) + current_frame;
    216           for (int i = 0, offset = ch; i < frames_read;
    217                ++i, offset += channels) {
    218             bus_data[i] = decoded_audio_data[offset];
    219           }
    220         }
    221       } else if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP) {
    222         for (int ch = 0; ch < audio_bus->channels(); ++ch) {
    223           memcpy(audio_bus->channel(ch) + current_frame,
    224                  av_frame->extended_data[ch], sizeof(float) * frames_read);
    225         }
    226       } else {
    227         audio_bus->FromInterleavedPartial(
    228             av_frame->data[0], current_frame, frames_read, bytes_per_sample);
    229       }
    230 
    231       current_frame += frames_read;
    232     } while (packet_temp.size > 0);
    233     av_free_packet(&packet);
    234   }
    235 
    236   // If decoding completed successfully try to strip end padding.
    237   if (continue_decoding && end_padding_ <= current_frame) {
    238     DCHECK_GE(end_padding_, 0);
    239     current_frame -= end_padding_;
    240   }
    241 
    242   // Zero any remaining frames.
    243   audio_bus->ZeroFramesPartial(
    244       current_frame, audio_bus->frames() - current_frame);
    245 
    246   // Returns the actual number of sample-frames decoded.
    247   // Ideally this represents the "true" exact length of the file.
    248   return current_frame;
    249 }
    250 
    251 base::TimeDelta AudioFileReader::GetDuration() const {
    252   const AVRational av_time_base = {1, AV_TIME_BASE};
    253 
    254   // Add one microsecond to avoid rounding-down errors which can occur when
    255   // |duration| has been calculated from an exact number of sample-frames.
    256   // One microsecond is much less than the time of a single sample-frame
    257   // at any real-world sample-rate.
    258   return ConvertFromTimeBase(av_time_base,
    259                              glue_->format_context()->duration + 1);
    260 }
    261 
    262 int AudioFileReader::GetNumberOfFrames() const {
    263   return static_cast<int>(ceil(GetDuration().InSecondsF() * sample_rate()));
    264 }
    265 
    266 bool AudioFileReader::OpenDemuxerForTesting() {
    267   return OpenDemuxer();
    268 }
    269 
    270 bool AudioFileReader::ReadPacketForTesting(AVPacket* output_packet) {
    271   return ReadPacket(output_packet);
    272 }
    273 
    274 bool AudioFileReader::ReadPacket(AVPacket* output_packet) {
    275   while (av_read_frame(glue_->format_context(), output_packet) >= 0 &&
    276          av_dup_packet(output_packet) >= 0) {
    277     // Skip packets from other streams.
    278     if (output_packet->stream_index != stream_index_) {
    279       av_free_packet(output_packet);
    280       continue;
    281     }
    282     return true;
    283   }
    284   return false;
    285 }
    286 
    287 bool AudioFileReader::SeekForTesting(base::TimeDelta seek_time) {
    288   return av_seek_frame(glue_->format_context(),
    289                        stream_index_,
    290                        ConvertToTimeBase(codec_context_->time_base, seek_time),
    291                        AVSEEK_FLAG_BACKWARD) >= 0;
    292 }
    293 
    294 const AVStream* AudioFileReader::GetAVStreamForTesting() const {
    295   return glue_->format_context()->streams[stream_index_];
    296 }
    297 
    298 }  // namespace media
    299