media: Opus support for WebM in Media Source

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/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.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/bind_to_loop.h"
 #include "media/base/buffers.h"
@@ skipping 226 matching lines @@
 OpusAudioDecoder::OpusAudioDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       demuxer_stream_(NULL),
       opus_decoder_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       last_input_timestamp_(kNoTimestamp()),
-      output_bytes_to_drop_(0),
       skip_samples_(0) {
 }
 
 void OpusAudioDecoder::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb);
 
@@ skipping 186 matching lines @@
   // Allocate the output buffer if necessary.
   if (!output_buffer_)
     output_buffer_.reset(new int16[kMaxOpusOutputPacketSizeSamples]);
 
   // Parse the Opus header.
   OpusHeader opus_header;
   ParseOpusHeader(config.extra_data(), config.extra_data_size(),
                   config,
                   &opus_header);
 
-  skip_samples_ = opus_header.skip_samples;
-
-  if (skip_samples_ > 0)
-    output_bytes_to_drop_ = skip_samples_ * config.bytes_per_frame();
+  if (!config.codec_delay().InMicroseconds()) {
+    // TODO(vigneshv): Replace this with return false once ffmpeg demuxer code
+    // starts populating the config correctly.
+    skip_samples_ = opus_header.skip_samples;
+  } else {
+    // Convert from seconds to samples.
+    skip_samples_ = std::ceil(config.codec_delay().InMicroseconds() *
+                              config.samples_per_second() / 1000000.0);
+    if (skip_samples_ < 0) {
+      DVLOG(1) << "Invalid file. Incorrect value for codec delay.";
+      return false;
+    }
+    if (skip_samples_ != opus_header.skip_samples) {
+      DVLOG(1) << "Invalid file. Codec Delay in container does not match the "
+               << "value in Opus header.";
+      return false;
+    }
+  }
 
   uint8 channel_mapping[kMaxVorbisChannels];
   memcpy(&channel_mapping,
          kDefaultOpusChannelLayout,
          kMaxChannelsWithDefaultLayout);
 
   if (channel_count > kMaxChannelsWithDefaultLayout) {
     RemapOpusChannelLayout(opus_header.stream_map,
                            channel_count,
                            channel_mapping);
   }
 
   // Init Opus.
   int status = OPUS_INVALID_STATE;
   opus_decoder_ = opus_multistream_decoder_create(config.samples_per_second(),
                                                   channel_count,
                                                   opus_header.num_streams,
                                                   opus_header.num_coupled,
                                                   channel_mapping,
                                                   &status);
   if (!opus_decoder_ || status != OPUS_OK) {
     LOG(ERROR) << "opus_multistream_decoder_create failed status="
                << opus_strerror(status);
     return false;
   }
 
-  // TODO(tomfinegan): Handle audio delay once the matroska spec is updated
-  // to represent the value.
-
   bits_per_channel_ = config.bits_per_channel();
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
   output_timestamp_helper_.reset(
       new AudioTimestampHelper(config.samples_per_second()));
   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();
-  output_bytes_to_drop_ = 0;
+  skip_samples_ = 0;
 }
 
 bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input,
                               scoped_refptr<AudioBuffer>* output_buffer) {
   int samples_decoded = opus_multistream_decode(opus_decoder_,
                                                 input->data(),
                                                 input->data_size(),
                                                 &output_buffer_[0],
                                                 kMaxOpusOutputPacketSizeSamples,
                                                 0);
@@ skipping 10 matching lines @@
   int decoded_audio_size = samples_decoded *
       demuxer_stream_->audio_decoder_config().bytes_per_frame();
   DCHECK_LE(decoded_audio_size, kMaxOpusOutputPacketSizeBytes);
 
   if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
       !input->end_of_stream()) {
     DCHECK(input->timestamp() != kNoTimestamp());
     output_timestamp_helper_->SetBaseTimestamp(input->timestamp());
   }
 
-  if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
-    int dropped_size = std::min(decoded_audio_size, output_bytes_to_drop_);
-    DCHECK_EQ(dropped_size % kBytesPerChannel, 0);
-    decoded_audio_data += dropped_size;
-    decoded_audio_size -= dropped_size;
-    output_bytes_to_drop_ -= dropped_size;
-    samples_decoded = decoded_audio_size /
-                      demuxer_stream_->audio_decoder_config().bytes_per_frame();
-  }
-
   if (decoded_audio_size > 0) {
     // Copy the audio samples into an output buffer.
     uint8* data[] = { decoded_audio_data };
     *output_buffer = AudioBuffer::CopyFrom(
         kSampleFormatS16,
         ChannelLayoutToChannelCount(channel_layout_),
         samples_decoded,
         data,
         output_timestamp_helper_->GetTimestamp(),
         output_timestamp_helper_->GetFrameDuration(samples_decoded));
     output_timestamp_helper_->AddFrames(samples_decoded);
+    if (skip_samples_ > 0) {
+      int dropped_size = std::min(samples_decoded, skip_samples_);
+      output_buffer->get()->TrimStart(dropped_size);
+      skip_samples_ -= dropped_size;
+      samples_decoded -= dropped_size;
+    }
+    if (input->discard_padding().InMicroseconds() > 0) {
+      int discard_padding = std::ceil(
+                                input->discard_padding().InMicroseconds() *
+                                samples_per_second_ / 1000000.0);
+      if (discard_padding < 0 || discard_padding > samples_decoded) {
+        DVLOG(1) << "Invalid file. Incorrect discard padding value.";
+        return false;
+      }
+      output_buffer->get()->TrimEnd(std::min(samples_decoded, discard_padding));
+      samples_decoded -= discard_padding;
+    }
   }
 
+  decoded_audio_size =
+      samples_decoded *
+      demuxer_stream_->audio_decoder_config().bytes_per_frame();
   // Decoding finished successfully, update statistics.
   PipelineStatistics statistics;
   statistics.audio_bytes_decoded = decoded_audio_size;
   statistics_cb_.Run(statistics);
 
   return true;
 }
 
 }  // namespace media