1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 //#define LOG_NDEBUG 0 18 #define LOG_TAG "SoftOpus" 19 #include <utils/Log.h> 20 21 #include "SoftOpus.h" 22 #include <OMX_AudioExt.h> 23 #include <OMX_IndexExt.h> 24 25 #include <media/stagefright/foundation/ADebug.h> 26 #include <media/stagefright/MediaDefs.h> 27 28 extern "C" { 29 #include <opus.h> 30 #include <opus_multistream.h> 31 } 32 33 namespace android { 34 35 static const int kRate = 48000; 36 37 template<class T> 38 static void InitOMXParams(T *params) { 39 params->nSize = sizeof(T); 40 params->nVersion.s.nVersionMajor = 1; 41 params->nVersion.s.nVersionMinor = 0; 42 params->nVersion.s.nRevision = 0; 43 params->nVersion.s.nStep = 0; 44 } 45 46 SoftOpus::SoftOpus( 47 const char *name, 48 const OMX_CALLBACKTYPE *callbacks, 49 OMX_PTR appData, 50 OMX_COMPONENTTYPE **component) 51 : SimpleSoftOMXComponent(name, callbacks, appData, component), 52 mInputBufferCount(0), 53 mDecoder(NULL), 54 mHeader(NULL), 55 mCodecDelay(0), 56 mSeekPreRoll(0), 57 mAnchorTimeUs(0), 58 mNumFramesOutput(0), 59 mOutputPortSettingsChange(NONE) { 60 initPorts(); 61 CHECK_EQ(initDecoder(), (status_t)OK); 62 } 63 64 SoftOpus::~SoftOpus() { 65 if (mDecoder != NULL) { 66 opus_multistream_decoder_destroy(mDecoder); 67 mDecoder = NULL; 68 } 69 if (mHeader != NULL) { 70 delete mHeader; 71 mHeader = NULL; 72 } 73 } 74 75 void SoftOpus::initPorts() { 76 OMX_PARAM_PORTDEFINITIONTYPE def; 77 InitOMXParams(&def); 78 79 def.nPortIndex = 0; 80 def.eDir = OMX_DirInput; 81 def.nBufferCountMin = kNumBuffers; 82 def.nBufferCountActual = def.nBufferCountMin; 83 def.nBufferSize = 960 * 6; 84 def.bEnabled = OMX_TRUE; 85 def.bPopulated = OMX_FALSE; 86 def.eDomain = OMX_PortDomainAudio; 87 def.bBuffersContiguous = OMX_FALSE; 88 def.nBufferAlignment = 1; 89 90 def.format.audio.cMIMEType = 91 const_cast<char *>(MEDIA_MIMETYPE_AUDIO_OPUS); 92 93 def.format.audio.pNativeRender = NULL; 94 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 95 def.format.audio.eEncoding = 96 (OMX_AUDIO_CODINGTYPE)OMX_AUDIO_CodingAndroidOPUS; 97 98 addPort(def); 99 100 def.nPortIndex = 1; 101 def.eDir = OMX_DirOutput; 102 def.nBufferCountMin = kNumBuffers; 103 def.nBufferCountActual = def.nBufferCountMin; 104 def.nBufferSize = kMaxNumSamplesPerBuffer * sizeof(int16_t); 105 def.bEnabled = OMX_TRUE; 106 def.bPopulated = OMX_FALSE; 107 def.eDomain = OMX_PortDomainAudio; 108 def.bBuffersContiguous = OMX_FALSE; 109 def.nBufferAlignment = 2; 110 111 def.format.audio.cMIMEType = const_cast<char *>("audio/raw"); 112 def.format.audio.pNativeRender = NULL; 113 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 114 def.format.audio.eEncoding = OMX_AUDIO_CodingPCM; 115 116 addPort(def); 117 } 118 119 status_t SoftOpus::initDecoder() { 120 return OK; 121 } 122 123 OMX_ERRORTYPE SoftOpus::internalGetParameter( 124 OMX_INDEXTYPE index, OMX_PTR params) { 125 switch ((int)index) { 126 case OMX_IndexParamAudioAndroidOpus: 127 { 128 OMX_AUDIO_PARAM_ANDROID_OPUSTYPE *opusParams = 129 (OMX_AUDIO_PARAM_ANDROID_OPUSTYPE *)params; 130 131 if (opusParams->nPortIndex != 0) { 132 return OMX_ErrorUndefined; 133 } 134 135 opusParams->nAudioBandWidth = 0; 136 opusParams->nSampleRate = kRate; 137 opusParams->nBitRate = 0; 138 139 if (!isConfigured()) { 140 opusParams->nChannels = 1; 141 } else { 142 opusParams->nChannels = mHeader->channels; 143 } 144 145 return OMX_ErrorNone; 146 } 147 148 case OMX_IndexParamAudioPcm: 149 { 150 OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams = 151 (OMX_AUDIO_PARAM_PCMMODETYPE *)params; 152 153 if (pcmParams->nPortIndex != 1) { 154 return OMX_ErrorUndefined; 155 } 156 157 pcmParams->eNumData = OMX_NumericalDataSigned; 158 pcmParams->eEndian = OMX_EndianBig; 159 pcmParams->bInterleaved = OMX_TRUE; 160 pcmParams->nBitPerSample = 16; 161 pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear; 162 pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF; 163 pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF; 164 pcmParams->nSamplingRate = kRate; 165 166 if (!isConfigured()) { 167 pcmParams->nChannels = 1; 168 } else { 169 pcmParams->nChannels = mHeader->channels; 170 } 171 172 return OMX_ErrorNone; 173 } 174 175 default: 176 return SimpleSoftOMXComponent::internalGetParameter(index, params); 177 } 178 } 179 180 OMX_ERRORTYPE SoftOpus::internalSetParameter( 181 OMX_INDEXTYPE index, const OMX_PTR params) { 182 switch ((int)index) { 183 case OMX_IndexParamStandardComponentRole: 184 { 185 const OMX_PARAM_COMPONENTROLETYPE *roleParams = 186 (const OMX_PARAM_COMPONENTROLETYPE *)params; 187 188 if (strncmp((const char *)roleParams->cRole, 189 "audio_decoder.opus", 190 OMX_MAX_STRINGNAME_SIZE - 1)) { 191 return OMX_ErrorUndefined; 192 } 193 194 return OMX_ErrorNone; 195 } 196 197 case OMX_IndexParamAudioAndroidOpus: 198 { 199 const OMX_AUDIO_PARAM_ANDROID_OPUSTYPE *opusParams = 200 (const OMX_AUDIO_PARAM_ANDROID_OPUSTYPE *)params; 201 202 if (opusParams->nPortIndex != 0) { 203 return OMX_ErrorUndefined; 204 } 205 206 return OMX_ErrorNone; 207 } 208 209 default: 210 return SimpleSoftOMXComponent::internalSetParameter(index, params); 211 } 212 } 213 214 bool SoftOpus::isConfigured() const { 215 return mInputBufferCount >= 1; 216 } 217 218 static uint16_t ReadLE16(const uint8_t *data, size_t data_size, 219 uint32_t read_offset) { 220 if (read_offset + 1 > data_size) 221 return 0; 222 uint16_t val; 223 val = data[read_offset]; 224 val |= data[read_offset + 1] << 8; 225 return val; 226 } 227 228 // Opus uses Vorbis channel mapping, and Vorbis channel mapping specifies 229 // mappings for up to 8 channels. This information is part of the Vorbis I 230 // Specification: 231 // http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html 232 static const int kMaxChannels = 8; 233 234 // Maximum packet size used in Xiph's opusdec. 235 static const int kMaxOpusOutputPacketSizeSamples = 960 * 6; 236 237 // Default audio output channel layout. Used to initialize |stream_map| in 238 // OpusHeader, and passed to opus_multistream_decoder_create() when the header 239 // does not contain mapping information. The values are valid only for mono and 240 // stereo output: Opus streams with more than 2 channels require a stream map. 241 static const int kMaxChannelsWithDefaultLayout = 2; 242 static const uint8_t kDefaultOpusChannelLayout[kMaxChannelsWithDefaultLayout] = { 0, 1 }; 243 244 // Parses Opus Header. Header spec: http://wiki.xiph.org/OggOpus#ID_Header 245 static bool ParseOpusHeader(const uint8_t *data, size_t data_size, 246 OpusHeader* header) { 247 // Size of the Opus header excluding optional mapping information. 248 const size_t kOpusHeaderSize = 19; 249 250 // Offset to the channel count byte in the Opus header. 251 const size_t kOpusHeaderChannelsOffset = 9; 252 253 // Offset to the pre-skip value in the Opus header. 254 const size_t kOpusHeaderSkipSamplesOffset = 10; 255 256 // Offset to the gain value in the Opus header. 257 const size_t kOpusHeaderGainOffset = 16; 258 259 // Offset to the channel mapping byte in the Opus header. 260 const size_t kOpusHeaderChannelMappingOffset = 18; 261 262 // Opus Header contains a stream map. The mapping values are in the header 263 // beyond the always present |kOpusHeaderSize| bytes of data. The mapping 264 // data contains stream count, coupling information, and per channel mapping 265 // values: 266 // - Byte 0: Number of streams. 267 // - Byte 1: Number coupled. 268 // - Byte 2: Starting at byte 2 are |header->channels| uint8 mapping 269 // values. 270 const size_t kOpusHeaderNumStreamsOffset = kOpusHeaderSize; 271 const size_t kOpusHeaderNumCoupledOffset = kOpusHeaderNumStreamsOffset + 1; 272 const size_t kOpusHeaderStreamMapOffset = kOpusHeaderNumStreamsOffset + 2; 273 274 if (data_size < kOpusHeaderSize) { 275 ALOGV("Header size is too small."); 276 return false; 277 } 278 header->channels = *(data + kOpusHeaderChannelsOffset); 279 280 if (header->channels <= 0 || header->channels > kMaxChannels) { 281 ALOGV("Invalid Header, wrong channel count: %d", header->channels); 282 return false; 283 } 284 header->skip_samples = ReadLE16(data, data_size, 285 kOpusHeaderSkipSamplesOffset); 286 header->gain_db = static_cast<int16_t>( 287 ReadLE16(data, data_size, 288 kOpusHeaderGainOffset)); 289 header->channel_mapping = *(data + kOpusHeaderChannelMappingOffset); 290 if (!header->channel_mapping) { 291 if (header->channels > kMaxChannelsWithDefaultLayout) { 292 ALOGV("Invalid Header, missing stream map."); 293 return false; 294 } 295 header->num_streams = 1; 296 header->num_coupled = header->channels > 1; 297 header->stream_map[0] = 0; 298 header->stream_map[1] = 1; 299 return true; 300 } 301 if (data_size < kOpusHeaderStreamMapOffset + header->channels) { 302 ALOGV("Invalid stream map; insufficient data for current channel " 303 "count: %d", header->channels); 304 return false; 305 } 306 header->num_streams = *(data + kOpusHeaderNumStreamsOffset); 307 header->num_coupled = *(data + kOpusHeaderNumCoupledOffset); 308 if (header->num_streams + header->num_coupled != header->channels) { 309 ALOGV("Inconsistent channel mapping."); 310 return false; 311 } 312 for (int i = 0; i < header->channels; ++i) 313 header->stream_map[i] = *(data + kOpusHeaderStreamMapOffset + i); 314 return true; 315 } 316 317 // Convert nanoseconds to number of samples. 318 static uint64_t ns_to_samples(uint64_t ns, int kRate) { 319 return static_cast<double>(ns) * kRate / 1000000000; 320 } 321 322 void SoftOpus::onQueueFilled(OMX_U32 portIndex) { 323 List<BufferInfo *> &inQueue = getPortQueue(0); 324 List<BufferInfo *> &outQueue = getPortQueue(1); 325 326 if (mOutputPortSettingsChange != NONE) { 327 return; 328 } 329 330 if (portIndex == 0 && mInputBufferCount < 3) { 331 BufferInfo *info = *inQueue.begin(); 332 OMX_BUFFERHEADERTYPE *header = info->mHeader; 333 334 const uint8_t *data = header->pBuffer + header->nOffset; 335 size_t size = header->nFilledLen; 336 337 if (mInputBufferCount == 0) { 338 CHECK(mHeader == NULL); 339 mHeader = new OpusHeader(); 340 memset(mHeader, 0, sizeof(*mHeader)); 341 if (!ParseOpusHeader(data, size, mHeader)) { 342 ALOGV("Parsing Opus Header failed."); 343 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 344 return; 345 } 346 347 uint8_t channel_mapping[kMaxChannels] = {0}; 348 memcpy(&channel_mapping, 349 kDefaultOpusChannelLayout, 350 kMaxChannelsWithDefaultLayout); 351 352 int status = OPUS_INVALID_STATE; 353 mDecoder = opus_multistream_decoder_create(kRate, 354 mHeader->channels, 355 mHeader->num_streams, 356 mHeader->num_coupled, 357 channel_mapping, 358 &status); 359 if (!mDecoder || status != OPUS_OK) { 360 ALOGV("opus_multistream_decoder_create failed status=%s", 361 opus_strerror(status)); 362 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 363 return; 364 } 365 status = 366 opus_multistream_decoder_ctl(mDecoder, 367 OPUS_SET_GAIN(mHeader->gain_db)); 368 if (status != OPUS_OK) { 369 ALOGV("Failed to set OPUS header gain; status=%s", 370 opus_strerror(status)); 371 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 372 return; 373 } 374 } else if (mInputBufferCount == 1) { 375 mCodecDelay = ns_to_samples( 376 *(reinterpret_cast<int64_t*>(header->pBuffer + 377 header->nOffset)), 378 kRate); 379 mSamplesToDiscard = mCodecDelay; 380 } else { 381 mSeekPreRoll = ns_to_samples( 382 *(reinterpret_cast<int64_t*>(header->pBuffer + 383 header->nOffset)), 384 kRate); 385 notify(OMX_EventPortSettingsChanged, 1, 0, NULL); 386 mOutputPortSettingsChange = AWAITING_DISABLED; 387 } 388 389 inQueue.erase(inQueue.begin()); 390 info->mOwnedByUs = false; 391 notifyEmptyBufferDone(header); 392 ++mInputBufferCount; 393 return; 394 } 395 396 while (!inQueue.empty() && !outQueue.empty()) { 397 BufferInfo *inInfo = *inQueue.begin(); 398 OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader; 399 400 BufferInfo *outInfo = *outQueue.begin(); 401 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 402 403 if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) { 404 inQueue.erase(inQueue.begin()); 405 inInfo->mOwnedByUs = false; 406 notifyEmptyBufferDone(inHeader); 407 408 outHeader->nFilledLen = 0; 409 outHeader->nFlags = OMX_BUFFERFLAG_EOS; 410 411 outQueue.erase(outQueue.begin()); 412 outInfo->mOwnedByUs = false; 413 notifyFillBufferDone(outHeader); 414 return; 415 } 416 417 if (inHeader->nOffset == 0) { 418 mAnchorTimeUs = inHeader->nTimeStamp; 419 mNumFramesOutput = 0; 420 } 421 422 // When seeking to zero, |mCodecDelay| samples has to be discarded 423 // instead of |mSeekPreRoll| samples (as we would when seeking to any 424 // other timestamp). 425 if (inHeader->nTimeStamp == 0) { 426 mSamplesToDiscard = mCodecDelay; 427 } 428 429 const uint8_t *data = inHeader->pBuffer + inHeader->nOffset; 430 const uint32_t size = inHeader->nFilledLen; 431 432 int numFrames = opus_multistream_decode(mDecoder, 433 data, 434 size, 435 (int16_t *)outHeader->pBuffer, 436 kMaxOpusOutputPacketSizeSamples, 437 0); 438 if (numFrames < 0) { 439 ALOGE("opus_multistream_decode returned %d", numFrames); 440 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 441 return; 442 } 443 444 outHeader->nOffset = 0; 445 if (mSamplesToDiscard > 0) { 446 if (mSamplesToDiscard > numFrames) { 447 mSamplesToDiscard -= numFrames; 448 numFrames = 0; 449 } else { 450 numFrames -= mSamplesToDiscard; 451 outHeader->nOffset = mSamplesToDiscard * sizeof(int16_t) * 452 mHeader->channels; 453 mSamplesToDiscard = 0; 454 } 455 } 456 457 outHeader->nFilledLen = numFrames * sizeof(int16_t) * mHeader->channels; 458 outHeader->nFlags = 0; 459 460 outHeader->nTimeStamp = mAnchorTimeUs + 461 (mNumFramesOutput * 1000000ll) / 462 kRate; 463 464 mNumFramesOutput += numFrames; 465 466 inInfo->mOwnedByUs = false; 467 inQueue.erase(inQueue.begin()); 468 inInfo = NULL; 469 notifyEmptyBufferDone(inHeader); 470 inHeader = NULL; 471 472 outInfo->mOwnedByUs = false; 473 outQueue.erase(outQueue.begin()); 474 outInfo = NULL; 475 notifyFillBufferDone(outHeader); 476 outHeader = NULL; 477 478 ++mInputBufferCount; 479 } 480 } 481 482 void SoftOpus::onPortFlushCompleted(OMX_U32 portIndex) { 483 if (portIndex == 0 && mDecoder != NULL) { 484 // Make sure that the next buffer output does not still 485 // depend on fragments from the last one decoded. 486 mNumFramesOutput = 0; 487 opus_multistream_decoder_ctl(mDecoder, OPUS_RESET_STATE); 488 mAnchorTimeUs = 0; 489 mSamplesToDiscard = mSeekPreRoll; 490 } 491 } 492 493 void SoftOpus::onReset() { 494 mInputBufferCount = 0; 495 mNumFramesOutput = 0; 496 if (mDecoder != NULL) { 497 opus_multistream_decoder_destroy(mDecoder); 498 mDecoder = NULL; 499 } 500 if (mHeader != NULL) { 501 delete mHeader; 502 mHeader = NULL; 503 } 504 505 mOutputPortSettingsChange = NONE; 506 } 507 508 void SoftOpus::onPortEnableCompleted(OMX_U32 portIndex, bool enabled) { 509 if (portIndex != 1) { 510 return; 511 } 512 513 switch (mOutputPortSettingsChange) { 514 case NONE: 515 break; 516 517 case AWAITING_DISABLED: 518 { 519 CHECK(!enabled); 520 mOutputPortSettingsChange = AWAITING_ENABLED; 521 break; 522 } 523 524 default: 525 { 526 CHECK_EQ((int)mOutputPortSettingsChange, (int)AWAITING_ENABLED); 527 CHECK(enabled); 528 mOutputPortSettingsChange = NONE; 529 break; 530 } 531 } 532 } 533 534 } // namespace android 535 536 android::SoftOMXComponent *createSoftOMXComponent( 537 const char *name, const OMX_CALLBACKTYPE *callbacks, 538 OMX_PTR appData, OMX_COMPONENTTYPE **component) { 539 return new android::SoftOpus(name, callbacks, appData, component); 540 } 541