Roll FFMpeg for M26. Fix ffmpeg float audio decoding.

media/filters/ffmpeg_audio_decoder.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/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
+#include "media/base/audio_bus.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/pipeline.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 
 namespace media {
 
@@ skipping 121 matching lines @@
 
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (!codec || avcodec_open2(codec_context_, codec, NULL) < 0) {
     DLOG(ERROR) << "Could not initialize audio decoder: "
                 << codec_context_->codec_id;
 
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
+  // Some codecs will only output float data, so we need to convert to integer
+  // before returning the decoded buffer.
+  if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP ||
+      codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
+    DCHECK_EQ(static_cast<size_t>(config.bits_per_channel()), sizeof(float));
+
+    // Preallocate the AudioBus for float conversions.  We can treat interleaved
+    // float data as a single planar channel since our output is expected in an
+    // interleaved format anyways.
+    int channels = codec_context_->channels;
+    if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT)
+      channels = 1;
+    converter_bus_ = AudioBus::CreateWrapper(channels);
+  }
+
   // Success!
   av_frame_ = avcodec_alloc_frame();
   bits_per_channel_ = config.bits_per_channel();
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
   bytes_per_frame_ = codec_context_->channels * bits_per_channel_ / 8;
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegAudioDecoder::DoReset(const base::Closure& closure) {
@@ skipping 126 matching lines @@
       if (output_bytes_to_drop_ > 0) {
         // Currently Vorbis is the only codec that causes us to drop samples.
         // If we have to drop samples it always means the timeline starts at 0.
         DCHECK(is_vorbis);
         output_timestamp_base_ = base::TimeDelta();
       } else {
         output_timestamp_base_ = input->GetTimestamp();
       }
     }
 
-    const uint8* decoded_audio_data = NULL;
     int decoded_audio_size = 0;
     if (frame_decoded) {
       int output_sample_rate = av_frame_->sample_rate;
       if (output_sample_rate != samples_per_second_) {
         DLOG(ERROR) << "Output sample rate (" << output_sample_rate
                     << ") doesn't match expected rate " << samples_per_second_;
 
         // This is an unrecoverable error, so bail out.
         QueuedAudioBuffer queue_entry = { kDecodeError, NULL };
         queued_audio_.push_back(queue_entry);
         break;
       }
 
-      decoded_audio_data = av_frame_->data[0];
       decoded_audio_size = av_samples_get_buffer_size(
           NULL, codec_context_->channels, av_frame_->nb_samples,
           codec_context_->sample_fmt, 1);
     }
 
-    scoped_refptr<DataBuffer> output;
+    int start_sample = 0;
+    if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
+      DCHECK_EQ(decoded_audio_size % bytes_per_frame_, 0)
+          << "Decoder didn't output full frames";
 
-    if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
       int dropped_size = std::min(decoded_audio_size, output_bytes_to_drop_);
-      decoded_audio_data += dropped_size;
+      start_sample = dropped_size / bytes_per_frame_;
       decoded_audio_size -= dropped_size;
       output_bytes_to_drop_ -= dropped_size;
     }
 
+    scoped_refptr<DataBuffer> output;
     if (decoded_audio_size > 0) {
       DCHECK_EQ(decoded_audio_size % bytes_per_frame_, 0)
           << "Decoder didn't output full frames";
 
-      // Copy the audio samples into an output buffer.
-      output = new DataBuffer(decoded_audio_data, decoded_audio_size);
+      // Convert float data using an AudioBus.
+      if (converter_bus_) {
+        // Setup the AudioBus as a wrapper of the AVFrame data and then use
+        // AudioBus::ToInterleaved() to convert the data as necessary.

[scherkus (not reviewing), 2012/12/06 17:25:32]

don't we immediately call FromInterleaved() in ARI::Render()?

do you have a plan in mind for minimizing data format conversions? it seems
unfortunate for audio decoders to deal with converting to planar integer

[DaleCurtis, 2012/12/06 22:15:41]

Not quite immediately, but yes.  The data first goes into a
AudioRendererAlgorithm's SeekableBuffer which handles time advancement as well
as buffer hand outs.

Ideally I'd like to pass an AudioBus out of the decoder at some point, but that
involves reworking AudioRendererAlgorithm.  Wd need to replace its use of
SeekableBuffer with something like an AudioFIFO which understands timestamp
information.

+        int skip_frames = start_sample;
+        int total_frames = av_frame_->nb_samples - start_sample;
+        if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
+          DCHECK_EQ(converter_bus_->channels(), 1);
+          total_frames *= codec_context_->channels;
+          skip_frames *= codec_context_->channels;
+        }
+        converter_bus_->set_frames(total_frames);
+        DCHECK_EQ(decoded_audio_size,
+                  converter_bus_->frames() * bytes_per_frame_);
+
+        for (int i = 0; i < converter_bus_->channels(); ++i) {
+          converter_bus_->SetChannelData(i, reinterpret_cast<float*>(
+              av_frame_->extended_data[i]) + skip_frames);
+        }
+
+        output = new DataBuffer(decoded_audio_size);
+        output->SetDataSize(decoded_audio_size);
+        converter_bus_->ToInterleaved(
+            converter_bus_->frames(), bits_per_channel_ / 8,
+            output->GetWritableData());
+      } else {
+        output = new DataBuffer(
+            av_frame_->extended_data[0] + start_sample * bytes_per_frame_,
+            decoded_audio_size);
+      }
 
       base::TimeDelta timestamp = GetNextOutputTimestamp();
       total_frames_decoded_ += decoded_audio_size / bytes_per_frame_;
 
       output->SetTimestamp(timestamp);
       output->SetDuration(GetNextOutputTimestamp() - timestamp);
     } else if (IsEndOfStream(result, decoded_audio_size, input)) {
       DCHECK_EQ(packet.size, 0);
       // Create an end of stream output buffer.
       output = new DataBuffer(0);
@@ skipping 32 matching lines @@
 }
 
 base::TimeDelta FFmpegAudioDecoder::GetNextOutputTimestamp() const {
   DCHECK(output_timestamp_base_ != kNoTimestamp());
   double decoded_us = (total_frames_decoded_ / samples_per_second_) *
       base::Time::kMicrosecondsPerSecond;
   return output_timestamp_base_ + base::TimeDelta::FromMicroseconds(decoded_us);
 }
 
 }  // namespace media