libstagefright/codecs/ffmpegdec/adec/SoftFFmpegAudio.cpp

   1 /*
   2  * Copyright 2012 Michael Chen <omxcodec@gmail.com>
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_NDEBUG 0
  18 #define LOG_TAG "SoftFFmpegAudio"
  19 #include <utils/Log.h>
  20
  21 #include "SoftFFmpegAudio.h"
  22
  23 #include <media/stagefright/foundation/ADebug.h>
  24 #include <media/stagefright/foundation/hexdump.h>
  25 #include <media/stagefright/MediaDefs.h>
  26
  27 #include "utils/common_utils.h"
  28 #include "utils/ffmpeg_utils.h"
  29
  30 //#undef realloc
  31 //#include <stdlib.h>
  32
  33 #define DEBUG_PKT 0
  34 #define DEBUG_FRM 0
  35
  36 /**
  37  * Note: DECLARE_ALIGNED should move from "*.h" to here, otherwise
  38  * "Fatal signal 7 (SIGBUS)"!!! SIGBUS is because of an alignment exception
  39  */
  40 DECLARE_ALIGNED(16, uint8_t, mAudioBuf2)[AVCODEC_MAX_AUDIO_FRAME_SIZE * 4];
  41
  42 namespace android {
  43
  44 template<class T>
  45 static void InitOMXParams(T *params) {
  46     params->nSize = sizeof(T);
  47     params->nVersion.s.nVersionMajor = 1;
  48     params->nVersion.s.nVersionMinor = 0;
  49     params->nVersion.s.nRevision = 0;
  50     params->nVersion.s.nStep = 0;
  51 }
  52
  53 SoftFFmpegAudio::SoftFFmpegAudio(
  54         const char *name,
  55         const OMX_CALLBACKTYPE *callbacks,
  56         OMX_PTR appData,
  57         OMX_COMPONENTTYPE **component)
  58     : SimpleSoftOMXComponent(name, callbacks, appData, component),
  59       mMode(MODE_MPEG),
  60       mCtx(NULL),
  61       mSwrCtx(NULL),
  62       mCodecOpened(false),
  63       mExtradataReady(false),
  64       mIgnoreExtradata(false),
  65       mFlushComplete(false),
  66       mSignalledError(false),
  67       mReceivedEOS(false),
  68       mFrame(NULL),
  69       mAnchorTimeUs(0),
  70       mNumFramesOutput(0),
  71       mInputBufferSize(0),
  72       mAudioBufferSize(0),
  73       mNumChannels(2),
  74       mSamplingRate(44100),
  75       mBitRate(0),
  76       mBlockAlign(0),
  77       mSamplingFmt(AV_SAMPLE_FMT_S16),
  78       mAudioConfigChanged(false),
  79       mOutputPortSettingsChange(NONE) {
  80     if (!strcmp(name, "OMX.ffmpeg.mp3.decoder")) {
  81         mMode = MODE_MPEG;
  82         mIgnoreExtradata = true;
  83     } else if (!strcmp(name, "OMX.ffmpeg.mp1.decoder")) {
  84         mMode = MODE_MPEGL1;
  85     } else if (!strcmp(name, "OMX.ffmpeg.mp2.decoder")) {
  86         mMode = MODE_MPEGL2;
  87     } else if (!strcmp(name, "OMX.ffmpeg.aac.decoder")) {
  88         mMode = MODE_AAC;
  89     } else if (!strcmp(name, "OMX.ffmpeg.wma.decoder")) {
  90         mMode = MODE_WMA;
  91     } else if (!strcmp(name, "OMX.ffmpeg.dts.decoder")) {
  92         mMode = MODE_DTS;
  93     } else if (!strcmp(name, "OMX.ffmpeg.ra.decoder")) {
  94         mMode = MODE_RA;
  95     } else if (strcmp(name, "OMX.ffmpeg.ac3.decoder")) {
  96         mMode = MODE_AC3;
  97     } else if (!strcmp(name, "OMX.ffmpeg.ape.decoder")) {
  98         mMode = MODE_APE;
  99     } else {
 100         TRESPASS();
 101     }
 102
 103     LOGV("SoftFFmpegAudio component: %s", name);
 104
 105     initPorts();
 106     CHECK_EQ(initDecoder(), (status_t)OK);
 107 }
 108
 109 SoftFFmpegAudio::~SoftFFmpegAudio() {
 110     av_freep(&mFrame);
 111     LOGV("~SoftFFmpegAudio");
 112     deInitDecoder();
 113     deInitFFmpeg();
 114 }
 115
 116 void SoftFFmpegAudio::initPorts() {
 117     OMX_PARAM_PORTDEFINITIONTYPE def;
 118     InitOMXParams(&def);
 119
 120     def.nPortIndex = 0;
 121     def.eDir = OMX_DirInput;
 122     def.nBufferCountMin = kNumBuffers;
 123     def.nBufferCountActual = def.nBufferCountMin;
 124     if (mMode == MODE_APE) {
 125         def.nBufferSize = 204800; // ape!
 126     } else if (mMode == MODE_DTS) {
 127         def.nBufferSize = 512000; // dts!
 128     } else {
 129         def.nBufferSize = 20480; // 8192 is too small
 130     }
 131     def.bEnabled = OMX_TRUE;
 132     def.bPopulated = OMX_FALSE;
 133     def.eDomain = OMX_PortDomainAudio;
 134     def.bBuffersContiguous = OMX_FALSE;
 135     def.nBufferAlignment = 1;
 136
 137     switch (mMode) {
 138     case MODE_MPEG:
 139         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_MPEG);
 140         def.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
 141         break;
 142     case MODE_MPEGL1:
 143         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
 144         def.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
 145         break;
 146     case MODE_MPEGL2:
 147         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 148         def.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
 149         break;
 150     case MODE_AAC:
 151         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_AAC);
 152         def.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
 153         break;
 154     case MODE_AC3:
 155         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_AC3);
 156         // TODO
 157         //def.format.audio.eEncoding = OMX_AUDIO_CodingAC3;
 158         def.format.audio.eEncoding = OMX_AUDIO_CodingAutoDetect; // right?? orz
 159         break;
 160     case MODE_WMA:
 161         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_WMA);
 162         def.format.audio.eEncoding = OMX_AUDIO_CodingWMA;
 163         break;
 164     case MODE_RA:
 165         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_RA);
 166         def.format.audio.eEncoding = OMX_AUDIO_CodingRA;
 167         break;
 168     case MODE_APE:
 169         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_APE);
 170         def.format.audio.eEncoding = OMX_AUDIO_CodingAPE;
 171         break;
 172     case MODE_DTS:
 173         def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_DTS);
 174         def.format.audio.eEncoding = OMX_AUDIO_CodingDTS;
 175         break;
 176     default:
 177         CHECK(!"Should not be here. Unsupported mime type and compression format");
 178         break;
 179     }
 180
 181     def.format.audio.pNativeRender = NULL;
 182     def.format.audio.bFlagErrorConcealment = OMX_FALSE;
 183
 184     addPort(def);
 185
 186     def.nPortIndex = 1;
 187     def.eDir = OMX_DirOutput;
 188     def.nBufferCountMin = kNumBuffers;
 189     def.nBufferCountActual = def.nBufferCountMin;
 190     def.nBufferSize = kOutputBufferSize;
 191     def.bEnabled = OMX_TRUE;
 192     def.bPopulated = OMX_FALSE;
 193     def.eDomain = OMX_PortDomainAudio;
 194     def.bBuffersContiguous = OMX_FALSE;
 195     def.nBufferAlignment = 2;
 196
 197     def.format.audio.cMIMEType = const_cast<char *>("audio/raw");
 198     def.format.audio.pNativeRender = NULL;
 199     def.format.audio.bFlagErrorConcealment = OMX_FALSE;
 200     def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
 201
 202     addPort(def);
 203 }
 204
 205 void SoftFFmpegAudio::setAVCtxToDefault(AVCodecContext *avctx, const AVCodec *codec) {
 206     int fast = 0;
 207
 208     avctx->workaround_bugs   = 1;
 209     avctx->lowres            = 0;
 210     if(avctx->lowres > codec->max_lowres){
 211         LOGW("The maximum value for lowres supported by the decoder is %d",
 212                 codec->max_lowres);
 213         avctx->lowres= codec->max_lowres;
 214     }
 215     avctx->idct_algo         = 0;
 216     avctx->skip_frame        = AVDISCARD_DEFAULT;
 217     avctx->skip_idct         = AVDISCARD_DEFAULT;
 218     avctx->skip_loop_filter  = AVDISCARD_DEFAULT;
 219     avctx->error_concealment = 3;
 220
 221     if(avctx->lowres) avctx->flags |= CODEC_FLAG_EMU_EDGE;
 222     if (fast)   avctx->flags2 |= CODEC_FLAG2_FAST;
 223     if(codec->capabilities & CODEC_CAP_DR1)
 224         avctx->flags |= CODEC_FLAG_EMU_EDGE;
 225 }
 226
 227 status_t SoftFFmpegAudio::initDecoder() {
 228     status_t status;
 229
 230     status = initFFmpeg();
 231     if (status != OK)
 232         return NO_INIT;
 233
 234     mCtx = avcodec_alloc_context3(NULL);
 235     if (!mCtx)
 236     {
 237         LOGE("avcodec_alloc_context failed.");
 238         return NO_MEMORY;
 239     }
 240
 241     mCtx->codec_type = AVMEDIA_TYPE_AUDIO;
 242     switch (mMode) {
 243     case MODE_MPEG:
 244         mCtx->codec_id = CODEC_ID_MP3;
 245         break;
 246     case MODE_MPEGL1:
 247         mCtx->codec_id = CODEC_ID_MP1;
 248         break;
 249     case MODE_MPEGL2:
 250         mCtx->codec_id = CODEC_ID_MP2;
 251         break;
 252     case MODE_AAC:
 253         mCtx->codec_id = CODEC_ID_AAC;
 254         break;
 255     case MODE_AC3:
 256         mCtx->codec_id = CODEC_ID_AC3;
 257         break;
 258     case MODE_WMA:
 259         mCtx->codec_id = CODEC_ID_WMAV2; // FIXME, CODEC_ID_WMAV1 or CODEC_ID_WMAV2?
 260         break;
 261     case MODE_RA:
 262         mCtx->codec_id = CODEC_ID_COOK; // FIXME
 263         break;
 264     case MODE_APE:
 265         mCtx->codec_id = CODEC_ID_APE;
 266     case MODE_DTS:
 267         mCtx->codec_id = CODEC_ID_DTS;
 268         break;
 269     default:
 270         CHECK(!"Should not be here. Unsupported codec");
 271         break;
 272     }
 273
 274     mCtx->codec = avcodec_find_decoder(mCtx->codec_id);
 275     if (!mCtx->codec)
 276     {
 277         LOGE("find codec failed");
 278         return BAD_TYPE;
 279     }
 280
 281     setAVCtxToDefault(mCtx, mCtx->codec);
 282
 283     mCtx->channels = mNumChannels;
 284     mCtx->sample_rate = mSamplingRate;
 285     mCtx->bit_rate = mBitRate;
 286     mCtx->sample_fmt = mSamplingFmt;
 287
 288     mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 289     mAudioSrcFreq = mAudioTgtFreq = mSamplingRate;
 290     mAudioSrcChannels = mAudioTgtChannels = mNumChannels;
 291     mAudioSrcChannelLayout = mAudioTgtChannelLayout =
 292         av_get_default_channel_layout(mNumChannels);
 293
 294     memset(mSilenceBuffer, 0, kOutputBufferSize);
 295
 296     return OK;
 297 }
 298
 299 void SoftFFmpegAudio::deInitDecoder() {
 300     if (mCtx) {
 301         //avcodec_flush_buffers(mCtx); // is it necessary? crash sometimes if call it
 302         if (!mCtx->extradata) {
 303             av_free(mCtx->extradata);
 304             mCtx->extradata = NULL;
 305             mCtx->extradata_size = 0;
 306         }
 307         avcodec_close(mCtx);
 308         av_free(mCtx);
 309         mCtx = NULL;
 310     }
 311
 312     if (mSwrCtx) {
 313         swr_free(&mSwrCtx);
 314         mSwrCtx = NULL;
 315     }
 316
 317 }
 318
 319 OMX_ERRORTYPE SoftFFmpegAudio::internalGetParameter(
 320         OMX_INDEXTYPE index, OMX_PTR params) {
 321     int32_t channels = 0;
 322     int32_t sampling_rate = 0;
 323
 324     switch (index) {
 325         case OMX_IndexParamAudioAac:
 326         {
 327             OMX_AUDIO_PARAM_AACPROFILETYPE *aacParams =
 328                 (OMX_AUDIO_PARAM_AACPROFILETYPE *)params;
 329
 330             if (aacParams->nPortIndex != 0) {
 331                 return OMX_ErrorUndefined;
 332             }
 333
 334             aacParams->nBitRate = 0;
 335             aacParams->nAudioBandWidth = 0;
 336             aacParams->nAACtools = 0;
 337             aacParams->nAACERtools = 0;
 338             aacParams->eAACProfile = OMX_AUDIO_AACObjectMain;
 339             aacParams->eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4FF;
 340             aacParams->eChannelMode = OMX_AUDIO_ChannelModeStereo;
 341
 342             aacParams->nChannels = mNumChannels;
 343             aacParams->nSampleRate = mSamplingRate;
 344
 345             return OMX_ErrorNone;
 346         }
 347         case OMX_IndexParamAudioWma:
 348         {
 349             OMX_AUDIO_PARAM_WMATYPE *wmaParams =
 350                 (OMX_AUDIO_PARAM_WMATYPE *)params;
 351
 352             if (wmaParams->nPortIndex != 0) {
 353                 return OMX_ErrorUndefined;
 354             }
 355
 356             wmaParams->nChannels = 0;
 357             wmaParams->nSamplingRate = 0;
 358             wmaParams->nBitRate = 0;
 359             wmaParams->eFormat = OMX_AUDIO_WMAFormatUnused;
 360
 361             return OMX_ErrorNone;
 362         }
 363         case OMX_IndexParamAudioRa:
 364         {
 365             OMX_AUDIO_PARAM_RATYPE *raParams =
 366                 (OMX_AUDIO_PARAM_RATYPE *)params;
 367
 368             if (raParams->nPortIndex != 0) {
 369                 return OMX_ErrorUndefined;
 370             }
 371
 372             raParams->nChannels = 0;
 373             raParams->nSamplingRate = 0;
 374             raParams->eFormat = OMX_AUDIO_RAFormatUnused;
 375
 376             return OMX_ErrorNone;
 377         }
 378         case OMX_IndexParamAudioApe:
 379         {
 380             OMX_AUDIO_PARAM_APETYPE *apeParams =
 381                 (OMX_AUDIO_PARAM_APETYPE *)params;
 382
 383             if (apeParams->nPortIndex != 0) {
 384                 return OMX_ErrorUndefined;
 385             }
 386
 387             apeParams->nChannels = 0;
 388             apeParams->nSamplingRate = 0;
 389
 390             return OMX_ErrorNone;
 391         }
 392         case OMX_IndexParamAudioDts:
 393         {
 394             OMX_AUDIO_PARAM_DTSTYPE *dtsParams =
 395                 (OMX_AUDIO_PARAM_DTSTYPE *)params;
 396
 397             if (dtsParams->nPortIndex != 0) {
 398                 return OMX_ErrorUndefined;
 399             }
 400
 401             dtsParams->nChannels = 0;
 402             dtsParams->nSamplingRate = 0;
 403
 404             return OMX_ErrorNone;
 405         }
 406         case OMX_IndexParamAudioPcm:
 407         {
 408             OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams =
 409                 (OMX_AUDIO_PARAM_PCMMODETYPE *)params;
 410
 411             if (pcmParams->nPortIndex > 1) {
 412                 return OMX_ErrorUndefined;
 413             }
 414
 415             pcmParams->eNumData = OMX_NumericalDataSigned;
 416             pcmParams->eEndian = OMX_EndianBig;
 417             pcmParams->bInterleaved = OMX_TRUE;
 418             pcmParams->nBitPerSample = 16;
 419             pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear;
 420             pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF;
 421             pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF;
 422
 423             LOGV("audio config change");
 424
 425             channels = mNumChannels >= 2 ? 2 : 1;
 426             sampling_rate = mSamplingRate;
 427             // 4000 <= nSamplingRate <= 48000
 428             if (mSamplingRate < 4000) {
 429                 sampling_rate = 4000;
 430             } else if (mSamplingRate > 48000) {
 431                 sampling_rate = 48000;
 432             }
 433
 434             // update src and target(except aac), only once!
 435             mAudioSrcChannels = mAudioTgtChannels =  channels;
 436             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 437             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 438             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 439
 440             pcmParams->nChannels = channels;
 441             pcmParams->nSamplingRate = sampling_rate;
 442
 443             return OMX_ErrorNone;
 444         }
 445
 446         default:
 447             return SimpleSoftOMXComponent::internalGetParameter(index, params);
 448     }
 449 }
 450
 451 OMX_ERRORTYPE SoftFFmpegAudio::internalSetParameter(
 452         OMX_INDEXTYPE index, const OMX_PTR params) {
 453     int32_t channels = 0;
 454     int32_t sampling_rate = 0;
 455
 456     switch (index) {
 457         case OMX_IndexParamStandardComponentRole:
 458         {
 459             const OMX_PARAM_COMPONENTROLETYPE *roleParams =
 460                 (const OMX_PARAM_COMPONENTROLETYPE *)params;
 461
 462             bool supported = true;
 463             switch (mMode) {
 464             case MODE_MPEG:
 465                 if (strncmp((const char *)roleParams->cRole,
 466                         "audio_decoder.mp3", OMX_MAX_STRINGNAME_SIZE - 1))
 467                     supported =  false;
 468                 break;
 469             case MODE_MPEGL1:
 470                 if (strncmp((const char *)roleParams->cRole,
 471                         "audio_decoder.mp1", OMX_MAX_STRINGNAME_SIZE - 1))
 472                     supported =  false;
 473                 break;
 474             case MODE_MPEGL2:
 475                 if (strncmp((const char *)roleParams->cRole,
 476                         "audio_decoder.mp2", OMX_MAX_STRINGNAME_SIZE - 1))
 477                     supported =  false;
 478                 break;
 479             case MODE_AAC:
 480                 if (strncmp((const char *)roleParams->cRole,
 481                         "audio_decoder.aac", OMX_MAX_STRINGNAME_SIZE - 1))
 482                     supported =  false;
 483                 break;
 484             case MODE_AC3:
 485                 if (strncmp((const char *)roleParams->cRole,
 486                         "audio_decoder.ac3", OMX_MAX_STRINGNAME_SIZE - 1))
 487                     supported =  false;
 488                 break;
 489             case MODE_WMA:
 490                 if (strncmp((const char *)roleParams->cRole,
 491                         "audio_decoder.wma", OMX_MAX_STRINGNAME_SIZE - 1))
 492                     supported =  false;
 493                 break;
 494             case MODE_RA:
 495                 if (strncmp((const char *)roleParams->cRole,
 496                         "audio_decoder.ra", OMX_MAX_STRINGNAME_SIZE - 1))
 497                     supported =  false;
 498                 break;
 499             case MODE_APE:
 500                 if (strncmp((const char *)roleParams->cRole,
 501                         "audio_decoder.ape", OMX_MAX_STRINGNAME_SIZE - 1))
 502                     supported =  false;
 503                 break;
 504             case MODE_DTS:
 505                 if (strncmp((const char *)roleParams->cRole,
 506                         "audio_decoder.dts", OMX_MAX_STRINGNAME_SIZE - 1))
 507                     supported =  false;
 508                 break;
 509             default:
 510                 CHECK(!"Should not be here. Unsupported role.");
 511                 break;
 512             }
 513             if (!supported) {
 514                 LOGE("unsupported role: %s", (const char *)roleParams->cRole);
 515                 return OMX_ErrorUndefined;
 516             }
 517
 518             return OMX_ErrorNone;
 519         }
 520         case OMX_IndexParamAudioAac:
 521         {
 522             const OMX_AUDIO_PARAM_AACPROFILETYPE *aacParams =
 523                 (const OMX_AUDIO_PARAM_AACPROFILETYPE *)params;
 524
 525             if (aacParams->nPortIndex != 0) {
 526                 return OMX_ErrorUndefined;
 527             }
 528
 529             mNumChannels = aacParams->nChannels;
 530             mSamplingRate = aacParams->nSampleRate;
 531
 532             channels = mNumChannels >= 2 ? 2 : 1;
 533             sampling_rate = mSamplingRate;
 534             // 4000 <= nSamplingRate <= 48000
 535             if (mSamplingRate < 4000) {
 536                 sampling_rate = 4000;
 537             } else if (mSamplingRate > 48000) {
 538                 sampling_rate = 48000;
 539             }
 540
 541             // update src and target(only aac), only once!
 542             mAudioSrcChannels = mAudioTgtChannels = channels;
 543             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 544             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 545             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 546
 547             LOGV("got OMX_IndexParamAudioAac, mNumChannels: %d, mSamplingRate: %d",
 548                 mNumChannels, mSamplingRate);
 549
 550             return OMX_ErrorNone;
 551         }
 552         case OMX_IndexParamAudioWma:
 553         {
 554             OMX_AUDIO_PARAM_WMATYPE *wmaParams =
 555                 (OMX_AUDIO_PARAM_WMATYPE *)params;
 556
 557             if (wmaParams->nPortIndex != 0) {
 558                 return OMX_ErrorUndefined;
 559             }
 560
 561             if (wmaParams->eFormat == OMX_AUDIO_WMAFormat7) {
 562                mCtx->codec_id = CODEC_ID_WMAV2;
 563             } else if (wmaParams->eFormat == OMX_AUDIO_WMAFormat8) {
 564                mCtx->codec_id = CODEC_ID_WMAPRO;
 565             } else if (wmaParams->eFormat == OMX_AUDIO_WMAFormat9) {
 566                mCtx->codec_id = CODEC_ID_WMALOSSLESS;
 567             } else {
 568                 LOGE("unsupported wma codec: 0x%x", wmaParams->eFormat);
 569                 return OMX_ErrorUndefined;
 570             }
 571
 572             mNumChannels = wmaParams->nChannels;
 573             mSamplingRate = wmaParams->nSamplingRate;
 574             mBitRate = wmaParams->nBitRate;
 575
 576             // wma need bitrate
 577             mCtx->bit_rate = mBitRate;
 578
 579             channels = mNumChannels >= 2 ? 2 : 1;
 580             sampling_rate = mSamplingRate;
 581             // 4000 <= nSamplingRate <= 48000
 582             if (mSamplingRate < 4000) {
 583                 sampling_rate = 4000;
 584             } else if (mSamplingRate > 48000) {
 585                 sampling_rate = 48000;
 586             }
 587
 588             // update src and target(only wma), only once!
 589             mAudioSrcChannels = mAudioTgtChannels = channels;
 590             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 591             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 592             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 593
 594             LOGV("got OMX_IndexParamAudioWma, mNumChannels: %d, mSamplingRate: %d, mBitRate: %d",
 595                 mNumChannels, mSamplingRate, mBitRate);
 596
 597             return OMX_ErrorNone;
 598         }
 599         case OMX_IndexParamAudioRa:
 600         {
 601             OMX_AUDIO_PARAM_RATYPE *raParams =
 602                 (OMX_AUDIO_PARAM_RATYPE *)params;
 603
 604             if (raParams->nPortIndex != 0) {
 605                 return OMX_ErrorUndefined;
 606             }
 607
 608             mCtx->codec_id = CODEC_ID_COOK;
 609
 610             mNumChannels = raParams->nChannels;
 611             mSamplingRate = raParams->nSamplingRate;
 612             // FIXME, HACK!!!, I use the nNumRegions parameter pass blockAlign!!!
 613             // the cook audio codec need blockAlign!
 614             mBlockAlign = raParams->nNumRegions;
 615
 616             // cook decoder need block_align
 617             mCtx->block_align = mBlockAlign;
 618
 619             channels = mNumChannels >= 2 ? 2 : 1;
 620             sampling_rate = mSamplingRate;
 621             // 4000 <= nSamplingRate <= 48000
 622             if (mSamplingRate < 4000) {
 623                 sampling_rate = 4000;
 624             } else if (mSamplingRate > 48000) {
 625                 sampling_rate = 48000;
 626             }
 627
 628             // update src and target(only wma), only once!
 629             mAudioSrcChannels = mAudioTgtChannels = channels;
 630             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 631             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 632             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 633
 634             LOGV("got OMX_IndexParamAudioRa, mNumChannels: %d, mSamplingRate: %d, mBlockAlign: %d",
 635                 mNumChannels, mSamplingRate, mBlockAlign);
 636
 637             return OMX_ErrorNone;
 638         }
 639         case OMX_IndexParamAudioApe:
 640         {
 641             OMX_AUDIO_PARAM_APETYPE *apeParams =
 642                 (OMX_AUDIO_PARAM_APETYPE *)params;
 643
 644             if (apeParams->nPortIndex != 0) {
 645                 return OMX_ErrorUndefined;
 646             }
 647
 648             mCtx->codec_id = CODEC_ID_APE;
 649
 650             mNumChannels = apeParams->nChannels;
 651             mSamplingRate = apeParams->nSamplingRate;
 652
 653             // ape decoder need bits_per_coded_sample
 654             mCtx->bits_per_coded_sample = apeParams->nBitsPerSample;
 655
 656             channels = mNumChannels >= 2 ? 2 : 1;
 657             sampling_rate = mSamplingRate;
 658             // 4000 <= nSamplingRate <= 48000
 659             if (mSamplingRate < 4000) {
 660                 sampling_rate = 4000;
 661             } else if (mSamplingRate > 48000) {
 662                 sampling_rate = 48000;
 663             }
 664
 665             // update src and target, only once!
 666             mAudioSrcChannels = mAudioTgtChannels = channels;
 667             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 668             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 669             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 670
 671             LOGV("got OMX_IndexParamAudioApe, mNumChannels: %d, mSamplingRate: %d, nBitsPerSample: %d",
 672                 mNumChannels, mSamplingRate, apeParams->nBitsPerSample);
 673
 674             return OMX_ErrorNone;
 675         }
 676         case OMX_IndexParamAudioDts:
 677         {
 678             OMX_AUDIO_PARAM_DTSTYPE *dtsParams =
 679                 (OMX_AUDIO_PARAM_DTSTYPE *)params;
 680
 681             if (dtsParams->nPortIndex != 0) {
 682                 return OMX_ErrorUndefined;
 683             }
 684
 685             mCtx->codec_id = CODEC_ID_DTS;
 686
 687             mNumChannels = dtsParams->nChannels;
 688             mSamplingRate = dtsParams->nSamplingRate;
 689
 690             channels = mNumChannels >= 2 ? 2 : 1;
 691             sampling_rate = mSamplingRate;
 692             // 4000 <= nSamplingRate <= 48000
 693             if (mSamplingRate < 4000) {
 694                 sampling_rate = 4000;
 695             } else if (mSamplingRate > 48000) {
 696                 sampling_rate = 48000;
 697             }
 698
 699             // update src and target, only once!
 700             mAudioSrcChannels = mAudioTgtChannels = channels;
 701             mAudioSrcFreq = mAudioTgtFreq = sampling_rate;
 702             mAudioSrcFmt = mAudioTgtFmt = AV_SAMPLE_FMT_S16;
 703             mAudioSrcChannelLayout = mAudioTgtChannelLayout = av_get_default_channel_layout(channels);
 704
 705             LOGV("got OMX_IndexParamAudioDts, mNumChannels: %d, mSamplingRate: %d",
 706                 mNumChannels, mSamplingRate);
 707
 708             return OMX_ErrorNone;
 709         }
 710         default:
 711             LOGI("internalSetParameter, index: 0x%x", index);
 712             return SimpleSoftOMXComponent::internalSetParameter(index, params);
 713     }
 714 }
 715
 716 void SoftFFmpegAudio::onQueueFilled(OMX_U32 portIndex) {
 717     int len = 0;
 718     int err = 0;
 719     size_t dataSize = 0;
 720     int64_t decChannelLayout;
 721     int32_t inputBufferUsedLength = 0;
 722     BufferInfo *inInfo = NULL;
 723     OMX_BUFFERHEADERTYPE *inHeader = NULL;
 724
 725     if (mSignalledError || mOutputPortSettingsChange != NONE) {
 726         return;
 727     }
 728
 729     List<BufferInfo *> &inQueue = getPortQueue(0);
 730     List<BufferInfo *> &outQueue = getPortQueue(1);
 731
 732     while ((!inQueue.empty() || mInputBufferSize > 0 ||
 733             mAudioBufferSize > 0 || mFlushComplete) && !outQueue.empty()) {
 734         if (!inQueue.empty() || mInputBufferSize > 0) {
 735             inInfo = *inQueue.begin();
 736             inHeader = inInfo->mHeader;
 737         } else {
 738             inInfo = NULL;
 739             inHeader = NULL;
 740         }
 741
 742         BufferInfo *outInfo = *outQueue.begin();
 743         OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
 744
 745         if (inHeader && inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
 746             inQueue.erase(inQueue.begin());
 747             inInfo->mOwnedByUs = false;
 748             notifyEmptyBufferDone(inHeader);
 749             mReceivedEOS = true;
 750         }
 751
 752         if (mReceivedEOS && (mFlushComplete || !(mCtx->codec->capabilities & CODEC_CAP_DELAY))) {
 753             outHeader->nFilledLen = 0;
 754             outHeader->nFlags = OMX_BUFFERFLAG_EOS;
 755
 756             outQueue.erase(outQueue.begin());
 757             outInfo->mOwnedByUs = false;
 758             notifyFillBufferDone(outHeader);
 759             return;
 760         }
 761
 762         if (inHeader && inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
 763             LOGI("got extradata, ignore: %d, size: %lu", mIgnoreExtradata, inHeader->nFilledLen);
 764             hexdump(inHeader->pBuffer + inHeader->nOffset, inHeader->nFilledLen);
 765             if (!mExtradataReady && !mIgnoreExtradata) {
 766                 int orig_extradata_size = mCtx->extradata_size;
 767                 mCtx->extradata_size += inHeader->nFilledLen;
 768                 mCtx->extradata = (uint8_t *)av_realloc(mCtx->extradata,
 769                         mCtx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 770                 if (!mCtx->extradata) {
 771                     LOGE("ffmpeg audio decoder failed to alloc extradata memory.");
 772                     notify(OMX_EventError, OMX_ErrorInsufficientResources, 0, NULL);
 773                     mSignalledError = true;
 774                     return;
 775                 }
 776
 777                 memcpy(mCtx->extradata + orig_extradata_size,
 778                         inHeader->pBuffer + inHeader->nOffset, inHeader->nFilledLen);
 779                 memset(mCtx->extradata + mCtx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 780
 781                 inInfo->mOwnedByUs = false;
 782                 inQueue.erase(inQueue.begin());
 783                 inInfo = NULL;
 784                 notifyEmptyBufferDone(inHeader);
 785                 inHeader = NULL;
 786
 787                 continue;
 788             }
 789             if (mIgnoreExtradata) {
 790                 LOGI("got extradata, size: %lu, but ignore it", inHeader->nFilledLen);
 791                 inInfo->mOwnedByUs = false;
 792                 inQueue.erase(inQueue.begin());
 793                 inInfo = NULL;
 794                 notifyEmptyBufferDone(inHeader);
 795                 inHeader = NULL;
 796
 797                 continue;
 798             }
 799         }
 800
 801         if (!mCodecOpened) {
 802             if (!mExtradataReady && !mIgnoreExtradata) {
 803                 LOGI("extradata is ready");
 804                 hexdump(mCtx->extradata, mCtx->extradata_size);
 805                 mExtradataReady = true;
 806             }
 807
 808             // find decoder again as codec_id may have changed
 809             mCtx->codec = avcodec_find_decoder(mCtx->codec_id);
 810             if (!mCtx->codec) {
 811                 LOGE("ffmpeg audio decoder failed to find codec");
 812                 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
 813                 mSignalledError = true;
 814                 return;
 815             }
 816
 817             setAVCtxToDefault(mCtx, mCtx->codec);
 818
 819             LOGI("open ffmpeg decoder now");
 820             err = avcodec_open2(mCtx, mCtx->codec, NULL);
 821             if (err < 0) {
 822                 print_error("avcodec_open2", err);
 823                 LOGE("ffmpeg audio decoder failed to initialize. (%d)", err);
 824                 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
 825                 mSignalledError = true;
 826                 return;
 827             }
 828             mCodecOpened = true;
 829             LOGI("open ffmpeg audio decoder, mCtx sample_rate: %d, channels: %d, channel_layout: %llu, sample_fmt: %s",
 830                 mCtx->sample_rate, mCtx->channels, mCtx->channel_layout, av_get_sample_fmt_name(mCtx->sample_fmt));
 831         }
 832
 833         /* update the audio clock with the pts */
 834         if (inHeader && inHeader->nOffset == 0) {
 835             mAnchorTimeUs = inHeader->nTimeStamp;
 836             mInputBufferSize = inHeader->nFilledLen;
 837         }
 838
 839         if (inHeader && mAudioBufferSize == 0 && !mFlushComplete) {
 840             AVPacket pkt;
 841             memset(&pkt, 0, sizeof(pkt));
 842             av_init_packet(&pkt);
 843             if (!mFlushComplete) {
 844                 pkt.data = (uint8_t *)inHeader->pBuffer + inHeader->nOffset;
 845                 pkt.size = inHeader->nFilledLen;
 846                 pkt.pts = inHeader->nTimeStamp; // ingore it, we will compute it
 847             } else {
 848                 pkt.data = NULL;
 849                 pkt.size = 0;
 850                 pkt.pts = AV_NOPTS_VALUE;
 851             }
 852 #if DEBUG_PKT
 853             LOGV("pkt size: %d, pts: %lld", pkt.size, pkt.pts);
 854 #endif
 855             if (!mFrame) {
 856                 if (!(mFrame = avcodec_alloc_frame())) {
 857                     LOGE("ffmpeg audio decoder failed to alloc memory.");
 858                     notify(OMX_EventError, OMX_ErrorInsufficientResources, 0, NULL);
 859                     mSignalledError = true;
 860                     return;
 861                 }
 862             } else {
 863                 avcodec_get_frame_defaults(mFrame);
 864             }
 865
 866             int gotFrm = false;
 867             inputBufferUsedLength = 0;
 868             len = avcodec_decode_audio4(mCtx, mFrame, &gotFrm, &pkt);
 869             if (len < 0) {
 870                 LOGE("ffmpeg audio decoder failed to decode frame. consume pkt len: %d", len);
 871
 872                 /* if !mAudioConfigChanged, Don't fill the out buffer */
 873                 if (!mAudioConfigChanged) {
 874                     inInfo->mOwnedByUs = false;
 875                     inQueue.erase(inQueue.begin());
 876                     inInfo = NULL;
 877                     notifyEmptyBufferDone(inHeader);
 878                     inHeader = NULL;
 879
 880                     mInputBufferSize = 0; // need?
 881                     continue;
 882                 }
 883
 884                 //inputBufferUsedLength = inHeader->nFilledLen;
 885                 /* if error, we skip the frame and play silence instead */
 886                 mPAudioBuffer = mSilenceBuffer;
 887                 mAudioBufferSize = kOutputBufferSize;
 888             }
 889
 890 #if DEBUG_PKT
 891             LOGV("ffmpeg audio decoder, consume pkt len: %d", len);
 892 #endif
 893
 894             if (len < 0)
 895                 inputBufferUsedLength = inHeader->nFilledLen;
 896             else
 897                 inputBufferUsedLength = len;
 898
 899             CHECK_GE(inHeader->nFilledLen, inputBufferUsedLength);
 900             inHeader->nOffset += inputBufferUsedLength;
 901             inHeader->nFilledLen -= inputBufferUsedLength;
 902             mInputBufferSize -= inputBufferUsedLength;
 903             if (inHeader->nFilledLen == 0) {
 904                 inInfo->mOwnedByUs = false;
 905                 inQueue.erase(inQueue.begin());
 906                 inInfo = NULL;
 907                 notifyEmptyBufferDone(inHeader);
 908                 inHeader = NULL;
 909
 910                 mInputBufferSize = 0;
 911             }
 912
 913             if (!gotFrm) {
 914                 LOGI("ffmpeg audio decoder failed to get frame.");
 915                 /* stop sending empty packets if the decoder is finished */
 916                 if (!pkt.data && mCtx->codec->capabilities & CODEC_CAP_DELAY)
 917                     mFlushComplete = true;
 918                 continue;
 919             }
 920
 921             /**
 922              * FIXME, check mAudioConfigChanged when the first time you call the audio4!
 923              * mCtx->sample_rate and mCtx->channels may be changed by audio decoder later, why???
 924              */
 925             if (!mAudioConfigChanged) {
 926                 //if (mCtx->channels != mNumChannels || mCtx->sample_rate != mSamplingRate || mCtx->sample_fmt != mSamplingFmt) {
 927                 if (mCtx->channels != mNumChannels || mCtx->sample_rate != mSamplingRate) {
 928                     LOGI("audio OMX_EventPortSettingsChanged, mCtx->channels: %d, mNumChannels: %d, mCtx->sample_rate: %d, mSamplingRate: %d, mCtx->sample_fmt: %s, mSamplingFmt: %s",
 929                             mCtx->channels, mNumChannels, mCtx->sample_rate, mSamplingRate,
 930                             av_get_sample_fmt_name(mCtx->sample_fmt), av_get_sample_fmt_name(mSamplingFmt));
 931                     mNumChannels = mCtx->channels;
 932                     mSamplingRate = mCtx->sample_rate;
 933                     mSamplingFmt = mCtx->sample_fmt;
 934                     mAudioConfigChanged = true;
 935                     notify(OMX_EventPortSettingsChanged, 1, 0, NULL);
 936                     mOutputPortSettingsChange = AWAITING_DISABLED;
 937                     return;
 938                 } else {
 939                     // match with the default, set mAudioConfigChanged true anyway!
 940                     mAudioConfigChanged = true;
 941                     mSamplingFmt = mCtx->sample_fmt;
 942                 }
 943             }
 944
 945             dataSize = av_samples_get_buffer_size(NULL, mNumChannels, mFrame->nb_samples, mSamplingFmt, 1);
 946
 947 #if DEBUG_FRM
 948             LOGV("audio decoder, nb_samples: %d, get buffer size: %d", mFrame->nb_samples, dataSize);
 949             LOGV("audio decoder: mCtx channel_layout: %llu, channels: %d, channels_from_layout: %d\n",
 950                 mCtx->channel_layout,  mCtx->channels, av_get_channel_layout_nb_channels(mCtx->channel_layout));
 951 #endif
 952
 953             decChannelLayout = av_get_default_channel_layout(mNumChannels);
 954             if (mSamplingFmt != mAudioSrcFmt ||
 955                     decChannelLayout != mAudioSrcChannelLayout ||
 956                     mSamplingRate != mAudioSrcFreq ) {
 957                 if (mSwrCtx)
 958                     swr_free(&mSwrCtx);
 959                 mSwrCtx = swr_alloc_set_opts(NULL,
 960                                              mAudioTgtChannelLayout, mAudioTgtFmt, mAudioTgtFreq,
 961                                              decChannelLayout,       mSamplingFmt, mSamplingRate,
 962                                              0, NULL);
 963                 if (!mSwrCtx || swr_init(mSwrCtx) < 0) {
 964                     LOGE("Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!",
 965                             mSamplingRate,
 966                             av_get_sample_fmt_name(mSamplingFmt),
 967                             mNumChannels,
 968                             mAudioTgtFreq,
 969                             av_get_sample_fmt_name(mAudioTgtFmt),
 970                             mAudioTgtChannels);
 971                     notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
 972                     mSignalledError = true;
 973                     return;
 974                 }
 975
 976                 LOGI("Create sample rate converter for conversion of %d Hz %s %d channels(%lld channel_layout) to %d Hz %s %d channels(%lld channel_layout)!",
 977                         mSamplingRate,
 978                         av_get_sample_fmt_name(mSamplingFmt),
 979                         mNumChannels,
 980                         mAudioTgtChannelLayout,
 981                         mAudioTgtFreq,
 982                         av_get_sample_fmt_name(mAudioTgtFmt),
 983                         mAudioTgtChannels,
 984                         decChannelLayout);
 985
 986                 mAudioSrcChannelLayout = decChannelLayout;
 987                 mAudioSrcChannels = mNumChannels;
 988                 mAudioSrcFreq = mSamplingRate;
 989                 mAudioSrcFmt = mSamplingFmt;
 990             }
 991
 992             if (mSwrCtx) {
 993                 //const uint8_t *in[] = { mFrame->data[0] };
 994                 const uint8_t **in = (const uint8_t **)mFrame->extended_data;
 995                 uint8_t *out[] = {mAudioBuf2};
 996                 int out_count = sizeof(mAudioBuf2) / mAudioTgtChannels / av_get_bytes_per_sample(mAudioTgtFmt);
 997 #if DEBUG_FRM
 998                 LOGV("swr_convert 1, out_count: %d, mFrame->nb_samples: %d, src frm: %s, tgt frm: %s",
 999                     out_count, mFrame->nb_samples, av_get_sample_fmt_name(mCtx->sample_fmt), av_get_sample_fmt_name(mAudioTgtFmt));
1000 #endif
1001                 int len2 = swr_convert(mSwrCtx, out, out_count, in, mFrame->nb_samples);
1002                 if (len2 < 0) {
1003                     LOGE("audio_resample() failed");
1004                     break;
1005                 }
1006                 if (len2 == out_count) {
1007                     LOGE("warning: audio buffer is probably too small");
1008                     swr_init(mSwrCtx);
1009                 }
1010                 mPAudioBuffer = mAudioBuf2;
1011                 mAudioBufferSize = len2 * mAudioTgtChannels * av_get_bytes_per_sample(mAudioTgtFmt);
1012             } else {
1013                 mPAudioBuffer = mFrame->data[0];
1014                 mAudioBufferSize = dataSize;
1015             }
1016
1017 #if DEBUG_FRM
1018             LOGV("ffmpeg audio decoder get frame. consume pkt len: %d, nb_samples(before resample): %d, mAudioBufferSize: %d",
1019                     len, mFrame->nb_samples, mAudioBufferSize);
1020 #endif
1021         } // if (inHeader && mAudioBufferSize == 0 && !mFlushComplete)
1022
1023         size_t copyToOutputBufferLen = mAudioBufferSize;
1024         if (mAudioBufferSize > kOutputBufferSize)
1025             copyToOutputBufferLen = kOutputBufferSize;
1026
1027         outHeader->nOffset = 0;
1028         outHeader->nFilledLen = copyToOutputBufferLen;
1029         outHeader->nTimeStamp = mAnchorTimeUs + (mNumFramesOutput * 1000000ll) / mSamplingRate;
1030         memcpy(outHeader->pBuffer, mPAudioBuffer, copyToOutputBufferLen);
1031         outHeader->nFlags = 0;
1032
1033 #if DEBUG_FRM
1034         LOGV("ffmpeg audio decoder, fill out buffer, pts: %lld, mNumFramesOutput: %lld", outHeader->nTimeStamp, mNumFramesOutput);
1035 #endif
1036
1037         mPAudioBuffer += copyToOutputBufferLen;
1038         mAudioBufferSize -= copyToOutputBufferLen;
1039         mNumFramesOutput += copyToOutputBufferLen / (av_get_bytes_per_sample(mAudioTgtFmt) * mNumChannels);
1040
1041         // reset mNumFramesOutput
1042         if (mAudioBufferSize == 0) {
1043 #if DEBUG_FRM
1044             LOGV("~~~~ mAudioBufferSize, set mNumFramesOutput = 0");
1045 #endif
1046             mNumFramesOutput = 0;
1047         }
1048
1049         outInfo->mOwnedByUs = false;
1050         outQueue.erase(outQueue.begin());
1051         outInfo = NULL;
1052         notifyFillBufferDone(outHeader);
1053         outHeader = NULL;
1054     }
1055 }
1056
1057 void SoftFFmpegAudio::onPortFlushCompleted(OMX_U32 portIndex) {
1058     if (portIndex == 0 && mCtx) {
1059         // Make sure that the next buffer output does not still
1060         // depend on fragments from the last one decoded.
1061         avcodec_flush_buffers(mCtx);
1062     }
1063
1064 }
1065
1066 void SoftFFmpegAudio::onPortEnableCompleted(OMX_U32 portIndex, bool enabled) {
1067     if (portIndex != 1) {
1068         return;
1069     }
1070
1071     switch (mOutputPortSettingsChange) {
1072         case NONE:
1073             break;
1074
1075         case AWAITING_DISABLED:
1076         {
1077             CHECK(!enabled);
1078             mOutputPortSettingsChange = AWAITING_ENABLED;
1079             break;
1080         }
1081
1082         default:
1083         {
1084             CHECK_EQ((int)mOutputPortSettingsChange, (int)AWAITING_ENABLED);
1085             CHECK(enabled);
1086             mOutputPortSettingsChange = NONE;
1087             break;
1088         }
1089     }
1090 }
1091
1092 }  // namespace android
1093
1094 android::SoftOMXComponent *createSoftOMXComponent(
1095         const char *name, const OMX_CALLBACKTYPE *callbacks,
1096         OMX_PTR appData, OMX_COMPONENTTYPE **component) {
1097     return new android::SoftFFmpegAudio(name, callbacks, appData, component);
1098 }