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