Consolidate and improve audio decoding test for all decoders.

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 <cmath>
 
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 10 matching lines @@
       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;
   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;
       stream_index_ = i;
       break;
     }
   }
 
   // Get the codec.
   if (!codec_context_)
     return false;
 
-  int result = avformat_find_stream_info(format_context, NULL);
-  if (result < 0) {
-    DLOG(WARNING)
-        << "AudioFileReader::Open() : error in avformat_find_stream_info()";
-    return false;
-  }
+  const int result = avformat_find_stream_info(format_context, NULL);
+  DLOG_IF(result < 0, WARNING)
+      << "AudioFileReader::Open() : error in avformat_find_stream_info()";
+  return result >= 0;
+}
 
+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;
 
-    if ((result = avcodec_open2(codec_context_, codec, NULL)) < 0) {
+    const int result = avcodec_open2(codec_context_, codec, NULL);
+    if (result < 0) {

[wolenetz, 2014/06/19 20:56:47]

nit: consistency : s/if.../DLOG_IF like you did above?

[wolenetz, 2014/06/19 21:00:16]

actually, forget this nit... there's a case where we don't yet want to return,
so it's not worth using DLOG_IF here.

       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 - "
                   << codec_context_->sample_fmt;
       return false;
     }
   } else {
-    DLOG(WARNING) << "AudioFileReader::Open() : could not find codec -"
-                  << " result: " << result;
+    DLOG(WARNING) << "AudioFileReader::Open() : could not find codec.";
     return false;
   }
 
   // Verify the channel layout is supported by Chrome.  Acts as a sanity check
   // against invalid files.  See http://crbug.com/171962
   if (ChannelLayoutToChromeChannelLayout(
           codec_context_->channel_layout, codec_context_->channels) ==
       CHANNEL_LAYOUT_UNSUPPORTED) {
     return false;
   }
 
   // Store initial values to guard against midstream configuration changes.
   channels_ = codec_context_->channels;
   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.
   glue_.reset();
   codec_context_ = NULL;
 }
 
@@ skipping 123 matching lines @@
   // One microsecond is much less than the time of a single sample-frame
   // at any real-world sample-rate.
   return ConvertFromTimeBase(av_time_base,
                              glue_->format_context()->duration + 1);
 }
 
 int AudioFileReader::GetNumberOfFrames() const {
   return static_cast<int>(ceil(GetDuration().InSecondsF() * sample_rate()));
 }
 
+bool AudioFileReader::OpenDemuxerForTesting() {
+  return OpenDemuxer();
+}
+
 bool AudioFileReader::ReadPacketForTesting(AVPacket* output_packet) {
   return ReadPacket(output_packet);
 }
 
 bool AudioFileReader::ReadPacket(AVPacket* output_packet) {
   while (av_read_frame(glue_->format_context(), output_packet) >= 0 &&
          av_dup_packet(output_packet) >= 0) {
     // Skip packets from other streams.
     if (output_packet->stream_index != stream_index_) {
       av_free_packet(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;
+}
+
+const AVStream* AudioFileReader::GetAVStreamForTesting() const {
+  return glue_->format_context()->streams[stream_index_];
+}
+
 }  // namespace media