Introduce AudioDiscardHelper. Refactor audio decoders to use it.

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"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
-#include "media/base/audio_timestamp_helper.h"
+#include "media/base/audio_discard_helper.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/decoder_buffer.h"
 #include "third_party/opus/src/include/opus.h"
 #include "third_party/opus/src/include/opus_multistream.h"
 
 namespace media {
 
 static uint16 ReadLE16(const uint8* data, size_t data_size, int read_offset) {
   uint16 value = 0;
   DCHECK_LE(read_offset + sizeof(value), data_size);
   memcpy(&value, data + read_offset, sizeof(value));
   return base::ByteSwapToLE16(value);
 }
 
-static int TimeDeltaToAudioFrames(base::TimeDelta time_delta,
-                                  int frame_rate) {
-  return std::ceil(time_delta.InSecondsF() * frame_rate);
-}
-
 // The Opus specification is part of IETF RFC 6716:
 // http://tools.ietf.org/html/rfc6716
 
 // Opus uses Vorbis channel mapping, and Vorbis channel mapping specifies
 // mappings for up to 8 channels. This information is part of the Vorbis I
 // Specification:
 // http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html
 static const int kMaxVorbisChannels = 8;
 
 // Maximum packet size used in Xiph's opusdec and FFmpeg's libopusdec.
@@ skipping 200 matching lines @@
 
   for (int i = 0; i < extra_data->channels; ++i)
     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),
       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 43 matching lines @@
 
   // Libopus does not buffer output. Decoding is complete when an end of stream
   // input buffer is received.
   if (input->end_of_stream()) {
     decode_cb.Run(kOk, AudioBuffer::CreateEOSBuffer());
     return;
   }
 
   // Make sure we are notified if http://crbug.com/49709 returns.  Issue also
   // occurs with some damaged files.
-  if (input->timestamp() == kNoTimestamp() &&
-      output_timestamp_helper_->base_timestamp() == kNoTimestamp()) {
+  if (input->timestamp() == kNoTimestamp()) {
     DLOG(ERROR) << "Received a buffer without timestamps!";
     decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
-  if (last_input_timestamp_ != kNoTimestamp() &&
-      input->timestamp() != kNoTimestamp() &&
-      input->timestamp() < last_input_timestamp_) {
-    base::TimeDelta diff = input->timestamp() - last_input_timestamp_;
-    DLOG(ERROR) << "Input timestamps are not monotonically increasing! "
-                << " ts " << input->timestamp().InMicroseconds() << " us"
-                << " 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() &&
+  if (!discard_helper_->initialized() &&
       input->timestamp() == start_input_timestamp_) {
-    frames_to_discard_ = config_.codec_delay();
+    discard_helper_->Reset(config_.codec_delay());
   }
 
-  last_input_timestamp_ = input->timestamp();
-
   scoped_refptr<AudioBuffer> output_buffer;
 
   if (!Decode(input, &output_buffer)) {
     decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
   if (output_buffer.get()) {
     // Execute callback to return the decoded audio.
     decode_cb.Run(kOk, output_buffer);
@@ skipping 75 matching lines @@
   }
 
   status = opus_multistream_decoder_ctl(
       opus_decoder_, OPUS_SET_GAIN(opus_extra_data.gain_db));
   if (status != OPUS_OK) {
     DLOG(ERROR) << "Failed to set OPUS header gain; status="
                 << opus_strerror(status);
     return false;
   }
 
-  output_timestamp_helper_.reset(
-      new AudioTimestampHelper(config_.samples_per_second()));
+  discard_helper_.reset(new AudioDiscardHelper(config_.samples_per_second()));
   start_input_timestamp_ = kNoTimestamp();
   return true;
 }
 
 void OpusAudioDecoder::CloseDecoder() {
   if (opus_decoder_) {
     opus_multistream_decoder_destroy(opus_decoder_);
     opus_decoder_ = NULL;
   }
 }
 
 void OpusAudioDecoder::ResetTimestampState() {
-  output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
-  last_input_timestamp_ = kNoTimestamp();
-  frames_to_discard_ = TimeDeltaToAudioFrames(config_.seek_preroll(),
-                                              config_.samples_per_second());
+  discard_helper_->Reset(
+      discard_helper_->TimeDeltaToFrames(config_.seek_preroll()));
 }
 
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   // Allocate a buffer for the output samples.
   *output_buffer = AudioBuffer::CreateBuffer(
       config_.sample_format(),
       config_.channel_layout(),
       ChannelLayoutToChannelCount(config_.channel_layout()),
       config_.samples_per_second(),
@@ skipping 15 matching lines @@
 
   if (frames_decoded < 0) {
     DLOG(ERROR) << "opus_multistream_decode failed for"
                 << " 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());
-    output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
-  }
-
   // 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;
-  if (frames_decoded > frames_to_discard_) {
-    if (frames_to_discard_ > 0) {
-      output_buffer->get()->TrimStart(frames_to_discard_);
-      frames_to_output -= frames_to_discard_;
-      frames_to_discard_ = 0;
-    }
-    if (input->discard_padding().InMicroseconds() > 0) {
-      int discard_padding = TimeDeltaToAudioFrames(
-          input->discard_padding(), config_.samples_per_second());
-      if (discard_padding < 0 || discard_padding > frames_to_output) {
-        DVLOG(1) << "Invalid file. Incorrect discard padding value.";
-        return false;
-      }
-      output_buffer->get()->TrimEnd(discard_padding);
-      frames_to_output -= discard_padding;
-    } else {
-      DCHECK_EQ(input->discard_padding().InMicroseconds(), 0);
-    }
-  } else {
-    frames_to_discard_ -= frames_to_output;
-    frames_to_output = 0;
-  }
+  // Handles discards and timestamping.  Discard the buffer if more data needed.
+  if (!discard_helper_->ProcessBuffers(input, *output_buffer))
+    *output_buffer = NULL;
 
-  // Discard the buffer to indicate we need more data.
-  if (!frames_to_output) {
-    *output_buffer = NULL;
-    return true;
-  }
-
-  // Assign timestamp and duration to the buffer.
-  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_to_output);
   return true;
 }
 
 }  // namespace media