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