[cast/test] Use AudioConverter in FakeMediaSource to play back 6-channel WEBM's.

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 "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/media.h"
-#include "media/base/multi_channel_resampler.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/ffmpeg_deleters.h"
 #include "media/filters/audio_renderer_algorithm.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/in_memory_url_protocol.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace {
 
-static const int kAudioChannels = 2;
-static const int kAudioSamplingFrequency = 48000;
 static const int kSoundFrequency = 440;  // Frequency of sinusoid wave.
 static const float kSoundVolume = 0.10f;
 static const int kAudioFrameMs = 10;  // Each audio frame is exactly 10ms.
 static const int kAudioPacketsPerSecond = 1000 / kAudioFrameMs;
 
 // Bounds for variable frame size mode.
 static const int kMinFakeFrameWidth = 60;
 static const int kMinFakeFrameHeight = 34;
 static const int kStartingFakeFrameWidth = 854;
 static const int kStartingFakeFrameHeight = 480;
@@ skipping 16 matching lines @@
 }
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
 FakeMediaSource::FakeMediaSource(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     base::TickClock* clock,
+    const AudioSenderConfig& audio_config,
     const VideoSenderConfig& video_config,
     bool keep_frames)
     : task_runner_(task_runner),
+      output_audio_params_(AudioParameters::AUDIO_PCM_LINEAR,
+                           media::GuessChannelLayout(audio_config.channels),
+                           audio_config.frequency,
+                           32,
+                           audio_config.frequency / kAudioPacketsPerSecond),
       video_config_(video_config),
       keep_frames_(keep_frames),
       variable_frame_size_mode_(false),
       synthetic_count_(0),
       clock_(clock),
       audio_frame_count_(0),
       video_frame_count_(0),
       av_format_context_(NULL),
       audio_stream_index_(-1),
       playback_rate_(1.0),
       video_stream_index_(-1),
       video_frame_rate_numerator_(video_config.max_frame_rate),
       video_frame_rate_denominator_(1),
       video_first_pts_(0),
       video_first_pts_set_(false),
       weak_factory_(this) {
-  audio_bus_factory_.reset(new TestAudioBusFactory(kAudioChannels,
-                                                   kAudioSamplingFrequency,
+  CHECK(output_audio_params_.IsValid());
+  audio_bus_factory_.reset(new TestAudioBusFactory(audio_config.channels,
+                                                   audio_config.frequency,
                                                    kSoundFrequency,
                                                    kSoundVolume));
 }
 
 FakeMediaSource::~FakeMediaSource() {
 }
 
 void FakeMediaSource::SetSourceFile(const base::FilePath& video_file,
                                     int override_fps) {
   DCHECK(!video_file.empty());
@@ skipping 51 matching lines @@
           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);
-      audio_params_.Reset(
+      source_audio_params_.Reset(
           AudioParameters::AUDIO_PCM_LINEAR,
           layout,
           av_codec_context->channels,
           av_codec_context->sample_rate,
           8 * av_get_bytes_per_sample(av_codec_context->sample_fmt),
           av_codec_context->sample_rate / kAudioPacketsPerSecond);
+      CHECK(source_audio_params_.IsValid());
       LOG(INFO) << "Source file has audio.";
     } else if (av_codec->type == AVMEDIA_TYPE_VIDEO) {
       VideoFrame::Format format =
           PixelFormatToVideoFormat(av_codec_context->pix_fmt);
       if (format != VideoFrame::YV12) {
         LOG(ERROR) << "Cannot handle non YV12 video format: " << format;
         continue;
       }
       if (video_stream_index_ != -1) {
         LOG(WARNING) << "Found multiple video streams.";
@@ skipping 40 matching lines @@
   if (!is_transcoding_audio() && !is_transcoding_video()) {
     // Send fake patterns.
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FakeMediaSource::SendNextFakeFrame,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   // Send transcoding streams.
-  audio_algo_.Initialize(audio_params_);
+  audio_algo_.Initialize(source_audio_params_);
   audio_algo_.FlushBuffers();
-  audio_fifo_input_bus_ =
-      AudioBus::Create(
-          audio_params_.channels(), audio_params_.frames_per_buffer());
+  audio_fifo_input_bus_ = AudioBus::Create(
+      source_audio_params_.channels(),
+      source_audio_params_.frames_per_buffer());
   // Audio FIFO can carry all data fron AudioRendererAlgorithm.
   audio_fifo_.reset(
-      new AudioFifo(audio_params_.channels(),
+      new AudioFifo(source_audio_params_.channels(),
                     audio_algo_.QueueCapacity()));
-  audio_resampler_.reset(new media::MultiChannelResampler(
-      audio_params_.channels(),
-      static_cast<double>(audio_params_.sample_rate()) /
-      kAudioSamplingFrequency,
-      audio_params_.frames_per_buffer(),
-      base::Bind(&FakeMediaSource::ProvideData, weak_factory_.GetWeakPtr())));
+  audio_converter_.reset(new media::AudioConverter(
+      source_audio_params_, output_audio_params_, true));
+  audio_converter_->AddInput(this);
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeMediaSource::SendNextFrame, weak_factory_.GetWeakPtr()));
 }
 
 void FakeMediaSource::SendNextFakeFrame() {
   UpdateNextFrameSize();
   scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateBlackFrame(current_frame_size_);
   PopulateVideoFrame(video_frame.get(), synthetic_count_);
@@ skipping 199 matching lines @@
     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(kAudioSamplingFrequency));
+          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),
             ChannelLayoutToChromeChannelLayout(
@@ skipping 23 matching lines @@
     // Prevent overflow of audio data in the FIFO.
     if (audio_fifo_input_bus_->frames() + audio_fifo_->frames()
         <= audio_fifo_->max_frames()) {
       audio_fifo_->Push(audio_fifo_input_bus_.get());
     } else {
       LOG(WARNING) << "Audio FIFO full; dropping samples.";
     }
 
     // Make sure there's enough data to resample audio.
     if (audio_fifo_->frames() <
-        2 * audio_params_.sample_rate() / kAudioPacketsPerSecond) {
+        2 * source_audio_params_.sample_rate() / kAudioPacketsPerSecond) {
       continue;
     }
 
     scoped_ptr<media::AudioBus> resampled_bus(
         media::AudioBus::Create(
-            audio_params_.channels(),
-            kAudioSamplingFrequency / kAudioPacketsPerSecond));
-    audio_resampler_->Resample(resampled_bus->frames(),
-                               resampled_bus.get());
+            output_audio_params_.channels(),
+            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)
@@ skipping 52 matching lines @@
       return;
     }
 
     if (audio_packet)
       DecodeAudio(packet.Pass());
     else
       DecodeVideo(packet.Pass());
   }
 }
 
-void FakeMediaSource::ProvideData(int frame_delay,
-                                  media::AudioBus* output_bus) {
+double FakeMediaSource::ProvideInput(media::AudioBus* output_bus,
+                                   base::TimeDelta buffer_delay) {
   if (audio_fifo_->frames() >= output_bus->frames()) {
     audio_fifo_->Consume(output_bus, 0, output_bus->frames());
+    return 1.0;
   } else {
     LOG(WARNING) << "Not enough audio data for resampling.";
     output_bus->Zero();
+    return 0.0;
   }
 }
 
 scoped_refptr<media::VideoFrame>
 FakeMediaSource::PopOldestInsertedVideoFrame() {
   CHECK(!inserted_video_frame_queue_.empty());
   scoped_refptr<media::VideoFrame> video_frame =
       inserted_video_frame_queue_.front();
   inserted_video_frame_queue_.pop();
   return video_frame;
@@ skipping 10 matching lines @@
 AVCodecContext* FakeMediaSource::av_audio_context() {
   return av_audio_stream()->codec;
 }
 
 AVCodecContext* FakeMediaSource::av_video_context() {
   return av_video_stream()->codec;
 }
 
 }  // namespace cast
 }  // namespace media