Wire up codec_delay() to MP3StreamParser and FFmpegAudioDecoder.

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/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
@@ skipping 107 matching lines @@
 
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the AudioBuffer object.
   void* opaque = NULL;
   buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
   frame->buf[0] = av_buffer_create(
       frame->data[0], buffer_size_in_bytes, ReleaseAudioBufferImpl, opaque, 0);
   return 0;
 }
 
+static int TimeDeltaToFrames(base::TimeDelta duration, int sample_rate) {
+  return 0.5 + duration.InSecondsF() * sample_rate;
+}
+
 FFmpegAudioDecoder::FFmpegAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       state_(kUninitialized),
       av_sample_format_(0),
       last_input_timestamp_(kNoTimestamp()),
       output_frames_to_drop_(0) {}
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
   DCHECK_EQ(state_, kUninitialized);
@@ skipping 122 matching lines @@
     decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
   if (!buffer->end_of_stream()) {
     if (last_input_timestamp_ == kNoTimestamp() &&
         codec_context_->codec_id == AV_CODEC_ID_VORBIS &&
         buffer->timestamp() < base::TimeDelta()) {
       // Dropping frames for negative timestamps as outlined in section A.2
       // in the Vorbis spec. http://xiph.org/vorbis/doc/Vorbis_I_spec.html
-      output_frames_to_drop_ = floor(0.5 + -buffer->timestamp().InSecondsF() *
-                                               config_.samples_per_second());
+      output_frames_to_drop_ =
+          TimeDeltaToFrames(-buffer->timestamp(), config_.samples_per_second());
     } else {
       if (last_input_timestamp_ != kNoTimestamp() &&
           buffer->timestamp() < last_input_timestamp_) {
         const base::TimeDelta diff =
             buffer->timestamp() - last_input_timestamp_;
         DLOG(WARNING)
             << "Input timestamps are not monotonically increasing! "
             << " ts " << buffer->timestamp().InMicroseconds() << " us"
             << " diff " << diff.InMicroseconds() << " us";
       }
@@ skipping 69 matching lines @@
     }
 
     // Update packet size and data pointer in case we need to call the decoder
     // with the remaining bytes from this packet.
     packet.size -= result;
     packet.data += result;
 
     if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
         !buffer->end_of_stream()) {
       DCHECK(buffer->timestamp() != kNoTimestamp());
-      if (output_frames_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_EQ(codec_context_->codec_id, AV_CODEC_ID_VORBIS);
+      if (output_frames_to_drop_ > 0 &&
+          codec_context_->codec_id == AV_CODEC_ID_VORBIS) {
+        // If we are dropping samples for Vorbis, it always means the timeline
+        // starts at 0.
         output_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
       } else {
         output_timestamp_helper_->SetBaseTimestamp(buffer->timestamp());
       }
     }
 
     scoped_refptr<AudioBuffer> output;
     int decoded_frames = 0;
     int original_frames = 0;
     int channels = DetermineChannels(av_frame_.get());
@@ skipping 114 matching lines @@
   if (codec_context_->channels !=
       ChannelLayoutToChannelCount(config_.channel_layout())) {
     DLOG(ERROR) << "Audio configuration specified "
                 << ChannelLayoutToChannelCount(config_.channel_layout())
                 << " channels, but FFmpeg thinks the file contains "
                 << codec_context_->channels << " channels";
     ReleaseFFmpegResources();
     state_ = kUninitialized;
     return false;
   }
+
+  if (config_.codec_delay() > base::TimeDelta()) {
+    output_frames_to_drop_ =
+        TimeDeltaToFrames(config_.codec_delay(), config_.samples_per_second());
+  }
+
   return true;
 }
 
 void FFmpegAudioDecoder::ResetTimestampState() {
   output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
   last_input_timestamp_ = kNoTimestamp();
   output_frames_to_drop_ = 0;
 }
 
 }  // namespace media