Wire up codec_delay() to MP3StreamParser and FFmpegAudioDecoder.

media/filters/opus_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/opus_audio_decoder.h"
 
 #include <cmath>
 
 #include "base/single_thread_task_runner.h"
 #include "base/sys_byteorder.h"
@@ skipping 235 matching lines @@
     extra_data->stream_map[i] = *(data + kOpusExtraDataStreamMapOffset + i);
   return true;
 }
 
 OpusAudioDecoder::OpusAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       opus_decoder_(NULL),
       last_input_timestamp_(kNoTimestamp()),
       frames_to_discard_(0),
-      frame_delay_at_start_(0),
       start_input_timestamp_(kNoTimestamp()) {}
 
 void OpusAudioDecoder::Initialize(const AudioDecoderConfig& config,
                                   const PipelineStatusCB& status_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
   config_ = config;
 
   if (!ConfigureDecoder()) {
@@ skipping 63 matching lines @@
                 << " diff " << diff.InMicroseconds() << " us";
     decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
   // Apply the necessary codec delay.
   if (start_input_timestamp_ == kNoTimestamp())
     start_input_timestamp_ = input->timestamp();
   if (last_input_timestamp_ == kNoTimestamp() &&
       input->timestamp() == start_input_timestamp_) {
-    frames_to_discard_ = frame_delay_at_start_;
+    frames_to_discard_ = config_.codec_delay();
   }
 
   last_input_timestamp_ = input->timestamp();
 
   scoped_refptr<AudioBuffer> output_buffer;
 
   if (!Decode(input, &output_buffer)) {
     decode_cb.Run(kDecodeError, NULL);
     return;
   }
@@ skipping 33 matching lines @@
   // Clean up existing decoder if necessary.
   CloseDecoder();
 
   // Parse the Opus Extra Data.
   OpusExtraData opus_extra_data;
   if (!ParseOpusExtraData(config_.extra_data(), config_.extra_data_size(),
                           config_,
                           &opus_extra_data))
     return false;
 
-  // Convert from seconds to samples.
-  timestamp_offset_ = config_.codec_delay();
-  frame_delay_at_start_ = TimeDeltaToAudioFrames(config_.codec_delay(),
-                                                 config_.samples_per_second());
-  if (timestamp_offset_ <= base::TimeDelta() || frame_delay_at_start_ < 0) {
+  if (config_.codec_delay() <= 0) {
     DLOG(ERROR) << "Invalid file. Incorrect value for codec delay: "
-                << config_.codec_delay().InMicroseconds();
+                << config_.codec_delay();
     return false;
   }
 
-  if (frame_delay_at_start_ != opus_extra_data.skip_samples) {
+  if (config_.codec_delay() != opus_extra_data.skip_samples) {
     DLOG(ERROR) << "Invalid file. Codec Delay in container does not match the "
                 << "value in Opus Extra Data.";
     return false;
   }
 
   uint8 channel_mapping[kMaxVorbisChannels] = {0};
   memcpy(&channel_mapping,
          kDefaultOpusChannelLayout,
          kMaxChannelsWithDefaultLayout);
 
@@ skipping 74 matching lines @@
                 << " timestamp: " << input->timestamp().InMicroseconds()
                 << " us, duration: " << input->duration().InMicroseconds()
                 << " us, packet size: " << input->data_size() << " bytes with"
                 << " status: " << opus_strerror(frames_decoded);
     return false;
   }
 
   if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
       !input->end_of_stream()) {
     DCHECK(input->timestamp() != kNoTimestamp());
+    // Adjust the timestamp helper so the base timestamp is corrected for frames
+    // dropped due to codec delay.
     output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
+    output_timestamp_helper_->SetBaseTimestamp(
+        input->timestamp() -
+        output_timestamp_helper_->GetFrameDuration(config_.codec_delay()));
   }
 
   // Trim off any extraneous allocation.
   DCHECK_LE(frames_decoded, output_buffer->get()->frame_count());
   const int trim_frames = output_buffer->get()->frame_count() - frames_decoded;
   if (trim_frames > 0)
     output_buffer->get()->TrimEnd(trim_frames);
 
   // Handle frame discard and trimming.
   int frames_to_output = frames_decoded;
@@ skipping 12 matching lines @@
       }
       output_buffer->get()->TrimEnd(discard_padding);
       frames_to_output -= discard_padding;
     }
   } else {
     frames_to_discard_ -= frames_to_output;
     frames_to_output = 0;
   }
 
   // Assign timestamp and duration to the buffer.
-  output_buffer->get()->set_timestamp(
-      output_timestamp_helper_->GetTimestamp() - timestamp_offset_);
+  output_buffer->get()->set_timestamp(output_timestamp_helper_->GetTimestamp());
   output_buffer->get()->set_duration(
       output_timestamp_helper_->GetFrameDuration(frames_to_output));
   output_timestamp_helper_->AddFrames(frames_decoded);
 
   // Discard the buffer to indicate we need more data.
   if (!frames_to_output)
     *output_buffer = NULL;
 
   return true;
 }
 
 }  // namespace media