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