1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "media/filters/opus_audio_decoder.h" 6 7#include <cmath> 8 9#include "base/single_thread_task_runner.h" 10#include "base/sys_byteorder.h" 11#include "media/base/audio_buffer.h" 12#include "media/base/audio_decoder_config.h" 13#include "media/base/audio_discard_helper.h" 14#include "media/base/bind_to_current_loop.h" 15#include "media/base/buffers.h" 16#include "media/base/decoder_buffer.h" 17#include "third_party/opus/src/include/opus.h" 18#include "third_party/opus/src/include/opus_multistream.h" 19 20namespace media { 21 22static uint16 ReadLE16(const uint8* data, size_t data_size, int read_offset) { 23 uint16 value = 0; 24 DCHECK_LE(read_offset + sizeof(value), data_size); 25 memcpy(&value, data + read_offset, sizeof(value)); 26 return base::ByteSwapToLE16(value); 27} 28 29// The Opus specification is part of IETF RFC 6716: 30// http://tools.ietf.org/html/rfc6716 31 32// Opus uses Vorbis channel mapping, and Vorbis channel mapping specifies 33// mappings for up to 8 channels. This information is part of the Vorbis I 34// Specification: 35// http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html 36static const int kMaxVorbisChannels = 8; 37 38// Maximum packet size used in Xiph's opusdec and FFmpeg's libopusdec. 39static const int kMaxOpusOutputPacketSizeSamples = 960 * 6; 40 41static void RemapOpusChannelLayout(const uint8* opus_mapping, 42 int num_channels, 43 uint8* channel_layout) { 44 DCHECK_LE(num_channels, kMaxVorbisChannels); 45 46 // Opus uses Vorbis channel layout. 47 const int32 num_layouts = kMaxVorbisChannels; 48 const int32 num_layout_values = kMaxVorbisChannels; 49 50 // Vorbis channel ordering for streams with >= 2 channels: 51 // 2 Channels 52 // L, R 53 // 3 Channels 54 // L, Center, R 55 // 4 Channels 56 // Front L, Front R, Back L, Back R 57 // 5 Channels 58 // Front L, Center, Front R, Back L, Back R 59 // 6 Channels (5.1) 60 // Front L, Center, Front R, Back L, Back R, LFE 61 // 7 channels (6.1) 62 // Front L, Front Center, Front R, Side L, Side R, Back Center, LFE 63 // 8 Channels (7.1) 64 // Front L, Center, Front R, Side L, Side R, Back L, Back R, LFE 65 // 66 // Channel ordering information is taken from section 4.3.9 of the Vorbis I 67 // Specification: 68 // http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9 69 70 // These are the FFmpeg channel layouts expressed using the position of each 71 // channel in the output stream from libopus. 72 const uint8 kFFmpegChannelLayouts[num_layouts][num_layout_values] = { 73 { 0 }, 74 75 // Stereo: No reorder. 76 { 0, 1 }, 77 78 // 3 Channels, from Vorbis order to: 79 // L, R, Center 80 { 0, 2, 1 }, 81 82 // 4 Channels: No reorder. 83 { 0, 1, 2, 3 }, 84 85 // 5 Channels, from Vorbis order to: 86 // Front L, Front R, Center, Back L, Back R 87 { 0, 2, 1, 3, 4 }, 88 89 // 6 Channels (5.1), from Vorbis order to: 90 // Front L, Front R, Center, LFE, Back L, Back R 91 { 0, 2, 1, 5, 3, 4 }, 92 93 // 7 Channels (6.1), from Vorbis order to: 94 // Front L, Front R, Front Center, LFE, Side L, Side R, Back Center 95 { 0, 2, 1, 6, 3, 4, 5 }, 96 97 // 8 Channels (7.1), from Vorbis order to: 98 // Front L, Front R, Center, LFE, Back L, Back R, Side L, Side R 99 { 0, 2, 1, 7, 5, 6, 3, 4 }, 100 }; 101 102 // Reorder the channels to produce the same ordering as FFmpeg, which is 103 // what the pipeline expects. 104 const uint8* vorbis_layout_offset = kFFmpegChannelLayouts[num_channels - 1]; 105 for (int channel = 0; channel < num_channels; ++channel) 106 channel_layout[channel] = opus_mapping[vorbis_layout_offset[channel]]; 107} 108 109// Opus Extra Data contents: 110// - "OpusHead" (64 bits) 111// - version number (8 bits) 112// - Channels C (8 bits) 113// - Pre-skip (16 bits) 114// - Sampling rate (32 bits) 115// - Gain in dB (16 bits, S7.8) 116// - Mapping (8 bits, 0=single stream (mono/stereo) 1=Vorbis mapping, 117// 2..254: reserved, 255: multistream with no mapping) 118// 119// - if (mapping != 0) 120// - N = totel number of streams (8 bits) 121// - M = number of paired streams (8 bits) 122// - C times channel origin 123// - if (C<2*M) 124// - stream = byte/2 125// - if (byte&0x1 == 0) 126// - left 127// else 128// - right 129// - else 130// - stream = byte-M 131 132// Default audio output channel layout. Used to initialize |stream_map| in 133// OpusExtraData, and passed to opus_multistream_decoder_create() when the 134// extra data does not contain mapping information. The values are valid only 135// for mono and stereo output: Opus streams with more than 2 channels require a 136// stream map. 137static const int kMaxChannelsWithDefaultLayout = 2; 138static const uint8 kDefaultOpusChannelLayout[kMaxChannelsWithDefaultLayout] = { 139 0, 1 }; 140 141// Size of the Opus extra data excluding optional mapping information. 142static const int kOpusExtraDataSize = 19; 143 144// Offset to the channel count byte in the Opus extra data. 145static const int kOpusExtraDataChannelsOffset = 9; 146 147// Offset to the pre-skip value in the Opus extra data. 148static const int kOpusExtraDataSkipSamplesOffset = 10; 149 150// Offset to the gain value in the Opus extra data. 151static const int kOpusExtraDataGainOffset = 16; 152 153// Offset to the channel mapping byte in the Opus extra data. 154static const int kOpusExtraDataChannelMappingOffset = 18; 155 156// Extra Data contains a stream map. The mapping values are in extra data beyond 157// the always present |kOpusExtraDataSize| bytes of data. The mapping data 158// contains stream count, coupling information, and per channel mapping values: 159// - Byte 0: Number of streams. 160// - Byte 1: Number coupled. 161// - Byte 2: Starting at byte 2 are |extra_data->channels| uint8 mapping 162// values. 163static const int kOpusExtraDataNumStreamsOffset = kOpusExtraDataSize; 164static const int kOpusExtraDataNumCoupledOffset = 165 kOpusExtraDataNumStreamsOffset + 1; 166static const int kOpusExtraDataStreamMapOffset = 167 kOpusExtraDataNumStreamsOffset + 2; 168 169struct OpusExtraData { 170 OpusExtraData() 171 : channels(0), 172 skip_samples(0), 173 channel_mapping(0), 174 num_streams(0), 175 num_coupled(0), 176 gain_db(0), 177 stream_map() { 178 memcpy(stream_map, 179 kDefaultOpusChannelLayout, 180 kMaxChannelsWithDefaultLayout); 181 } 182 int channels; 183 uint16 skip_samples; 184 int channel_mapping; 185 int num_streams; 186 int num_coupled; 187 int16 gain_db; 188 uint8 stream_map[kMaxVorbisChannels]; 189}; 190 191// Returns true when able to successfully parse and store Opus extra data in 192// |extra_data|. Based on opus header parsing code in libopusdec from FFmpeg, 193// and opus_header from Xiph's opus-tools project. 194static bool ParseOpusExtraData(const uint8* data, int data_size, 195 const AudioDecoderConfig& config, 196 OpusExtraData* extra_data) { 197 if (data_size < kOpusExtraDataSize) { 198 DLOG(ERROR) << "Extra data size is too small:" << data_size; 199 return false; 200 } 201 202 extra_data->channels = *(data + kOpusExtraDataChannelsOffset); 203 204 if (extra_data->channels <= 0 || extra_data->channels > kMaxVorbisChannels) { 205 DLOG(ERROR) << "invalid channel count in extra data: " 206 << extra_data->channels; 207 return false; 208 } 209 210 extra_data->skip_samples = 211 ReadLE16(data, data_size, kOpusExtraDataSkipSamplesOffset); 212 extra_data->gain_db = static_cast<int16>( 213 ReadLE16(data, data_size, kOpusExtraDataGainOffset)); 214 215 extra_data->channel_mapping = *(data + kOpusExtraDataChannelMappingOffset); 216 217 if (!extra_data->channel_mapping) { 218 if (extra_data->channels > kMaxChannelsWithDefaultLayout) { 219 DLOG(ERROR) << "Invalid extra data, missing stream map."; 220 return false; 221 } 222 223 extra_data->num_streams = 1; 224 extra_data->num_coupled = 225 (ChannelLayoutToChannelCount(config.channel_layout()) > 1) ? 1 : 0; 226 return true; 227 } 228 229 if (data_size < kOpusExtraDataStreamMapOffset + extra_data->channels) { 230 DLOG(ERROR) << "Invalid stream map; insufficient data for current channel " 231 << "count: " << extra_data->channels; 232 return false; 233 } 234 235 extra_data->num_streams = *(data + kOpusExtraDataNumStreamsOffset); 236 extra_data->num_coupled = *(data + kOpusExtraDataNumCoupledOffset); 237 238 if (extra_data->num_streams + extra_data->num_coupled != extra_data->channels) 239 DVLOG(1) << "Inconsistent channel mapping."; 240 241 for (int i = 0; i < extra_data->channels; ++i) 242 extra_data->stream_map[i] = *(data + kOpusExtraDataStreamMapOffset + i); 243 return true; 244} 245 246OpusAudioDecoder::OpusAudioDecoder( 247 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) 248 : task_runner_(task_runner), 249 opus_decoder_(NULL), 250 start_input_timestamp_(kNoTimestamp()) {} 251 252std::string OpusAudioDecoder::GetDisplayName() const { 253 return "OpusAudioDecoder"; 254} 255 256void OpusAudioDecoder::Initialize(const AudioDecoderConfig& config, 257 const PipelineStatusCB& status_cb, 258 const OutputCB& output_cb) { 259 DCHECK(task_runner_->BelongsToCurrentThread()); 260 PipelineStatusCB initialize_cb = BindToCurrentLoop(status_cb); 261 262 config_ = config; 263 output_cb_ = BindToCurrentLoop(output_cb); 264 265 if (!ConfigureDecoder()) { 266 initialize_cb.Run(DECODER_ERROR_NOT_SUPPORTED); 267 return; 268 } 269 270 initialize_cb.Run(PIPELINE_OK); 271} 272 273void OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer, 274 const DecodeCB& decode_cb) { 275 DCHECK(task_runner_->BelongsToCurrentThread()); 276 DCHECK(!decode_cb.is_null()); 277 278 DecodeBuffer(buffer, BindToCurrentLoop(decode_cb)); 279} 280 281void OpusAudioDecoder::Reset(const base::Closure& closure) { 282 DCHECK(task_runner_->BelongsToCurrentThread()); 283 284 opus_multistream_decoder_ctl(opus_decoder_, OPUS_RESET_STATE); 285 ResetTimestampState(); 286 task_runner_->PostTask(FROM_HERE, closure); 287} 288 289OpusAudioDecoder::~OpusAudioDecoder() { 290 DCHECK(task_runner_->BelongsToCurrentThread()); 291 292 if (!opus_decoder_) 293 return; 294 295 opus_multistream_decoder_ctl(opus_decoder_, OPUS_RESET_STATE); 296 ResetTimestampState(); 297 CloseDecoder(); 298} 299 300void OpusAudioDecoder::DecodeBuffer( 301 const scoped_refptr<DecoderBuffer>& input, 302 const DecodeCB& decode_cb) { 303 DCHECK(task_runner_->BelongsToCurrentThread()); 304 DCHECK(!decode_cb.is_null()); 305 DCHECK(input.get()); 306 307 // Libopus does not buffer output. Decoding is complete when an end of stream 308 // input buffer is received. 309 if (input->end_of_stream()) { 310 decode_cb.Run(kOk); 311 return; 312 } 313 314 // Make sure we are notified if http://crbug.com/49709 returns. Issue also 315 // occurs with some damaged files. 316 if (input->timestamp() == kNoTimestamp()) { 317 DLOG(ERROR) << "Received a buffer without timestamps!"; 318 decode_cb.Run(kDecodeError); 319 return; 320 } 321 322 // Apply the necessary codec delay. 323 if (start_input_timestamp_ == kNoTimestamp()) 324 start_input_timestamp_ = input->timestamp(); 325 if (!discard_helper_->initialized() && 326 input->timestamp() == start_input_timestamp_) { 327 discard_helper_->Reset(config_.codec_delay()); 328 } 329 330 scoped_refptr<AudioBuffer> output_buffer; 331 332 if (!Decode(input, &output_buffer)) { 333 decode_cb.Run(kDecodeError); 334 return; 335 } 336 337 if (output_buffer.get()) { 338 output_cb_.Run(output_buffer); 339 } 340 341 decode_cb.Run(kOk); 342} 343 344bool OpusAudioDecoder::ConfigureDecoder() { 345 if (config_.codec() != kCodecOpus) { 346 DVLOG(1) << "Codec must be kCodecOpus."; 347 return false; 348 } 349 350 const int channel_count = 351 ChannelLayoutToChannelCount(config_.channel_layout()); 352 if (!config_.IsValidConfig() || channel_count > kMaxVorbisChannels) { 353 DLOG(ERROR) << "Invalid or unsupported audio stream -" 354 << " codec: " << config_.codec() 355 << " channel count: " << channel_count 356 << " channel layout: " << config_.channel_layout() 357 << " bits per channel: " << config_.bits_per_channel() 358 << " samples per second: " << config_.samples_per_second(); 359 return false; 360 } 361 362 if (config_.is_encrypted()) { 363 DLOG(ERROR) << "Encrypted audio stream not supported."; 364 return false; 365 } 366 367 // Clean up existing decoder if necessary. 368 CloseDecoder(); 369 370 // Parse the Opus Extra Data. 371 OpusExtraData opus_extra_data; 372 if (!ParseOpusExtraData(config_.extra_data(), config_.extra_data_size(), 373 config_, 374 &opus_extra_data)) 375 return false; 376 377 if (config_.codec_delay() < 0) { 378 DLOG(ERROR) << "Invalid file. Incorrect value for codec delay: " 379 << config_.codec_delay(); 380 return false; 381 } 382 383 if (config_.codec_delay() != opus_extra_data.skip_samples) { 384 DLOG(ERROR) << "Invalid file. Codec Delay in container does not match the " 385 << "value in Opus Extra Data. " << config_.codec_delay() 386 << " vs " << opus_extra_data.skip_samples; 387 return false; 388 } 389 390 uint8 channel_mapping[kMaxVorbisChannels] = {0}; 391 memcpy(&channel_mapping, 392 kDefaultOpusChannelLayout, 393 kMaxChannelsWithDefaultLayout); 394 395 if (channel_count > kMaxChannelsWithDefaultLayout) { 396 RemapOpusChannelLayout(opus_extra_data.stream_map, 397 channel_count, 398 channel_mapping); 399 } 400 401 // Init Opus. 402 int status = OPUS_INVALID_STATE; 403 opus_decoder_ = opus_multistream_decoder_create(config_.samples_per_second(), 404 channel_count, 405 opus_extra_data.num_streams, 406 opus_extra_data.num_coupled, 407 channel_mapping, 408 &status); 409 if (!opus_decoder_ || status != OPUS_OK) { 410 DLOG(ERROR) << "opus_multistream_decoder_create failed status=" 411 << opus_strerror(status); 412 return false; 413 } 414 415 status = opus_multistream_decoder_ctl( 416 opus_decoder_, OPUS_SET_GAIN(opus_extra_data.gain_db)); 417 if (status != OPUS_OK) { 418 DLOG(ERROR) << "Failed to set OPUS header gain; status=" 419 << opus_strerror(status); 420 return false; 421 } 422 423 discard_helper_.reset( 424 new AudioDiscardHelper(config_.samples_per_second(), 0)); 425 start_input_timestamp_ = kNoTimestamp(); 426 return true; 427} 428 429void OpusAudioDecoder::CloseDecoder() { 430 if (opus_decoder_) { 431 opus_multistream_decoder_destroy(opus_decoder_); 432 opus_decoder_ = NULL; 433 } 434} 435 436void OpusAudioDecoder::ResetTimestampState() { 437 discard_helper_->Reset( 438 discard_helper_->TimeDeltaToFrames(config_.seek_preroll())); 439} 440 441bool OpusAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& input, 442 scoped_refptr<AudioBuffer>* output_buffer) { 443 // Allocate a buffer for the output samples. 444 *output_buffer = AudioBuffer::CreateBuffer( 445 config_.sample_format(), 446 config_.channel_layout(), 447 ChannelLayoutToChannelCount(config_.channel_layout()), 448 config_.samples_per_second(), 449 kMaxOpusOutputPacketSizeSamples); 450 const int buffer_size = 451 output_buffer->get()->channel_count() * 452 output_buffer->get()->frame_count() * 453 SampleFormatToBytesPerChannel(config_.sample_format()); 454 455 float* float_output_buffer = reinterpret_cast<float*>( 456 output_buffer->get()->channel_data()[0]); 457 const int frames_decoded = 458 opus_multistream_decode_float(opus_decoder_, 459 input->data(), 460 input->data_size(), 461 float_output_buffer, 462 buffer_size, 463 0); 464 465 if (frames_decoded < 0) { 466 DLOG(ERROR) << "opus_multistream_decode failed for" 467 << " timestamp: " << input->timestamp().InMicroseconds() 468 << " us, duration: " << input->duration().InMicroseconds() 469 << " us, packet size: " << input->data_size() << " bytes with" 470 << " status: " << opus_strerror(frames_decoded); 471 return false; 472 } 473 474 // Trim off any extraneous allocation. 475 DCHECK_LE(frames_decoded, output_buffer->get()->frame_count()); 476 const int trim_frames = output_buffer->get()->frame_count() - frames_decoded; 477 if (trim_frames > 0) 478 output_buffer->get()->TrimEnd(trim_frames); 479 480 // Handles discards and timestamping. Discard the buffer if more data needed. 481 if (!discard_helper_->ProcessBuffers(input, *output_buffer)) 482 *output_buffer = NULL; 483 484 return true; 485} 486 487} // namespace media 488