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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 232 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()) {
+    skip_samples_ = opus_header.skip_samples;

[fgalligan1, 2013/08/26 21:10:06]

Is this the same value as below? I.e. skipped_bytes = opus_header.skip_samples *
bytesPerSample * numChannels?

[vignesh, 2013/08/26 21:44:23]

No it is not. If you look below (Line 542 in the red diff), i have modified the
Start Trimming code to make use of AudioBuffer.TrimStart() rather than having
our own implementation of it. The TrimStart function expects number of samples
and not number of bytes. So that conversion is not necessary anymore.

[fgalligan1, 2013/08/26 22:11:53]

Sorry I was just asking if opus_header.skip_samples included numChannels or not

[vignesh, 2013/08/26 23:55:48]

No it does not. Neither does the skip_samples_ variable in the else block. The
TrimStart and TrimEnd functions in AudioBuffer takes numChannels into account.
So we just call them with the number of samples.

+  } else {
+    // WebM container stores codec delay in nanoseconds. Convert it to samples.
+    skip_samples_ = config.codec_delay() * config.samples_per_second() /
+                    1000000000;
+    if (skip_samples_ != opus_header.skip_samples) {
+      DVLOG(1) << "Codec Delay in container does not match the value in Opus "
+               << "header. Using the value in container.";
+    }
+  }
 
   uint8 channel_mapping[kMaxVorbisChannels];
   memcpy(&channel_mapping,
          kDefaultOpusChannelLayout,
          kMaxChannelsWithDefaultLayout);
 
   if (channel_count > kMaxChannelsWithDefaultLayout) {
     RemapOpusChannelLayout(opus_header.stream_map,
                            channel_count,
                            channel_mapping);
@@ skipping 27 matching lines @@
 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);

[fgalligan1, 2013/08/26 21:10:06]

I'm assuming this works on samples? Does it take into account numChannels?

[vignesh, 2013/08/26 21:44:23]

Yes, it works on samples. I am unsure if it takes numChannels into account. Will
get back on this shortly.

[vignesh, 2013/08/26 23:55:48]

As mentioned in the other comment in this file, this function accoutns for
number of channels.

+      skip_samples_ -= dropped_size;
+      samples_decoded -= dropped_size;
+    }
+    if (input->discard_padding() > 0) {
+      int discard_padding = input->discard_padding() * samples_per_second_ /
+                            1000000000;
+      output_buffer->get()->TrimEnd(std::min(samples_decoded, discard_padding));
+    }
   }
 
   // Decoding finished successfully, update statistics.
   PipelineStatistics statistics;
   statistics.audio_bytes_decoded = decoded_audio_size;
   statistics_cb_.Run(statistics);
 
   return true;
 }
 
 }  // namespace media