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