Add support for setting OPUS header gain.

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"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/pipeline.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;
+template <typename T>
+static T ReadLE16(const uint8* data, size_t data_size, int read_offset) {
+  T 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);
 }
 
@@ skipping 111 matching lines @@
 
 // Size of the Opus extra data excluding optional mapping information.
 static const int kOpusExtraDataSize = 19;
 
 // Offset to the channel count byte in the Opus extra data.
 static const int kOpusExtraDataChannelsOffset = 9;
 
 // Offset to the pre-skip value in the Opus extra data.
 static const int kOpusExtraDataSkipSamplesOffset = 10;
 
+// Offset to the gain value in the Opus extra data.
+static const int kOpusExtraDataGainOffset = 16;
+
 // Offset to the channel mapping byte in the Opus extra data.
 static const int kOpusExtraDataChannelMappingOffset = 18;
 
 // Extra Data contains a stream map. The mapping values are in extra data beyond
 // the always present |kOpusExtraDataSize| bytes of data. The mapping data
 // contains stream count, coupling information, and per channel mapping values:
 //   - Byte 0: Number of streams.
 //   - Byte 1: Number coupled.
 //   - Byte 2: Starting at byte 2 are |extra_data->channels| uint8 mapping
 //             values.
 static const int kOpusExtraDataNumStreamsOffset = kOpusExtraDataSize;
 static const int kOpusExtraDataNumCoupledOffset =
     kOpusExtraDataNumStreamsOffset + 1;
 static const int kOpusExtraDataStreamMapOffset =
     kOpusExtraDataNumStreamsOffset + 2;
 
 struct OpusExtraData {
   OpusExtraData()
       : channels(0),
         skip_samples(0),
         channel_mapping(0),
         num_streams(0),
-        num_coupled(0) {
+        num_coupled(0),
+        gain_db(0) {
     memcpy(stream_map,
            kDefaultOpusChannelLayout,
            kMaxChannelsWithDefaultLayout);
   }
   int channels;
-  int skip_samples;
+  uint16_t skip_samples;
   int channel_mapping;
   int num_streams;
   int num_coupled;
+  int16_t gain_db;
   uint8 stream_map[kMaxVorbisChannels];
 };
 
 // Returns true when able to successfully parse and store Opus extra data in
 // |extra_data|. Based on opus header parsing code in libopusdec from FFmpeg,
 // and opus_header from Xiph's opus-tools project.
 static bool ParseOpusExtraData(const uint8* data, int data_size,
                                const AudioDecoderConfig& config,
                                OpusExtraData* extra_data) {
   if (data_size < kOpusExtraDataSize) {
     DLOG(ERROR) << "Extra data size is too small:" << data_size;
     return false;
   }
 
   extra_data->channels = *(data + kOpusExtraDataChannelsOffset);
 
   if (extra_data->channels <= 0 || extra_data->channels > kMaxVorbisChannels) {
     DLOG(ERROR) << "invalid channel count in extra data: "
                 << extra_data->channels;
     return false;
   }
 
   extra_data->skip_samples =
-      ReadLE16(data, data_size, kOpusExtraDataSkipSamplesOffset);
+      ReadLE16<uint16_t>(data, data_size, kOpusExtraDataSkipSamplesOffset);
+  extra_data->gain_db =
+      ReadLE16<int16_t>(data, data_size, kOpusExtraDataGainOffset);

[acolwell GONE FROM CHROMIUM, 2013/12/16 21:37:08]

nit: How about just putting a static_cast<int16_t>() here instead of making
ReadLE16() a template. It seems like that would result in less code and avoid
the implicit casting that is going on in your template (ie there is no int16_t
version of ByteSwapToLE16).

[DaleCurtis, 2013/12/16 22:21:04]

Nice catch, I've reverted this in place of just using a static_cast. 

 
   extra_data->channel_mapping = *(data + kOpusExtraDataChannelMappingOffset);
 
   if (!extra_data->channel_mapping) {
     if (extra_data->channels > kMaxChannelsWithDefaultLayout) {
       DLOG(ERROR) << "Invalid extra data, missing stream map.";
       return false;
     }
 
     extra_data->num_streams = 1;
@@ skipping 269 matching lines @@
                                                   opus_extra_data.num_streams,
                                                   opus_extra_data.num_coupled,
                                                   channel_mapping,
                                                   &status);
   if (!opus_decoder_ || status != OPUS_OK) {
     DLOG(ERROR) << "opus_multistream_decoder_create failed status="
                 << opus_strerror(status);
     return false;
   }
 
+  status = opus_multistream_decoder_ctl(
+      opus_decoder_, OPUS_SET_GAIN(opus_extra_data.gain_db));
+  if (status != OPUS_OK) {
+    DLOG(WARNING) << "Failed to set OPUS header gain.  status="
+                  << opus_strerror(status);

[acolwell GONE FROM CHROMIUM, 2013/12/16 21:37:08]

nit: Shouldn't we return false here since this is a sign of invalid content?

[DaleCurtis, 2013/12/16 22:21:04]

While the docs don't make it clear, errors will be returned when the gain value
is outside of [-32768, 32767].  The test files I have play fine, so I've made it
an error.

[vignesh, 2013/12/16 22:24:51]

We do strict checking on other fields (like codec_delay). So i think we should
be strict here as well and return false.

[DaleCurtis, 2013/12/16 22:28:02]

The bounds are int16_min -> int16_max, it's enforced by virtue of being an int16
type.

+  }
+
   channel_layout_ = config.channel_layout();
   samples_per_second_ = config.samples_per_second();
   output_timestamp_helper_.reset(
       new AudioTimestampHelper(config.samples_per_second()));
   start_input_timestamp_ = kNoTimestamp();
   return true;
 }
 
 void OpusAudioDecoder::CloseDecoder() {
   if (opus_decoder_) {
@@ skipping 89 matching lines @@
   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