VideoEditorAudioDecoder.cpp revision b5c7784c96a606890eb8a8b560153ef4a5d1a0d9
1/* 2 * Copyright (C) 2011 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************************************************************************* 18* @file VideoEditorAudioDecoder.cpp 19* @brief StageFright shell Audio Decoder 20************************************************************************* 21*/ 22 23#define LOG_NDEBUG 1 24#define LOG_TAG "VIDEOEDITOR_AUDIODECODER" 25 26#include "M4OSA_Debug.h" 27#include "VideoEditorAudioDecoder.h" 28#include "VideoEditorUtils.h" 29#include "M4MCS_InternalTypes.h" 30 31#include "utils/Log.h" 32#include <media/stagefright/MediaSource.h> 33#include <media/stagefright/MediaDebug.h> 34#include <media/stagefright/MediaDefs.h> 35#include <media/stagefright/MetaData.h> 36#include <media/stagefright/OMXClient.h> 37#include <media/stagefright/OMXCodec.h> 38 39/******************** 40 * DEFINITIONS * 41 ********************/ 42// Version 43#define VIDEOEDITOR_AUDIO_DECODER_VERSION_MAJOR 1 44#define VIDEOEDITOR_AUDIO_DECODER_VERSION_MINOR 0 45#define VIDEOEDITOR_AUDIO_DECODER_VERSION_REV 0 46 47// Force using software decoder as engine does not support prefetch 48#define VIDEOEDITOR_FORCECODEC kSoftwareCodecsOnly 49 50namespace android { 51 52struct VideoEditorAudioDecoderSource : public MediaSource { 53 public: 54 static sp<VideoEditorAudioDecoderSource> Create( 55 const sp<MetaData>& format); 56 virtual status_t start(MetaData *params = NULL); 57 virtual status_t stop(); 58 virtual sp<MetaData> getFormat(); 59 virtual status_t read(MediaBuffer **buffer, 60 const ReadOptions *options = NULL); 61 virtual int32_t storeBuffer(MediaBuffer *buffer); 62 63 protected: 64 virtual ~VideoEditorAudioDecoderSource(); 65 66 private: 67 struct MediaBufferChain { 68 MediaBuffer* buffer; 69 MediaBufferChain* nextLink; 70 }; 71 enum State { 72 CREATED, 73 STARTED, 74 ERROR 75 }; 76 VideoEditorAudioDecoderSource(const sp<MetaData>& format); 77 sp<MetaData> mFormat; 78 MediaBufferChain* mFirstBufferLink; 79 MediaBufferChain* mLastBufferLink; 80 int32_t mNbBuffer; 81 bool mIsEOS; 82 State mState; 83}; 84 85sp<VideoEditorAudioDecoderSource> VideoEditorAudioDecoderSource::Create( 86 const sp<MetaData>& format) { 87 88 sp<VideoEditorAudioDecoderSource> aSource = 89 new VideoEditorAudioDecoderSource(format); 90 91 return aSource; 92} 93 94VideoEditorAudioDecoderSource::VideoEditorAudioDecoderSource( 95 const sp<MetaData>& format): 96 mFormat(format), 97 mFirstBufferLink(NULL), 98 mLastBufferLink(NULL), 99 mNbBuffer(0), 100 mIsEOS(false), 101 mState(CREATED) { 102} 103 104VideoEditorAudioDecoderSource::~VideoEditorAudioDecoderSource() { 105 106 if( STARTED == mState ) { 107 stop(); 108 } 109} 110 111status_t VideoEditorAudioDecoderSource::start(MetaData *meta) { 112 status_t err = OK; 113 114 if( CREATED != mState ) { 115 LOGV("VideoEditorAudioDecoderSource::start: invalid state %d", mState); 116 return UNKNOWN_ERROR; 117 } 118 119 mState = STARTED; 120 121cleanUp: 122 LOGV("VideoEditorAudioDecoderSource::start END (0x%x)", err); 123 return err; 124} 125 126status_t VideoEditorAudioDecoderSource::stop() { 127 status_t err = OK; 128 int32_t i = 0; 129 130 LOGV("VideoEditorAudioDecoderSource::stop begin"); 131 132 if( STARTED != mState ) { 133 LOGV("VideoEditorAudioDecoderSource::stop: invalid state %d", mState); 134 return UNKNOWN_ERROR; 135 } 136 137 // Release the buffer chain 138 MediaBufferChain* tmpLink = NULL; 139 while( mFirstBufferLink ) { 140 i++; 141 tmpLink = mFirstBufferLink; 142 mFirstBufferLink = mFirstBufferLink->nextLink; 143 delete tmpLink; 144 } 145 LOGV("VideoEditorAudioDecoderSource::stop : %d buffer remained", i); 146 mFirstBufferLink = NULL; 147 mLastBufferLink = NULL; 148 149 mState = CREATED; 150 151 LOGV("VideoEditorAudioDecoderSource::stop END (0x%x)", err); 152 return err; 153} 154 155sp<MetaData> VideoEditorAudioDecoderSource::getFormat() { 156 157 LOGV("VideoEditorAudioDecoderSource::getFormat"); 158 return mFormat; 159} 160 161status_t VideoEditorAudioDecoderSource::read(MediaBuffer **buffer, 162 const ReadOptions *options) { 163 MediaSource::ReadOptions readOptions; 164 status_t err = OK; 165 MediaBufferChain* tmpLink = NULL; 166 167 LOGV("VideoEditorAudioDecoderSource::read begin"); 168 169 if ( STARTED != mState ) { 170 LOGV("VideoEditorAudioDecoderSource::read invalid state %d", mState); 171 return UNKNOWN_ERROR; 172 } 173 174 // Get a buffer from the chain 175 if( NULL == mFirstBufferLink ) { 176 *buffer = NULL; 177 if( mIsEOS ) { 178 LOGV("VideoEditorAudioDecoderSource::read : EOS"); 179 return ERROR_END_OF_STREAM; 180 } else { 181 LOGV("VideoEditorAudioDecoderSource::read : no buffer available"); 182 return UNKNOWN_ERROR; 183 } 184 } 185 *buffer = mFirstBufferLink->buffer; 186 187 tmpLink = mFirstBufferLink; 188 mFirstBufferLink = mFirstBufferLink->nextLink; 189 if( NULL == mFirstBufferLink ) { 190 mLastBufferLink = NULL; 191 } 192 delete tmpLink; 193 mNbBuffer--; 194 195 LOGV("VideoEditorAudioDecoderSource::read END (0x%x)", err); 196 return err; 197} 198 199int32_t VideoEditorAudioDecoderSource::storeBuffer(MediaBuffer *buffer) { 200 status_t err = OK; 201 202 LOGV("VideoEditorAudioDecoderSource::storeBuffer begin"); 203 204 // A NULL input buffer means that the end of stream was reached 205 if( NULL == buffer ) { 206 mIsEOS = true; 207 } else { 208 MediaBufferChain* newLink = new MediaBufferChain; 209 newLink->buffer = buffer; 210 newLink->nextLink = NULL; 211 if( NULL != mLastBufferLink ) { 212 mLastBufferLink->nextLink = newLink; 213 } else { 214 mFirstBufferLink = newLink; 215 } 216 mLastBufferLink = newLink; 217 mNbBuffer++; 218 } 219 LOGV("VideoEditorAudioDecoderSource::storeBuffer END"); 220 return mNbBuffer; 221} 222 223/******************** 224 * TOOLS * 225 ********************/ 226 227M4OSA_ERR VideoEditorAudioDecoder_getBits(M4OSA_Int8* pData, 228 M4OSA_UInt32 dataSize, M4OSA_UInt8 nbBits, M4OSA_Int32* pResult, 229 M4OSA_UInt32* pOffset) { 230 231 M4OSA_ERR err = M4NO_ERROR; 232 M4OSA_UInt32 startByte = 0; 233 M4OSA_UInt32 startBit = 0; 234 M4OSA_UInt32 endByte = 0; 235 M4OSA_UInt32 endBit = 0; 236 M4OSA_UInt32 currentByte = 0; 237 M4OSA_UInt32 result = 0; 238 M4OSA_UInt32 ui32Tmp = 0; 239 M4OSA_UInt32 ui32Mask = 0; 240 241 // Input parameters check 242 VIDEOEDITOR_CHECK(M4OSA_NULL != pData, M4ERR_PARAMETER); 243 VIDEOEDITOR_CHECK(M4OSA_NULL != pOffset, M4ERR_PARAMETER); 244 VIDEOEDITOR_CHECK(32 >= nbBits, M4ERR_PARAMETER); 245 VIDEOEDITOR_CHECK((*pOffset + nbBits) <= 8*dataSize, M4ERR_PARAMETER); 246 247 LOGV("VideoEditorAudioDecoder_getBits begin"); 248 249 startByte = (*pOffset) >> 3; 250 endByte = (*pOffset + nbBits) >> 3; 251 startBit = (*pOffset) % 8; 252 endBit = (*pOffset + nbBits) % 8; 253 currentByte = startByte; 254 255 // Extract the requested nunber of bits from memory 256 while( currentByte <= endByte) { 257 ui32Mask = 0x000000FF; 258 if( currentByte == startByte ) { 259 ui32Mask >>= startBit; 260 } 261 ui32Tmp = ui32Mask & ((M4OSA_UInt32)pData[currentByte]); 262 if( currentByte == endByte ) { 263 ui32Tmp >>= (8-endBit); 264 result <<= endBit; 265 } else { 266 result <<= 8; 267 } 268 result |= ui32Tmp; 269 currentByte++; 270 } 271 272 *pResult = result; 273 *pOffset += nbBits; 274 275cleanUp: 276 if( M4NO_ERROR == err ) { 277 LOGV("VideoEditorAudioDecoder_getBits no error"); 278 } else { 279 LOGV("VideoEditorAudioDecoder_getBits ERROR 0x%X", err); 280 } 281 LOGV("VideoEditorAudioDecoder_getBits end"); 282 return err; 283} 284 285 286#define FREQ_TABLE_SIZE 16 287const M4OSA_UInt32 AD_AAC_FREQ_TABLE[FREQ_TABLE_SIZE] = 288 {96000, 88200, 64000, 48000, 44100, 289 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, 0, 0, 0}; 290 291 292M4OSA_ERR VideoEditorAudioDecoder_parse_AAC_DSI(M4OSA_Int8* pDSI, 293 M4OSA_UInt32 dsiSize, AAC_DEC_STREAM_PROPS* pProperties) { 294 295 M4OSA_ERR err = M4NO_ERROR; 296 M4OSA_UInt32 offset = 0; 297 M4OSA_Int32 result = 0; 298 299 LOGV("VideoEditorAudioDecoder_parse_AAC_DSI begin"); 300 301 // Input parameters check 302 VIDEOEDITOR_CHECK(M4OSA_NULL != pDSI, M4ERR_PARAMETER); 303 VIDEOEDITOR_CHECK(M4OSA_NULL != pProperties, M4ERR_PARAMETER); 304 305 // Get the object type 306 err = VideoEditorAudioDecoder_getBits(pDSI, dsiSize, 5, &result, &offset); 307 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 308 switch( result ) { 309 case 2: 310 pProperties->aPSPresent = 0; 311 pProperties->aSBRPresent = 0; 312 break; 313 default: 314 LOGV("parse_AAC_DSI ERROR : object type %d is not supported", 315 result); 316 VIDEOEDITOR_CHECK(!"invalid AAC object type", M4ERR_BAD_OPTION_ID); 317 break; 318 } 319 pProperties->aAudioObjectType = (M4OSA_Int32)result; 320 321 // Get the frequency index 322 err = VideoEditorAudioDecoder_getBits(pDSI, dsiSize, 4, &result, &offset); 323 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 324 VIDEOEDITOR_CHECK((0 <= result) && (FREQ_TABLE_SIZE > result), 325 M4ERR_PARAMETER); 326 pProperties->aSampFreq = AD_AAC_FREQ_TABLE[result]; 327 pProperties->aExtensionSampFreq = 0; 328 329 // Get the number of channels 330 err = VideoEditorAudioDecoder_getBits(pDSI, dsiSize, 4, &result, &offset); 331 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 332 pProperties->aNumChan = (M4OSA_UInt32)result; 333 334 // Set the max PCM samples per channel 335 pProperties->aMaxPCMSamplesPerCh = (pProperties->aSBRPresent) ? 2048 : 1024; 336 337cleanUp: 338 if( M4NO_ERROR == err ) { 339 LOGV("VideoEditorAudioDecoder_parse_AAC_DSI no error"); 340 } else { 341 LOGV("VideoEditorAudioDecoder_parse_AAC_DSI ERROR 0x%X", err); 342 } 343 LOGV("VideoEditorAudioDecoder_parse_AAC_DSI end"); 344 return err; 345} 346 347/******************** 348 * ENGINE INTERFACE * 349 ********************/ 350 351/** 352 ****************************************************************************** 353 * structure VideoEditorAudioDecoder_Context 354 * @brief This structure defines the context of the StageFright audio decoder 355 * shell 356 ****************************************************************************** 357*/ 358typedef struct { 359 M4AD_Type mDecoderType; 360 M4_AudioStreamHandler* mAudioStreamHandler; 361 sp<VideoEditorAudioDecoderSource> mDecoderSource; 362 OMXClient mClient; 363 sp<MediaSource> mDecoder; 364 int32_t mNbOutputChannels; 365 uint32_t mNbInputFrames; 366 uint32_t mNbOutputFrames; 367} VideoEditorAudioDecoder_Context; 368 369M4OSA_ERR VideoEditorAudioDecoder_destroy(M4AD_Context pContext) { 370 M4OSA_ERR err = M4NO_ERROR; 371 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 372 373 LOGV("VideoEditorAudioDecoder_destroy begin"); 374 // Input parameters check 375 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 376 377 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 378 379 // Stop the graph 380 if( M4OSA_NULL != pDecoderContext->mDecoder.get() ) { 381 pDecoderContext->mDecoder->stop(); 382 } 383 384 // Destroy the graph 385 pDecoderContext->mDecoderSource.clear(); 386 pDecoderContext->mDecoder.clear(); 387 pDecoderContext->mClient.disconnect(); 388 389 SAFE_FREE(pDecoderContext); 390 pContext = M4OSA_NULL; 391 LOGV("VideoEditorAudioDecoder_destroy : DONE"); 392 393cleanUp: 394 if( M4NO_ERROR == err ) { 395 LOGV("VideoEditorAudioDecoder_destroy no error"); 396 } else { 397 LOGV("VideoEditorAudioDecoder_destroy ERROR 0x%X", err); 398 } 399 LOGV("VideoEditorAudioDecoder_destroy : end"); 400 return err; 401} 402 403M4OSA_ERR VideoEditorAudioDecoder_create(M4AD_Type decoderType, 404 M4AD_Context* pContext, M4_AudioStreamHandler* pStreamHandler, 405 void* pUserData) { 406 M4OSA_ERR err = M4NO_ERROR; 407 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 408 AAC_DEC_STREAM_PROPS aacProperties; 409 status_t result = OK; 410 sp<MetaData> decoderMetaData = NULL; 411 const char* mime = NULL; 412 uint32_t codecFlags = 0; 413 414 LOGV("VideoEditorAudioDecoder_create begin: decoderType %d", decoderType); 415 416 // Input parameters check 417 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 418 VIDEOEDITOR_CHECK(M4OSA_NULL != pStreamHandler, M4ERR_PARAMETER); 419 420 // Context allocation & initialization 421 SAFE_MALLOC(pDecoderContext, VideoEditorAudioDecoder_Context, 1, 422 "AudioDecoder"); 423 pDecoderContext->mDecoderType = decoderType; 424 pDecoderContext->mAudioStreamHandler = pStreamHandler; 425 426 pDecoderContext->mNbInputFrames = 0; 427 pDecoderContext->mNbOutputFrames = 0; 428 429 LOGV("VideoEditorAudioDecoder_create : maxAUSize %d", 430 pDecoderContext->mAudioStreamHandler->m_basicProperties.m_maxAUSize); 431 432 // Create the meta data for the decoder 433 decoderMetaData = new MetaData; 434 switch( pDecoderContext->mDecoderType ) { 435 case M4AD_kTypeAMRNB: 436 // StageFright parameters 437 mime = MEDIA_MIMETYPE_AUDIO_AMR_NB; 438 // Engine parameters 439 pDecoderContext->mAudioStreamHandler->m_byteFrameLength = 160; 440 // Number of bytes per sample 441 pDecoderContext->mAudioStreamHandler->m_byteSampleSize = 2; 442 pDecoderContext->mAudioStreamHandler->m_samplingFrequency = 8000; 443 pDecoderContext->mAudioStreamHandler->m_nbChannels = 1; 444 break; 445 446 case M4AD_kTypeAMRWB: 447 // StageFright parameters 448 mime = MEDIA_MIMETYPE_AUDIO_AMR_WB; 449 450 pDecoderContext->mAudioStreamHandler->m_byteFrameLength = 160; 451 // Number of bytes per sample 452 pDecoderContext->mAudioStreamHandler->m_byteSampleSize = 2; 453 pDecoderContext->mAudioStreamHandler->m_samplingFrequency = 16000; 454 pDecoderContext->mAudioStreamHandler->m_nbChannels = 1; 455 break; 456 457 case M4AD_kTypeAAC: 458 // Reject ADTS & ADIF (or any incorrect type) 459 VIDEOEDITOR_CHECK(M4DA_StreamTypeAudioAac == 460 pDecoderContext->mAudioStreamHandler->\ 461 m_basicProperties.m_streamType,M4ERR_PARAMETER); 462 463 // StageFright parameters 464 mime = MEDIA_MIMETYPE_AUDIO_AAC; 465 466 decoderMetaData->setData(kKeyESDS, kTypeESDS, 467 pStreamHandler->m_basicProperties.m_pESDSInfo, 468 pStreamHandler->m_basicProperties.m_ESDSInfoSize); 469 470 // Engine parameters 471 // Retrieve sampling frequency and number of channels from the DSI 472 err = VideoEditorAudioDecoder_parse_AAC_DSI( 473 (M4OSA_Int8*)pStreamHandler->m_basicProperties.\ 474 m_pDecoderSpecificInfo, 475 pStreamHandler->m_basicProperties.m_decoderSpecificInfoSize, 476 &aacProperties); 477 478 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 479 pDecoderContext->mAudioStreamHandler->m_byteFrameLength = 1024; 480 // Number of bytes per sample 481 pDecoderContext->mAudioStreamHandler->m_byteSampleSize = 2; 482 pDecoderContext->mAudioStreamHandler->m_samplingFrequency = 483 aacProperties.aSampFreq; 484 pDecoderContext->mAudioStreamHandler->m_nbChannels = 485 aacProperties.aNumChan; 486 487 // Copy the stream properties into userdata 488 if( M4OSA_NULL != pUserData ) { 489 memcpy((void *)pUserData, 490 (void *)&aacProperties, 491 sizeof(AAC_DEC_STREAM_PROPS)); 492 } 493 break; 494 495 case M4AD_kTypeMP3: 496 // StageFright parameters 497 mime = MEDIA_MIMETYPE_AUDIO_MPEG; 498 break; 499 500 default: 501 VIDEOEDITOR_CHECK(!"AudioDecoder_open : incorrect input format", 502 M4ERR_STATE); 503 break; 504 } 505 decoderMetaData->setCString(kKeyMIMEType, mime); 506 decoderMetaData->setInt32(kKeySampleRate, 507 (int32_t)pDecoderContext->mAudioStreamHandler->m_samplingFrequency); 508 decoderMetaData->setInt32(kKeyChannelCount, 509 pDecoderContext->mAudioStreamHandler->m_nbChannels); 510 decoderMetaData->setInt64(kKeyDuration, 511 (int64_t)pDecoderContext->mAudioStreamHandler->\ 512 m_basicProperties.m_duration); 513 514 // Create the decoder source 515 pDecoderContext->mDecoderSource = VideoEditorAudioDecoderSource::Create( 516 decoderMetaData); 517 VIDEOEDITOR_CHECK(NULL != pDecoderContext->mDecoderSource.get(), 518 M4ERR_STATE); 519 520 // Connect to the OMX client 521 result = pDecoderContext->mClient.connect(); 522 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE); 523 524 // Create the OMX codec 525#ifdef VIDEOEDITOR_FORCECODEC 526 codecFlags |= OMXCodec::VIDEOEDITOR_FORCECODEC; 527#endif /* VIDEOEDITOR_FORCECODEC */ 528 529 pDecoderContext->mDecoder = OMXCodec::Create(pDecoderContext->\ 530 mClient.interface(), 531 decoderMetaData, false, pDecoderContext->mDecoderSource, NULL, 532 codecFlags); 533 VIDEOEDITOR_CHECK(NULL != pDecoderContext->mDecoder.get(), M4ERR_STATE); 534 535 // Get the output channels, the decoder might overwrite the input metadata 536 pDecoderContext->mDecoder->getFormat()->findInt32(kKeyChannelCount, 537 &pDecoderContext->mNbOutputChannels); 538 LOGV("VideoEditorAudioDecoder_create : output chan %d", 539 pDecoderContext->mNbOutputChannels); 540 541 // Start the decoder 542 result = pDecoderContext->mDecoder->start(); 543 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE); 544 545 *pContext = pDecoderContext; 546 LOGV("VideoEditorAudioDecoder_create : DONE"); 547 548cleanUp: 549 if( M4NO_ERROR == err ) { 550 LOGV("VideoEditorAudioDecoder_create no error"); 551 } else { 552 VideoEditorAudioDecoder_destroy(pDecoderContext); 553 *pContext = M4OSA_NULL; 554 LOGV("VideoEditorAudioDecoder_create ERROR 0x%X", err); 555 } 556 return err; 557} 558 559M4OSA_ERR VideoEditorAudioDecoder_create_AAC(M4AD_Context* pContext, 560 M4_AudioStreamHandler* pStreamHandler, void* pUserData) { 561 562 return VideoEditorAudioDecoder_create( 563 M4AD_kTypeAAC, pContext, pStreamHandler,pUserData); 564} 565 566 567M4OSA_ERR VideoEditorAudioDecoder_create_AMRNB(M4AD_Context* pContext, 568 M4_AudioStreamHandler* pStreamHandler, void* pUserData) { 569 570 return VideoEditorAudioDecoder_create( 571 M4AD_kTypeAMRNB, pContext, pStreamHandler, pUserData); 572} 573 574 575M4OSA_ERR VideoEditorAudioDecoder_create_AMRWB(M4AD_Context* pContext, 576 M4_AudioStreamHandler* pStreamHandler, void* pUserData) { 577 578 return VideoEditorAudioDecoder_create( 579 M4AD_kTypeAMRWB, pContext, pStreamHandler, pUserData); 580} 581 582 583M4OSA_ERR VideoEditorAudioDecoder_create_MP3(M4AD_Context* pContext, 584 M4_AudioStreamHandler* pStreamHandler, void* pUserData) { 585 586 return VideoEditorAudioDecoder_create( 587 M4AD_kTypeMP3, pContext, pStreamHandler, pUserData); 588} 589 590M4OSA_ERR VideoEditorAudioDecoder_processInputBuffer( 591 M4AD_Context pContext, M4AD_Buffer* pInputBuffer) { 592 M4OSA_ERR err = M4NO_ERROR; 593 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 594 MediaBuffer* buffer = NULL; 595 int32_t nbBuffer = 0; 596 597 LOGV("VideoEditorAudioDecoder_processInputBuffer begin"); 598 // Input parameters check 599 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 600 601 602 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 603 604 if( M4OSA_NULL != pInputBuffer ) { 605 buffer = new MediaBuffer((size_t)pInputBuffer->m_bufferSize); 606 memcpy((void *)((M4OSA_Int8*)buffer->data() + buffer->range_offset()), 607 (void *)pInputBuffer->m_dataAddress, pInputBuffer->m_bufferSize); 608 } 609 nbBuffer = pDecoderContext->mDecoderSource->storeBuffer(buffer); 610 611cleanUp: 612 if( M4NO_ERROR == err ) { 613 LOGV("VideoEditorAudioDecoder_processInputBuffer no error"); 614 } else { 615 LOGV("VideoEditorAudioDecoder_processInputBuffer ERROR 0x%X", err); 616 } 617 LOGV("VideoEditorAudioDecoder_processInputBuffer end"); 618 return err; 619} 620 621M4OSA_ERR VideoEditorAudioDecoder_processOutputBuffer(M4AD_Context pContext, 622 MediaBuffer* buffer, M4AD_Buffer* pOuputBuffer) { 623 M4OSA_ERR err = M4NO_ERROR; 624 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 625 int32_t i32Tmp = 0; 626 int64_t i64Tmp = 0; 627 status_t result = OK; 628 629 LOGV("VideoEditorAudioDecoder_processOutputBuffer begin"); 630 // Input parameters check 631 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 632 VIDEOEDITOR_CHECK(M4OSA_NULL != buffer, M4ERR_PARAMETER); 633 VIDEOEDITOR_CHECK(M4OSA_NULL != pOuputBuffer, M4ERR_PARAMETER); 634 635 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 636 637 // Process the returned data 638 if( 0 == buffer->range_length() ) { 639 // Decoder has no data yet, nothing unusual 640 goto cleanUp; 641 } 642 643 pDecoderContext->mNbOutputFrames++; 644 645 if( pDecoderContext->mAudioStreamHandler->m_nbChannels == 646 (M4OSA_UInt32)pDecoderContext->mNbOutputChannels ) { 647 // Just copy the PCMs 648 pOuputBuffer->m_bufferSize = (M4OSA_UInt32)buffer->range_length(); 649 memcpy((void *)pOuputBuffer->m_dataAddress, 650 (void *)(((M4OSA_MemAddr8)buffer->data())+buffer->range_offset()), 651 buffer->range_length()); 652 } else if( pDecoderContext->mAudioStreamHandler->m_nbChannels < 653 (M4OSA_UInt32)pDecoderContext->mNbOutputChannels ) { 654 // The decoder forces stereo output, downsample 655 pOuputBuffer->m_bufferSize = (M4OSA_UInt32)(buffer->range_length()/2); 656 M4OSA_Int16* pDataIn = ((M4OSA_Int16*)buffer->data()) + 657 buffer->range_offset(); 658 M4OSA_Int16* pDataOut = (M4OSA_Int16*)pOuputBuffer->m_dataAddress; 659 M4OSA_Int16* pDataEnd = pDataIn + \ 660 (buffer->range_length()/sizeof(M4OSA_Int16)); 661 while( pDataIn < pDataEnd ) { 662 *pDataOut = *pDataIn; 663 pDataIn+=2; 664 pDataOut++; 665 } 666 } else { 667 // The decoder forces mono output, not supported 668 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_PARAMETER); 669 } 670 671cleanUp: 672 // Release the buffer 673 buffer->release(); 674 if( M4NO_ERROR == err ) { 675 LOGV("VideoEditorAudioDecoder_processOutputBuffer no error"); 676 } else { 677 pOuputBuffer->m_bufferSize = 0; 678 LOGV("VideoEditorAudioDecoder_processOutputBuffer ERROR 0x%X", err); 679 } 680 LOGV("VideoEditorAudioDecoder_processOutputBuffer end"); 681 return err; 682} 683 684M4OSA_ERR VideoEditorAudioDecoder_step(M4AD_Context pContext, 685 M4AD_Buffer* pInputBuffer, M4AD_Buffer* pOutputBuffer, 686 M4OSA_Bool bJump) { 687 M4OSA_ERR err = M4NO_ERROR; 688 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 689 status_t result = OK; 690 MediaBuffer* outputBuffer = NULL; 691 692 LOGV("VideoEditorAudioDecoder_step begin"); 693 // Input parameters check 694 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 695 696 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 697 pDecoderContext->mNbInputFrames++; 698 699 // Push the input buffer to the decoder source 700 err = VideoEditorAudioDecoder_processInputBuffer(pDecoderContext, 701 pInputBuffer); 702 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 703 704 // Read 705 result = pDecoderContext->mDecoder->read(&outputBuffer, NULL); 706 if(OK != result) { 707 LOGE("VideoEditorAudioDecoder_step result = %d",result); 708 709 } 710 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE); 711 712 // Convert the PCM buffer 713 err = VideoEditorAudioDecoder_processOutputBuffer(pDecoderContext, 714 outputBuffer, pOutputBuffer); 715 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err); 716 717cleanUp: 718 if( M4NO_ERROR == err ) { 719 LOGV("VideoEditorAudioDecoder_step no error"); 720 } else { 721 LOGV("VideoEditorAudioDecoder_step ERROR 0x%X", err); 722 } 723 LOGV("VideoEditorAudioDecoder_step end"); 724 return err; 725} 726 727M4OSA_ERR VideoEditorAudioDecoder_getVersion(M4_VersionInfo* pVersionInfo) { 728 M4OSA_ERR err = M4NO_ERROR; 729 730 LOGV("VideoEditorAudioDecoder_getVersion begin"); 731 // Input parameters check 732 VIDEOEDITOR_CHECK(M4OSA_NULL != pVersionInfo, M4ERR_PARAMETER); 733 734 pVersionInfo->m_major = VIDEOEDITOR_AUDIO_DECODER_VERSION_MAJOR; 735 pVersionInfo->m_minor = VIDEOEDITOR_AUDIO_DECODER_VERSION_MINOR; 736 pVersionInfo->m_revision = VIDEOEDITOR_AUDIO_DECODER_VERSION_REV; 737 pVersionInfo->m_structSize = sizeof(M4_VersionInfo); 738 739cleanUp: 740 if( M4NO_ERROR == err ) { 741 LOGV("VideoEditorAudioDecoder_getVersion no error"); 742 } else { 743 LOGV("VideoEditorAudioDecoder_getVersion ERROR 0x%X", err); 744 } 745 LOGV("VideoEditorAudioDecoder_getVersion end"); 746 return err; 747} 748 749M4OSA_ERR VideoEditorAudioDecoder_setOption(M4AD_Context pContext, 750 M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) { 751 752 M4OSA_ERR err = M4NO_ERROR; 753 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 754 755 LOGV("VideoEditorAudioDecoder_setOption begin 0x%X", optionID); 756 // Input parameters check 757 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 758 759 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 760 761 switch( optionID ) { 762 case M4AD_kOptionID_UserParam: 763 LOGV("VideoEditorAudioDecodersetOption UserParam is not supported"); 764 err = M4ERR_NOT_IMPLEMENTED; 765 break; 766 default: 767 LOGV("VideoEditorAudioDecoder_setOption unsupported optionId 0x%X", 768 optionID); 769 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID); 770 break; 771 } 772 773cleanUp: 774 if( ((M4OSA_UInt32)M4NO_ERROR == err) || ((M4OSA_UInt32)M4ERR_NOT_IMPLEMENTED == err) ) { 775 LOGV("VideoEditorAudioDecoder_setOption error 0x%X", err); 776 } else { 777 LOGV("VideoEditorAudioDecoder_setOption ERROR 0x%X", err); 778 } 779 LOGV("VideoEditorAudioDecoder_setOption end"); 780 return err; 781} 782 783M4OSA_ERR VideoEditorAudioDecoder_getOption(M4AD_Context pContext, 784 M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) { 785 786 M4OSA_ERR err = M4NO_ERROR; 787 VideoEditorAudioDecoder_Context* pDecoderContext = M4OSA_NULL; 788 789 LOGV("VideoEditorAudioDecoder_getOption begin: optionID 0x%X", optionID); 790 // Input parameters check 791 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER); 792 793 pDecoderContext = (VideoEditorAudioDecoder_Context*)pContext; 794 795 switch( optionID ) { 796 default: 797 LOGV("VideoEditorAudioDecoder_getOption unsupported optionId 0x%X", 798 optionID); 799 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID); 800 break; 801 } 802 803cleanUp: 804 if( M4NO_ERROR == err ) { 805 LOGV("VideoEditorAudioDecoder_getOption no error"); 806 } else { 807 LOGV("VideoEditorAudioDecoder_getOption ERROR 0x%X", err); 808 } 809 LOGV("VideoEditorAudioDecoder_getOption end"); 810 return err; 811} 812 813M4OSA_ERR VideoEditorAudioDecoder_getInterface(M4AD_Type decoderType, 814 M4AD_Type* pDecoderType, M4AD_Interface** pDecoderInterface) { 815 816 M4OSA_ERR err = M4NO_ERROR; 817 818 // Input parameters check 819 VIDEOEDITOR_CHECK(M4OSA_NULL != pDecoderType, M4ERR_PARAMETER); 820 VIDEOEDITOR_CHECK(M4OSA_NULL != pDecoderInterface, M4ERR_PARAMETER); 821 822 LOGV("VideoEditorAudioDecoder_getInterface begin %d 0x%x 0x%x", 823 decoderType, pDecoderType, pDecoderInterface); 824 825 SAFE_MALLOC(*pDecoderInterface, M4AD_Interface, 1, 826 "VideoEditorAudioDecoder"); 827 828 *pDecoderType = decoderType; 829 830 switch( decoderType ) { 831 case M4AD_kTypeAMRNB: 832 (*pDecoderInterface)->m_pFctCreateAudioDec = 833 VideoEditorAudioDecoder_create_AMRNB; 834 break; 835 case M4AD_kTypeAMRWB: 836 (*pDecoderInterface)->m_pFctCreateAudioDec = 837 VideoEditorAudioDecoder_create_AMRWB; 838 break; 839 case M4AD_kTypeAAC: 840 (*pDecoderInterface)->m_pFctCreateAudioDec = 841 VideoEditorAudioDecoder_create_AAC; 842 break; 843 case M4AD_kTypeMP3: 844 (*pDecoderInterface)->m_pFctCreateAudioDec = 845 VideoEditorAudioDecoder_create_MP3; 846 break; 847 default: 848 LOGV("VEAD_getInterface ERROR: unsupported type %d", decoderType); 849 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_PARAMETER); 850 break; 851 } 852 (*pDecoderInterface)->m_pFctDestroyAudioDec = 853 VideoEditorAudioDecoder_destroy; 854 (*pDecoderInterface)->m_pFctResetAudioDec = M4OSA_NULL; 855 (*pDecoderInterface)->m_pFctStartAudioDec = M4OSA_NULL; 856 (*pDecoderInterface)->m_pFctStepAudioDec = 857 VideoEditorAudioDecoder_step; 858 (*pDecoderInterface)->m_pFctGetVersionAudioDec = 859 VideoEditorAudioDecoder_getVersion; 860 (*pDecoderInterface)->m_pFctSetOptionAudioDec = 861 VideoEditorAudioDecoder_setOption; 862 (*pDecoderInterface)->m_pFctGetOptionAudioDec = 863 VideoEditorAudioDecoder_getOption; 864 865cleanUp: 866 if( M4NO_ERROR == err ) { 867 LOGV("VideoEditorAudioDecoder_getInterface no error"); 868 } else { 869 *pDecoderInterface = M4OSA_NULL; 870 LOGV("VideoEditorAudioDecoder_getInterface ERROR 0x%X", err); 871 } 872 LOGV("VideoEditorAudioDecoder_getInterface end"); 873 return err; 874} 875 876 877extern "C" { 878 879M4OSA_ERR VideoEditorAudioDecoder_getInterface_AAC(M4AD_Type* pDecoderType, 880 M4AD_Interface** pDecoderInterface) { 881 LOGV("TEST: AAC VideoEditorAudioDecoder_getInterface no error"); 882 return VideoEditorAudioDecoder_getInterface( 883 M4AD_kTypeAAC, pDecoderType, pDecoderInterface); 884} 885 886M4OSA_ERR VideoEditorAudioDecoder_getInterface_AMRNB(M4AD_Type* pDecoderType, 887 M4AD_Interface** pDecoderInterface) { 888 LOGV("TEST: AMR VideoEditorAudioDecoder_getInterface no error"); 889 return VideoEditorAudioDecoder_getInterface( 890 M4AD_kTypeAMRNB, pDecoderType, pDecoderInterface); 891} 892 893M4OSA_ERR VideoEditorAudioDecoder_getInterface_AMRWB(M4AD_Type* pDecoderType, 894 M4AD_Interface** pDecoderInterface) { 895 896 return VideoEditorAudioDecoder_getInterface( 897 M4AD_kTypeAMRWB, pDecoderType, pDecoderInterface); 898} 899 900M4OSA_ERR VideoEditorAudioDecoder_getInterface_MP3(M4AD_Type* pDecoderType, 901 M4AD_Interface** pDecoderInterface) { 902 903 return VideoEditorAudioDecoder_getInterface( 904 M4AD_kTypeMP3, pDecoderType, pDecoderInterface); 905} 906 907} // extern "C" 908 909} // namespace android 910