Merge 23038 - Updated decode logic to estimate timestamps if the demuxer has ...

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2009 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 "media/base/data_buffer.h"
-#include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 
 namespace media {
 
 // Size of the decoded audio buffer.
 const size_t FFmpegAudioDecoder::kOutputBufferSize =
     AVCODEC_MAX_AUDIO_FRAME_SIZE;
 
 FFmpegAudioDecoder::FFmpegAudioDecoder()
@@ skipping 49 matching lines @@
 
   // Prepare the output buffer.
   output_buffer_.reset(static_cast<uint8*>(av_malloc(kOutputBufferSize)));
   if (!output_buffer_.get()) {
     host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
     return false;
   }
   return true;
 }
 
+void FFmpegAudioDecoder::OnSeek(base::TimeDelta time) {
+  avcodec_flush_buffers(codec_context_);
+  estimated_next_timestamp_ = base::TimeDelta();
+}
+
 void FFmpegAudioDecoder::OnStop() {
 }
 
 void FFmpegAudioDecoder::OnDecode(Buffer* input) {
-  // Check for discontinuous buffer. If we receive a discontinuous buffer here,
-  // flush the internal buffer of FFmpeg.
-  if (input->IsDiscontinuous()) {
-    avcodec_flush_buffers(codec_context_);
-  }
-
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
   av_init_packet(&packet);
   packet.data = const_cast<uint8*>(input->GetData());
   packet.size = input->GetDataSize();
 
   int16_t* output_buffer = reinterpret_cast<int16_t*>(output_buffer_.get());
   int output_buffer_size = kOutputBufferSize;
   int result = avcodec_decode_audio3(codec_context_,
                                      output_buffer,
@@ skipping 17 matching lines @@
     memcpy(data, output_buffer, output_buffer_size);
 
     // Determine the duration if the demuxer couldn't figure it out, otherwise
     // copy it over.
     if (input->GetDuration().InMicroseconds() == 0) {
       result_buffer->SetDuration(CalculateDuration(output_buffer_size));
     } else {
       result_buffer->SetDuration(input->GetDuration());
     }
 
-    // Copy over the timestamp.
-    result_buffer->SetTimestamp(input->GetTimestamp());
+    // Use our estimate for the timestamp if |input| does not have one.
+    // Otherwise, copy over the timestamp.
+    if (input->GetTimestamp().InMicroseconds() == 0) {
+      result_buffer->SetTimestamp(estimated_next_timestamp_);
+    } else {
+      result_buffer->SetTimestamp(input->GetTimestamp());
+    }
+
+    // Update our estimated timestamp for the next packet.
+    estimated_next_timestamp_ = result_buffer->GetTimestamp() +
+        result_buffer->GetDuration();
 
     EnqueueResult(result_buffer);
     return;
   }
 
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
   if (result == 0 && output_buffer_size == 0 && input->IsEndOfStream()) {
     DataBuffer* result_buffer = new DataBuffer(0);
     result_buffer->SetTimestamp(input->GetTimestamp());
     result_buffer->SetDuration(input->GetDuration());
     EnqueueResult(result_buffer);
   }
 }
 
 base::TimeDelta FFmpegAudioDecoder::CalculateDuration(size_t size) {
   int64 denominator = codec_context_->channels *
       av_get_bits_per_sample_format(codec_context_->sample_fmt) / 8 *
       codec_context_->sample_rate;
   double microseconds = size /
       (denominator / static_cast<double>(base::Time::kMicrosecondsPerSecond));
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 }
 
 }  // namespace