libstagefright/FFmpegExtractor/FFmpegExtractor.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 "FFmpegExtractor"
  19 #include <utils/Log.h>
  20
  21 #include <stdint.h>
  22 #include <limits.h> /* INT_MAX */
  23 #include <inttypes.h>
  24
  25 #include <media/stagefright/foundation/ABitReader.h>
  26 #include <media/stagefright/foundation/ABuffer.h>
  27 #include <media/stagefright/foundation/ADebug.h>
  28 #include <media/stagefright/foundation/AMessage.h>
  29 #include <media/stagefright/foundation/hexdump.h>
  30 #include <media/stagefright/DataSource.h>
  31 #include <media/stagefright/MediaBuffer.h>
  32 #include <media/stagefright/foundation/ADebug.h>
  33 #include <media/stagefright/MediaDefs.h>
  34 #include <media/stagefright/MediaErrors.h>
  35 #include <media/stagefright/MediaSource.h>
  36 #include <media/stagefright/MetaData.h>
  37 #include <media/stagefright/Utils.h>
  38 #include <cutils/properties.h>
  39 #include <utils/String8.h>
  40 #include <utils/misc.h>
  41
  42 #include "include/avc_utils.h"
  43 #include "utils/ffmpeg_utils.h"
  44 #include "utils/ffmpeg_cmdutils.h"
  45 #include "FFmpegExtractor.h"
  46
  47 #define MAX_QUEUE_SIZE (15 * 1024 * 1024)
  48 #define MIN_AUDIOQ_SIZE (20 * 16 * 1024)
  49 #define MIN_FRAMES 5
  50 #define EXTRACTOR_MAX_PROBE_PACKETS 200
  51 #define FF_MAX_EXTRADATA_SIZE ((1 << 28) - FF_INPUT_BUFFER_PADDING_SIZE)
  52
  53 //debug
  54 #define DEBUG_READ_ENTRY           0
  55 #define DEBUG_DISABLE_VIDEO        0
  56 #define DEBUG_DISABLE_AUDIO        0
  57 #define WAIT_KEY_PACKET_AFTER_SEEK 1
  58 #define DISABLE_NAL_TO_ANNEXB      0
  59 #define DEBUG_PKT                  0
  60
  61 enum {
  62     NO_SEEK = 0,
  63     SEEK,
  64 };
  65
  66 static AVPacket flush_pkt;
  67
  68 namespace android {
  69
  70 static const char *findMatchingContainer(const char *name);
  71
  72 struct FFmpegExtractor::Track : public MediaSource {
  73     Track(FFmpegExtractor *extractor, sp<MetaData> meta, bool isAVC,
  74           AVStream *stream, PacketQueue *queue);
  75
  76     virtual status_t start(MetaData *params);
  77     virtual status_t stop();
  78     virtual sp<MetaData> getFormat();
  79
  80     virtual status_t read(
  81             MediaBuffer **buffer, const ReadOptions *options);
  82
  83 protected:
  84     virtual ~Track();
  85
  86 private:
  87     friend struct FFmpegExtractor;
  88
  89     FFmpegExtractor *mExtractor;
  90     sp<MetaData> mMeta;
  91
  92     enum AVMediaType mMediaType;
  93
  94     mutable Mutex mLock;
  95
  96     bool mIsAVC;
  97     size_t mNALLengthSize;
  98     bool mNal2AnnexB;
  99
 100     AVStream *mStream;
 101     PacketQueue *mQueue;
 102
 103     int64_t mFirstKeyPktTimestamp;
 104
 105     DISALLOW_EVIL_CONSTRUCTORS(Track);
 106 };
 107
 108 ////////////////////////////////////////////////////////////////////////////////
 109
 110 FFmpegExtractor::FFmpegExtractor(const sp<DataSource> &source)
 111     : mDataSource(source),
 112       mMeta(new MetaData),
 113       mInitCheck(NO_INIT),
 114       mFFmpegInited(false),
 115       mFormatCtx(NULL),
 116       mReaderThreadStarted(false) {
 117     ALOGV("FFmpegExtractor::FFmpegExtractor");
 118
 119     buildFileName(source);
 120
 121     int err = initStreams();
 122     if (err < 0) {
 123         ALOGE("failed to init ffmpeg");
 124         return;
 125     }
 126
 127     // start reader here, as we want to extract extradata from bitstream if no extradata
 128     startReaderThread();
 129
 130     while(mProbePkts <= EXTRACTOR_MAX_PROBE_PACKETS && !mEOF &&
 131         (mFormatCtx->pb ? !mFormatCtx->pb->error : 1) &&
 132         (mDefersToCreateVideoTrack || mDefersToCreateAudioTrack)) {
 133         // FIXME, i am so lazy! Should use pthread_cond_wait to wait conditions
 134         usleep(5000);
 135     }
 136
 137     ALOGV("mProbePkts: %d, mEOF: %d, pb->error(if has): %d, mDefersToCreateVideoTrack: %d, mDefersToCreateAudioTrack: %d",
 138         mProbePkts, mEOF, mFormatCtx->pb ? mFormatCtx->pb->error : 0, mDefersToCreateVideoTrack, mDefersToCreateAudioTrack);
 139
 140     mInitCheck = OK;
 141 }
 142
 143 FFmpegExtractor::~FFmpegExtractor() {
 144     ALOGV("FFmpegExtractor::~FFmpegExtractor");
 145
 146     // stop reader here if no track!
 147     stopReaderThread();
 148
 149     deInitStreams();
 150 }
 151
 152 size_t FFmpegExtractor::countTracks() {
 153     return mInitCheck == OK ? mTracks.size() : 0;
 154 }
 155
 156 sp<MediaSource> FFmpegExtractor::getTrack(size_t index) {
 157     ALOGV("FFmpegExtractor::getTrack[%d]", index);
 158
 159     if (mInitCheck != OK) {
 160         return NULL;
 161     }
 162
 163     if (index >= mTracks.size()) {
 164         return NULL;
 165     }
 166
 167     return mTracks.valueAt(index);
 168 }
 169
 170 sp<MetaData> FFmpegExtractor::getTrackMetaData(size_t index, uint32_t flags) {
 171     ALOGV("FFmpegExtractor::getTrackMetaData[%d]", index);
 172
 173     if (mInitCheck != OK) {
 174         return NULL;
 175     }
 176
 177     if (index >= mTracks.size()) {
 178         return NULL;
 179     }
 180
 181     return mTracks.valueAt(index)->getFormat();
 182 }
 183
 184 sp<MetaData> FFmpegExtractor::getMetaData() {
 185     ALOGV("FFmpegExtractor::getMetaData");
 186
 187     if (mInitCheck != OK) {
 188         return NULL;
 189     }
 190
 191     return mMeta;
 192 }
 193
 194 uint32_t FFmpegExtractor::flags() const {
 195     ALOGV("FFmpegExtractor::flags");
 196
 197     if (mInitCheck != OK) {
 198         return 0;
 199     }
 200
 201     uint32_t flags = CAN_PAUSE;
 202
 203     if (mFormatCtx->duration != AV_NOPTS_VALUE) {
 204         flags |= CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK;
 205     }
 206
 207     return flags;
 208 }
 209
 210 void FFmpegExtractor::packet_queue_init(PacketQueue *q)
 211 {
 212     memset(q, 0, sizeof(PacketQueue));
 213     pthread_mutex_init(&q->mutex, NULL);
 214     pthread_cond_init(&q->cond, NULL);
 215     packet_queue_put(q, &flush_pkt);
 216 }
 217
 218 void FFmpegExtractor::packet_queue_flush(PacketQueue *q)
 219 {
 220     AVPacketList *pkt, *pkt1;
 221
 222     pthread_mutex_lock(&q->mutex);
 223     for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
 224         pkt1 = pkt->next;
 225         av_free_packet(&pkt->pkt);
 226         av_freep(&pkt);
 227     }
 228     q->last_pkt = NULL;
 229     q->first_pkt = NULL;
 230     q->nb_packets = 0;
 231     q->size = 0;
 232     pthread_mutex_unlock(&q->mutex);
 233 }
 234
 235 void FFmpegExtractor::packet_queue_end(PacketQueue *q)
 236 {
 237     packet_queue_flush(q);
 238 }
 239
 240 void FFmpegExtractor::packet_queue_abort(PacketQueue *q)
 241 {
 242     pthread_mutex_lock(&q->mutex);
 243
 244     q->abort_request = 1;
 245
 246     pthread_cond_signal(&q->cond);
 247
 248     pthread_mutex_unlock(&q->mutex);
 249 }
 250
 251 int FFmpegExtractor::packet_queue_put(PacketQueue *q, AVPacket *pkt)
 252 {
 253     AVPacketList *pkt1;
 254
 255     /* duplicate the packet */
 256     if (pkt != &flush_pkt && av_dup_packet(pkt) < 0)
 257         return -1;
 258
 259     pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));
 260     if (!pkt1)
 261         return -1;
 262     pkt1->pkt = *pkt;
 263     pkt1->next = NULL;
 264
 265     pthread_mutex_lock(&q->mutex);
 266
 267     if (!q->last_pkt)
 268
 269         q->first_pkt = pkt1;
 270     else
 271         q->last_pkt->next = pkt1;
 272     q->last_pkt = pkt1;
 273     q->nb_packets++;
 274     //q->size += pkt1->pkt.size + sizeof(*pkt1);
 275     q->size += pkt1->pkt.size;
 276     pthread_cond_signal(&q->cond);
 277
 278     pthread_mutex_unlock(&q->mutex);
 279     return 0;
 280 }
 281
 282 /* packet queue handling */
 283 /* return < 0 if aborted, 0 if no packet and > 0 if packet.  */
 284 int FFmpegExtractor::packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
 285 {
 286     AVPacketList *pkt1;
 287     int ret;
 288
 289     pthread_mutex_lock(&q->mutex);
 290
 291     for (;;) {
 292         if (q->abort_request) {
 293             ret = -1;
 294             break;
 295         }
 296
 297         pkt1 = q->first_pkt;
 298         if (pkt1) {
 299             q->first_pkt = pkt1->next;
 300             if (!q->first_pkt)
 301                 q->last_pkt = NULL;
 302             q->nb_packets--;
 303             //q->size -= pkt1->pkt.size + sizeof(*pkt1);
 304             q->size -= pkt1->pkt.size;
 305             *pkt = pkt1->pkt;
 306             av_free(pkt1);
 307             ret = 1;
 308             break;
 309         } else if (!block) {
 310             ret = 0;
 311             break;
 312         } else {
 313             pthread_cond_wait(&q->cond, &q->mutex);
 314         }
 315     }
 316     pthread_mutex_unlock(&q->mutex);
 317     return ret;
 318 }
 319
 320 static void EncodeSize14(uint8_t **_ptr, size_t size) {
 321     CHECK_LE(size, 0x3fff);
 322
 323     uint8_t *ptr = *_ptr;
 324
 325     *ptr++ = 0x80 | (size >> 7);
 326     *ptr++ = size & 0x7f;
 327
 328     *_ptr = ptr;
 329 }
 330
 331 static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
 332     sp<ABuffer> esds = new ABuffer(csd->size() + 25);
 333
 334     uint8_t *ptr = esds->data();
 335     *ptr++ = 0x03;
 336     EncodeSize14(&ptr, 22 + csd->size());
 337
 338     *ptr++ = 0x00;  // ES_ID
 339     *ptr++ = 0x00;
 340
 341     *ptr++ = 0x00;  // streamDependenceFlag, URL_Flag, OCRstreamFlag
 342
 343     *ptr++ = 0x04;
 344     EncodeSize14(&ptr, 16 + csd->size());
 345
 346     *ptr++ = 0x40;  // Audio ISO/IEC 14496-3
 347
 348     for (size_t i = 0; i < 12; ++i) {
 349         *ptr++ = 0x00;
 350     }
 351
 352     *ptr++ = 0x05;
 353     EncodeSize14(&ptr, csd->size());
 354
 355     memcpy(ptr, csd->data(), csd->size());
 356
 357     return esds;
 358 }
 359
 360 // Returns the sample rate based on the sampling frequency index
 361 static uint32_t get_sample_rate(const uint8_t sf_index)
 362 {
 363     static const uint32_t sample_rates[] =
 364     {
 365         96000, 88200, 64000, 48000, 44100, 32000,
 366         24000, 22050, 16000, 12000, 11025, 8000
 367     };
 368
 369     if (sf_index < sizeof(sample_rates) / sizeof(sample_rates[0])) {
 370         return sample_rates[sf_index];
 371     }
 372
 373     return 0;
 374 }
 375
 376 int FFmpegExtractor::check_extradata(AVCodecContext *avctx)
 377 {
 378     enum AVCodecID codec_id = CODEC_ID_NONE;
 379     const char *name = NULL;
 380     bool *defersToCreateTrack = NULL;
 381     AVBitStreamFilterContext **bsfc = NULL;
 382
 383     // init
 384     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 385         bsfc = &mVideoBsfc;
 386         defersToCreateTrack = &mDefersToCreateVideoTrack;
 387     } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO){
 388         bsfc = &mAudioBsfc;
 389         defersToCreateTrack = &mDefersToCreateAudioTrack;
 390     }
 391
 392         codec_id = avctx->codec_id;
 393
 394     // ignore extradata
 395     if (codec_id != CODEC_ID_H264
 396             && codec_id != CODEC_ID_MPEG4
 397             && codec_id != CODEC_ID_MPEG1VIDEO
 398             && codec_id != CODEC_ID_MPEG2VIDEO
 399             && codec_id != CODEC_ID_AAC) {
 400         return 1;
 401     }
 402
 403     // is extradata compatible with android?
 404     if (codec_id != CODEC_ID_AAC) {
 405         int is_compatible = is_extradata_compatible_with_android(avctx);
 406         if (!is_compatible) {
 407             ALOGI("%s extradata is not compatible with android, should to extract it from bitstream",
 408                     av_get_media_type_string(avctx->codec_type));
 409             *defersToCreateTrack = true;
 410             *bsfc = NULL; // H264 don't need bsfc, only AAC?
 411             return 0;
 412         }
 413         return 1;
 414     }
 415
 416     if (codec_id == CODEC_ID_AAC) {
 417         name = "aac_adtstoasc";
 418     }
 419
 420     if (avctx->extradata_size <= 0) {
 421         ALOGI("No %s extradata found, should to extract it from bitstream",
 422                 av_get_media_type_string(avctx->codec_type));
 423         *defersToCreateTrack = true;
 424          //CHECK(name != NULL);
 425         if (!*bsfc && name) {
 426             *bsfc = av_bitstream_filter_init(name);
 427             if (!*bsfc) {
 428                 ALOGE("Cannot open the %s BSF!", name);
 429                 *defersToCreateTrack = false;
 430                 return -1;
 431             } else {
 432                 ALOGV("open the %s bsf", name);
 433                 return 0;
 434             }
 435         } else {
 436             return 0;
 437         }
 438     }
 439     return 1;
 440 }
 441
 442 void FFmpegExtractor::printTime(int64_t time)
 443 {
 444     int hours, mins, secs, us;
 445
 446     if (time == AV_NOPTS_VALUE)
 447         return;
 448
 449     secs = time / AV_TIME_BASE;
 450     us = time % AV_TIME_BASE;
 451     mins = secs / 60;
 452     secs %= 60;
 453     hours = mins / 60;
 454     mins %= 60;
 455     ALOGI("the time is %02d:%02d:%02d.%02d",
 456         hours, mins, secs, (100 * us) / AV_TIME_BASE);
 457 }
 458
 459 bool FFmpegExtractor::is_codec_supported(enum AVCodecID codec_id)
 460 {
 461     bool supported = false;
 462
 463     switch(codec_id) {
 464     case CODEC_ID_H264:
 465     case CODEC_ID_MPEG4:
 466     case CODEC_ID_H263:
 467     case CODEC_ID_H263P:
 468     case CODEC_ID_H263I:
 469     case CODEC_ID_AAC:
 470     case CODEC_ID_AC3:
 471     case CODEC_ID_MP1:
 472     case CODEC_ID_MP2:
 473     case CODEC_ID_MP3:
 474     case CODEC_ID_MPEG1VIDEO:
 475     case CODEC_ID_MPEG2VIDEO:
 476     case CODEC_ID_WMV1:
 477     case CODEC_ID_WMV2:
 478     case CODEC_ID_WMV3:
 479     case CODEC_ID_VC1:
 480     case CODEC_ID_WMAV1:
 481     case CODEC_ID_WMAV2:
 482     case CODEC_ID_WMAPRO:
 483     case CODEC_ID_WMALOSSLESS:
 484     case CODEC_ID_RV20:
 485     case CODEC_ID_RV30:
 486     case CODEC_ID_RV40:
 487     case CODEC_ID_COOK:
 488     case CODEC_ID_APE:
 489     case CODEC_ID_DTS:
 490     case CODEC_ID_FLAC:
 491     case CODEC_ID_FLV1:
 492         supported = true;
 493         break;
 494     default:
 495         ALOGD("unsuppoted codec(id:0x%0x), but give it a chance", codec_id);
 496         //Won't promise that the following codec id can be supported.
 497             //Just give these codecs a chance.
 498         supported = true;
 499         break;
 500     }
 501
 502         return supported;
 503 }
 504
 505 int FFmpegExtractor::stream_component_open(int stream_index)
 506 {
 507     AVCodecContext *avctx = NULL;
 508     sp<MetaData> meta = NULL;
 509     bool isAVC = false;
 510     bool supported = false;
 511     uint32_t type = 0;
 512     const void *data = NULL;
 513     size_t size = 0;
 514     int ret = 0;
 515
 516     ALOGI("stream_index: %d", stream_index);
 517     if (stream_index < 0 || stream_index >= (int)mFormatCtx->nb_streams)
 518         return -1;
 519     avctx = mFormatCtx->streams[stream_index]->codec;
 520
 521     supported = is_codec_supported(avctx->codec_id);
 522
 523     if (!supported) {
 524         ALOGE("unsupport the codec, id: 0x%0x", avctx->codec_id);
 525         return -1;
 526     }
 527     ALOGV("support the codec");
 528
 529     unsigned streamType;
 530     ssize_t index = mTracks.indexOfKey(stream_index);
 531
 532     if (index >= 0) {
 533         ALOGE("this track already exists");
 534         return 0;
 535     }
 536
 537     mFormatCtx->streams[stream_index]->discard = AVDISCARD_DEFAULT;
 538
 539     char tagbuf[32];
 540     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), avctx->codec_tag);
 541     ALOGV("Tag %s/0x%08x with codec id '%d'\n", tagbuf, avctx->codec_tag, avctx->codec_id);
 542
 543     switch (avctx->codec_type) {
 544     case AVMEDIA_TYPE_VIDEO:
 545         if (mVideoStreamIdx == -1)
 546             mVideoStreamIdx = stream_index;
 547         if (mVideoStream == NULL)
 548             mVideoStream = mFormatCtx->streams[stream_index];
 549         if (!mVideoQInited) {
 550                 packet_queue_init(&mVideoQ);
 551             mVideoQInited = true;
 552         }
 553
 554         ret = check_extradata(avctx);
 555         if (ret != 1) {
 556             if (ret == -1) {
 557                 // disable the stream
 558                 mVideoStreamIdx = -1;
 559                 mVideoStream = NULL;
 560                 packet_queue_end(&mVideoQ);
 561                 mVideoQInited =  false;
 562                 mFormatCtx->streams[stream_index]->discard = AVDISCARD_ALL;
 563             }
 564             return ret;
 565          }
 566
 567         if (avctx->extradata) {
 568             ALOGV("video stream extradata:");
 569             hexdump(avctx->extradata, avctx->extradata_size);
 570         } else {
 571             ALOGV("video stream no extradata, but we can ignore it.");
 572         }
 573
 574         meta = new MetaData;
 575
 576         switch(avctx->codec_id) {
 577         case CODEC_ID_H264:
 578             /**
 579              * H.264 Video Types
 580              * http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
 581              */
 582             //if (avctx->codec_tag && avctx->codec_tag == AV_RL32("avc1")) {
 583             if (avctx->extradata[0] == 1 /* configurationVersion */) {
 584                 // H.264 bitstream without start codes.
 585                 isAVC = true;
 586                 ALOGV("AVC");
 587
 588                 if (avctx->width == 0 || avctx->height == 0) {
 589                     int32_t width, height;
 590                     sp<ABuffer> seqParamSet = new ABuffer(avctx->extradata_size - 8);
 591                     memcpy(seqParamSet->data(), avctx->extradata + 8, avctx->extradata_size - 8);
 592                     FindAVCDimensions(seqParamSet, &width, &height);
 593                     avctx->width  = width;
 594                     avctx->height = height;
 595                 }
 596
 597                 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
 598                 meta->setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
 599             } else {
 600                 // H.264 bitstream with start codes.
 601                 isAVC = false;
 602                 ALOGV("H264");
 603
 604                 /* set NULL to release meta as we will new a meta in MakeAVCCodecSpecificData() fxn */
 605                 meta->clear();
 606                 meta = NULL;
 607
 608                 sp<ABuffer> buffer = new ABuffer(avctx->extradata_size);
 609                 memcpy(buffer->data(), avctx->extradata, avctx->extradata_size);
 610                 meta = MakeAVCCodecSpecificData(buffer);
 611             }
 612             break;
 613         case CODEC_ID_MPEG4:
 614             ALOGV("MPEG4");
 615             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
 616             {
 617                 sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 618                 memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 619                 sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 620                 meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 621             }
 622             break;
 623         case CODEC_ID_H263:
 624         case CODEC_ID_H263P:
 625         case CODEC_ID_H263I:
 626             ALOGV("H263");
 627             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
 628             break;
 629         case CODEC_ID_MPEG1VIDEO:
 630         case CODEC_ID_MPEG2VIDEO:
 631             ALOGV("MPEG%dVIDEO", avctx->codec_id == CODEC_ID_MPEG2VIDEO ? 2 : 1);
 632             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
 633             {
 634                 sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 635                 memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 636                 sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 637                 meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 638             }
 639             break;
 640         case CODEC_ID_VC1:
 641             ALOGV("VC1");
 642             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
 643             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 644             break;
 645         case CODEC_ID_WMV1:
 646             ALOGV("WMV1");
 647             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 648             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
 649             break;
 650         case CODEC_ID_WMV2:
 651             ALOGV("WMV2");
 652             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 653             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 654             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
 655             break;
 656         case CODEC_ID_WMV3:
 657             ALOGV("WMV3");
 658             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 659             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 660             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
 661             break;
 662         case CODEC_ID_RV20:
 663             ALOGV("RV30");
 664             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 665             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 666             meta->setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVideo
 667         case CODEC_ID_RV30:
 668             ALOGV("RV30");
 669             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 670             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 671             meta->setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVideo
 672             break;
 673         case CODEC_ID_RV40:
 674             ALOGV("RV40");
 675             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 676             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 677             meta->setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVideo
 678             break;
 679         case CODEC_ID_FLV1:
 680             ALOGV("FLV1");
 681             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
 682             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 683             break;
 684         default:
 685             ALOGD("unsuppoted video codec(id:%d, name:%s), but give it a chance",
 686                     avctx->codec_id, avcodec_get_name(avctx->codec_id));
 687             meta = new MetaData;
 688             meta->setInt32(kKeyCodecId, avctx->codec_id);
 689             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
 690             if (avctx->extradata_size > 0) {
 691                 meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 692             }
 693             //CHECK(!"Should not be here. Unsupported codec.");
 694             break;
 695         }
 696
 697         ALOGI("width: %d, height: %d, bit_rate: %d",
 698              avctx->width, avctx->height, avctx->bit_rate);
 699
 700         meta->setInt32(kKeyWidth, avctx->width);
 701         meta->setInt32(kKeyHeight, avctx->height);
 702         if (avctx->bit_rate > 0)
 703             meta->setInt32(kKeyBitRate, avctx->bit_rate);
 704         if (mVideoStream->duration != AV_NOPTS_VALUE) {
 705             int64_t duration = mVideoStream->duration * av_q2d(mVideoStream->time_base) * 1000000;
 706             printTime(duration);
 707             ALOGV("video startTime: %lld", mVideoStream->start_time);
 708             if (mVideoStream->start_time != AV_NOPTS_VALUE) {
 709                 ALOGV("video startTime:%lld", mVideoStream->start_time);
 710             } else {
 711                 ALOGV("video startTime:N/A");
 712             }
 713             meta->setInt64(kKeyDuration, duration);
 714         } else {
 715             // default when no stream duration
 716             meta->setInt64(kKeyDuration, mFormatCtx->duration);
 717         }
 718
 719         ALOGV("create a video track");
 720         index = mTracks.add(
 721             stream_index, new Track(this, meta, isAVC, mVideoStream, &mVideoQ));
 722
 723         mDefersToCreateVideoTrack = false;
 724
 725         break;
 726     case AVMEDIA_TYPE_AUDIO:
 727         if (mAudioStreamIdx == -1)
 728             mAudioStreamIdx = stream_index;
 729         if (mAudioStream == NULL)
 730             mAudioStream = mFormatCtx->streams[stream_index];
 731         if (!mAudioQInited) {
 732             packet_queue_init(&mAudioQ);
 733             mAudioQInited = true;
 734         }
 735
 736         ret = check_extradata(avctx);
 737         if (ret != 1) {
 738             if (ret == -1) {
 739                 // disable the stream
 740                 mAudioStreamIdx = -1;
 741                 mAudioStream = NULL;
 742                 packet_queue_end(&mAudioQ);
 743                 mAudioQInited =  false;
 744                 mFormatCtx->streams[stream_index]->discard = AVDISCARD_ALL;
 745             }
 746             return ret;
 747         }
 748
 749         if (avctx->extradata) {
 750             ALOGV("audio stream extradata:");
 751             hexdump(avctx->extradata, avctx->extradata_size);
 752         } else {
 753             ALOGV("audio stream no extradata, but we can ignore it.");
 754         }
 755
 756         switch(avctx->codec_id) {
 757         case CODEC_ID_MP1:
 758             ALOGV("MP1");
 759             meta = new MetaData;
 760             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
 761             break;
 762         case CODEC_ID_MP2:
 763             ALOGV("MP2");
 764             meta = new MetaData;
 765             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 766             break;
 767         case CODEC_ID_MP3:
 768             ALOGV("MP3");
 769             meta = new MetaData;
 770             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
 771             break;
 772         case CODEC_ID_AC3:
 773             ALOGV("AC3");
 774             meta = new MetaData;
 775             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
 776             break;
 777         case CODEC_ID_AAC:
 778             ALOGV("AAC");
 779             uint32_t sr;
 780             const uint8_t *header;
 781             uint8_t profile, sf_index, channel;
 782
 783             header = avctx->extradata;
 784             CHECK(header != NULL);
 785
 786             // AudioSpecificInfo follows
 787             // oooo offf fccc c000
 788             // o - audioObjectType
 789             // f - samplingFreqIndex
 790             // c - channelConfig
 791             profile = ((header[0] & 0xf8) >> 3) - 1;
 792             sf_index = (header[0] & 0x07) << 1 | (header[1] & 0x80) >> 7;
 793             sr = get_sample_rate(sf_index);
 794             if (sr == 0) {
 795                 ALOGE("unsupport the sample rate");
 796                 return -1;
 797             }
 798             channel = (header[1] >> 3) & 0xf;
 799             ALOGV("profile: %d, sf_index: %d, channel: %d", profile, sf_index, channel);
 800
 801             meta = MakeAACCodecSpecificData(profile, sf_index, channel);
 802             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
 803             break;
 804         case CODEC_ID_WMAV1:  // TODO, version?
 805             ALOGV("WMAV1");
 806             meta = new MetaData;
 807             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 808             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 809             break;
 810         case CODEC_ID_WMAV2:
 811             ALOGV("WMAV2");
 812             meta = new MetaData;
 813             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 814             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 815             meta->setInt32(kKeyWMAVersion, kTypeWMA);
 816             break;
 817         case CODEC_ID_WMAPRO:
 818             ALOGV("WMAPRO");
 819             meta = new MetaData;
 820             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 821             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 822             meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
 823             break;
 824         case CODEC_ID_WMALOSSLESS:
 825             ALOGV("WMALOSSLESS");
 826             meta = new MetaData;
 827             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 828             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 829             meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
 830             break;
 831         case CODEC_ID_COOK: // audio codec in RMVB
 832             ALOGV("COOK");
 833             meta = new MetaData;
 834             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
 835             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 836             break;
 837         case CODEC_ID_APE:
 838             ALOGV("APE");
 839             meta = new MetaData;
 840             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
 841             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 842             break;
 843         case CODEC_ID_DTS:
 844             ALOGV("DTS");
 845             meta = new MetaData;
 846             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
 847             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 848             break;
 849         case CODEC_ID_FLAC:
 850             ALOGV("FLAC");
 851             meta = new MetaData;
 852             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
 853             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 854             break;
 855         default:
 856             ALOGD("unsuppoted audio codec(id:%d, name:%s), but give it a chance",
 857                     avctx->codec_id, avcodec_get_name(avctx->codec_id));
 858             meta = new MetaData;
 859             meta->setInt32(kKeyCodecId, avctx->codec_id);
 860             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
 861             if (avctx->extradata_size > 0) {
 862                 meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 863             }
 864             //CHECK(!"Should not be here. Unsupported codec.");
 865             break;
 866         }
 867
 868         ALOGI("bit_rate: %d, sample_rate: %d, channels: %d, "
 869                 "bits_per_coded_sample: %d, block_align:%d",
 870                 avctx->bit_rate, avctx->sample_rate, avctx->channels,
 871                 avctx->bits_per_coded_sample, avctx->block_align);
 872
 873         meta->setInt32(kKeyChannelCount, avctx->channels);
 874         meta->setInt32(kKeyBitRate, avctx->bit_rate);
 875         meta->setInt32(kKeyBitspersample, avctx->bits_per_coded_sample);
 876         meta->setInt32(kKeySampleRate, avctx->sample_rate);
 877         meta->setInt32(kKeyBlockAlign, avctx->block_align);
 878         meta->setInt32(kKeySampleFormat, avctx->sample_fmt);
 879         if (mAudioStream->duration != AV_NOPTS_VALUE) {
 880             int64_t duration = mAudioStream->duration * av_q2d(mAudioStream->time_base) * 1000000;
 881             printTime(duration);
 882             if (mAudioStream->start_time != AV_NOPTS_VALUE) {
 883                 ALOGV("audio startTime:%lld", mAudioStream->start_time);
 884             } else {
 885                 ALOGV("audio startTime:N/A");
 886             }
 887             meta->setInt64(kKeyDuration, duration);
 888         } else {
 889             // default when no stream duration
 890             meta->setInt64(kKeyDuration, mFormatCtx->duration);
 891         }
 892
 893         ALOGV("create a audio track");
 894         index = mTracks.add(
 895             stream_index, new Track(this, meta, false, mAudioStream, &mAudioQ));
 896
 897         mDefersToCreateAudioTrack = false;
 898
 899         break;
 900     case AVMEDIA_TYPE_SUBTITLE:
 901         /* Unsupport now */
 902         CHECK(!"Should not be here. Unsupported media type.");
 903         break;
 904     default:
 905         CHECK(!"Should not be here. Unsupported media type.");
 906         break;
 907     }
 908     return 0;
 909 }
 910
 911 void FFmpegExtractor::stream_component_close(int stream_index)
 912 {
 913     AVCodecContext *avctx;
 914
 915     if (stream_index < 0 || stream_index >= (int)mFormatCtx->nb_streams)
 916         return;
 917     avctx = mFormatCtx->streams[stream_index]->codec;
 918
 919     switch (avctx->codec_type) {
 920     case AVMEDIA_TYPE_VIDEO:
 921         ALOGV("packet_queue_abort videoq");
 922         packet_queue_abort(&mVideoQ);
 923         /* wait until the end */
 924         while (!mAbortRequest && !mVideoEOSReceived) {
 925             ALOGV("wait for video received");
 926             usleep(10000);
 927         }
 928         ALOGV("packet_queue_end videoq");
 929         packet_queue_end(&mVideoQ);
 930         break;
 931     case AVMEDIA_TYPE_AUDIO:
 932         ALOGV("packet_queue_abort audioq");
 933         packet_queue_abort(&mAudioQ);
 934         while (!mAbortRequest && !mAudioEOSReceived) {
 935             ALOGV("wait for audio received");
 936             usleep(10000);
 937         }
 938         ALOGV("packet_queue_end audioq");
 939         packet_queue_end(&mAudioQ);
 940         break;
 941     case AVMEDIA_TYPE_SUBTITLE:
 942         break;
 943     default:
 944         break;
 945     }
 946
 947     mFormatCtx->streams[stream_index]->discard = AVDISCARD_ALL;
 948     switch (avctx->codec_type) {
 949     case AVMEDIA_TYPE_VIDEO:
 950         mVideoStream    = NULL;
 951         mVideoStreamIdx = -1;
 952         if (mVideoBsfc) {
 953             av_bitstream_filter_close(mVideoBsfc);
 954             mVideoBsfc  = NULL;
 955         }
 956         break;
 957     case AVMEDIA_TYPE_AUDIO:
 958         mAudioStream    = NULL;
 959         mAudioStreamIdx = -1;
 960         if (mAudioBsfc) {
 961             av_bitstream_filter_close(mAudioBsfc);
 962             mAudioBsfc  = NULL;
 963         }
 964         break;
 965     case AVMEDIA_TYPE_SUBTITLE:
 966         break;
 967     default:
 968         break;
 969     }
 970 }
 971
 972 void FFmpegExtractor::reachedEOS(enum AVMediaType media_type)
 973 {
 974     Mutex::Autolock autoLock(mLock);
 975
 976     if (media_type == AVMEDIA_TYPE_VIDEO) {
 977         mVideoEOSReceived = true;
 978     } else if (media_type == AVMEDIA_TYPE_AUDIO) {
 979         mAudioEOSReceived = true;
 980     }
 981 }
 982
 983 /* seek in the stream */
 984 int FFmpegExtractor::stream_seek(int64_t pos, enum AVMediaType media_type)
 985 {
 986     Mutex::Autolock autoLock(mLock);
 987
 988     if (mVideoStreamIdx >= 0 &&
 989         mAudioStreamIdx >= 0 &&
 990         media_type == AVMEDIA_TYPE_AUDIO &&
 991         !mVideoEOSReceived) {
 992        return NO_SEEK;
 993     }
 994
 995     // flush immediately
 996     if (mAudioStreamIdx >= 0)
 997         packet_queue_flush(&mAudioQ);
 998     if (mVideoStreamIdx >= 0)
 999         packet_queue_flush(&mVideoQ);
1000
1001     mSeekPos = pos;
1002     mSeekFlags &= ~AVSEEK_FLAG_BYTE;
1003     mSeekReq = 1;
1004
1005     return SEEK;
1006 }
1007
1008 // staitc
1009 int FFmpegExtractor::decode_interrupt_cb(void *ctx)
1010 {
1011     FFmpegExtractor *extrator = static_cast<FFmpegExtractor *>(ctx);
1012     return extrator->mAbortRequest;
1013 }
1014
1015 void FFmpegExtractor::buildFileName(const sp<DataSource> &source)
1016 {
1017 #if 1
1018     ALOGI("android-source:%p", source.get());
1019     // pass the addr of smart pointer("source")
1020     snprintf(mFilename, sizeof(mFilename), "android-source:%p", source.get());
1021     ALOGI("build mFilename: %s", mFilename);
1022 #else
1023     const char *url = mDataSource->getNamURI();
1024     if (url == NULL) {
1025         ALOGI("url is error!");
1026         return;
1027     }
1028     // is it right?
1029     if (!strcmp(url, "-")) {
1030         av_strlcpy(mFilename, "pipe:", strlen("pipe:") + 1);
1031     } else {
1032         av_strlcpy(mFilename, url, strlen(url) + 1);
1033     }
1034     ALOGI("build url: %s, mFilename: %s", url, mFilename);
1035 #endif
1036 }
1037
1038 void FFmpegExtractor::setFFmpegDefaultOpts()
1039 {
1040     mGenPTS       = 0;
1041 #if DEBUG_DISABLE_VIDEO
1042     mVideoDisable = 1;
1043 #else
1044     mVideoDisable = 0;
1045 #endif
1046 #if DEBUG_DISABLE_AUDIO
1047     mAudioDisable = 1;
1048 #else
1049     mAudioDisable = 0;
1050 #endif
1051     mShowStatus   = 0;
1052     mSeekByBytes  = 0; /* seek by bytes 0=off 1=on -1=auto" */
1053     mDuration     = AV_NOPTS_VALUE;
1054     mSeekPos      = AV_NOPTS_VALUE;
1055     mAutoExit     = 1;
1056     mLoop         = 1;
1057
1058     mVideoStreamIdx = -1;
1059     mAudioStreamIdx = -1;
1060     mVideoStream  = NULL;
1061     mAudioStream  = NULL;
1062     mVideoQInited = false;
1063     mAudioQInited = false;
1064     mDefersToCreateVideoTrack = false;
1065     mDefersToCreateAudioTrack = false;
1066     mVideoBsfc = NULL;
1067     mAudioBsfc = NULL;
1068
1069     mAbortRequest = 0;
1070     mPaused       = 0;
1071     mLastPaused   = 0;
1072     mSeekReq      = 0;
1073
1074     mProbePkts    = 0;
1075     mEOF          = false;
1076 }
1077
1078 int FFmpegExtractor::initStreams()
1079 {
1080     int err = 0;
1081         int i = 0;
1082     status_t status = UNKNOWN_ERROR;
1083     int eof = 0;
1084     int ret = 0, audio_ret = -1, video_ret = -1;
1085     int pkt_in_play_range = 0;
1086     AVDictionaryEntry *t = NULL;
1087     AVDictionary **opts = NULL;
1088     int orig_nb_streams = 0;
1089     int st_index[AVMEDIA_TYPE_NB] = {0};
1090     int wanted_stream[AVMEDIA_TYPE_NB] = {0};
1091     st_index[AVMEDIA_TYPE_AUDIO]  = -1;
1092     st_index[AVMEDIA_TYPE_VIDEO]  = -1;
1093     wanted_stream[AVMEDIA_TYPE_AUDIO]  = -1;
1094     wanted_stream[AVMEDIA_TYPE_VIDEO]  = -1;
1095     const char *mime = NULL;
1096
1097     setFFmpegDefaultOpts();
1098
1099     status = initFFmpeg();
1100     if (status != OK) {
1101         ret = -1;
1102         goto fail;
1103     }
1104     mFFmpegInited = true;
1105
1106     av_init_packet(&flush_pkt);
1107     flush_pkt.data = (uint8_t *)"FLUSH";
1108     flush_pkt.size = 0;
1109
1110     mFormatCtx = avformat_alloc_context();
1111         if (!mFormatCtx)
1112         {
1113         ALOGE("oom for alloc avformat context");
1114         ret = -1;
1115         goto fail;
1116         }
1117     mFormatCtx->interrupt_callback.callback = decode_interrupt_cb;
1118     mFormatCtx->interrupt_callback.opaque = this;
1119     ALOGV("mFilename: %s", mFilename);
1120     err = avformat_open_input(&mFormatCtx, mFilename, NULL, &format_opts);
1121     if (err < 0) {
1122         ALOGE("%s: avformat_open_input failed, err:%s", mFilename, av_err2str(err));
1123         ret = -1;
1124         goto fail;
1125     }
1126     if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1127         ALOGE("Option %s not found.\n", t->key);
1128         //ret = AVERROR_OPTION_NOT_FOUND;
1129         ret = -1;
1130         goto fail;
1131     }
1132
1133     if (mGenPTS)
1134         mFormatCtx->flags |= AVFMT_FLAG_GENPTS;
1135
1136     opts = setup_find_stream_info_opts(mFormatCtx, codec_opts);
1137     orig_nb_streams = mFormatCtx->nb_streams;
1138
1139     err = avformat_find_stream_info(mFormatCtx, opts);
1140     if (err < 0) {
1141         ALOGE("%s: could not find stream info, err:%s", mFilename, av_err2str(err));
1142         ret = -1;
1143         goto fail;
1144     }
1145     for (i = 0; i < orig_nb_streams; i++)
1146         av_dict_free(&opts[i]);
1147     av_freep(&opts);
1148
1149     mime = findMatchingContainer(mFormatCtx->iformat->name);
1150     CHECK(mime != NULL);
1151     mMeta->setCString(kKeyMIMEType, mime);
1152
1153     if (mFormatCtx->pb)
1154         mFormatCtx->pb->eof_reached = 0; // FIXME hack, ffplay maybe should not use url_feof() to test for the end
1155
1156     if (mSeekByBytes < 0)
1157         mSeekByBytes = !!(mFormatCtx->iformat->flags & AVFMT_TS_DISCONT);
1158
1159     for (i = 0; i < (int)mFormatCtx->nb_streams; i++)
1160         mFormatCtx->streams[i]->discard = AVDISCARD_ALL;
1161     if (!mVideoDisable)
1162         st_index[AVMEDIA_TYPE_VIDEO] =
1163             av_find_best_stream(mFormatCtx, AVMEDIA_TYPE_VIDEO,
1164                                 wanted_stream[AVMEDIA_TYPE_VIDEO], -1, NULL, 0);
1165     if (!mAudioDisable)
1166         st_index[AVMEDIA_TYPE_AUDIO] =
1167             av_find_best_stream(mFormatCtx, AVMEDIA_TYPE_AUDIO,
1168                                 wanted_stream[AVMEDIA_TYPE_AUDIO],
1169                                 st_index[AVMEDIA_TYPE_VIDEO],
1170                                 NULL, 0);
1171     if (mShowStatus) {
1172         av_dump_format(mFormatCtx, 0, mFilename, 0);
1173     }
1174
1175     if (mFormatCtx->duration != AV_NOPTS_VALUE &&
1176             mFormatCtx->start_time != AV_NOPTS_VALUE) {
1177         int hours, mins, secs, us;
1178
1179         ALOGV("file startTime: %lld", mFormatCtx->start_time);
1180
1181         mDuration = mFormatCtx->duration;
1182
1183         secs = mDuration / AV_TIME_BASE;
1184         us = mDuration % AV_TIME_BASE;
1185         mins = secs / 60;
1186         secs %= 60;
1187         hours = mins / 60;
1188         mins %= 60;
1189         ALOGI("the duration is %02d:%02d:%02d.%02d",
1190             hours, mins, secs, (100 * us) / AV_TIME_BASE);
1191     }
1192
1193     if (st_index[AVMEDIA_TYPE_AUDIO] >= 0) {
1194         audio_ret = stream_component_open(st_index[AVMEDIA_TYPE_AUDIO]);
1195     }
1196
1197     if (st_index[AVMEDIA_TYPE_VIDEO] >= 0) {
1198         video_ret = stream_component_open(st_index[AVMEDIA_TYPE_VIDEO]);
1199     }
1200
1201     if ( audio_ret < 0 && video_ret < 0) {
1202         ALOGE("%s: could not open codecs\n", mFilename);
1203         ret = -1;
1204         goto fail;
1205     }
1206
1207     ret = 0;
1208
1209 fail:
1210     return ret;
1211 }
1212
1213 void FFmpegExtractor::deInitStreams()
1214 {
1215     if (mFormatCtx) {
1216         avformat_close_input(&mFormatCtx);
1217     }
1218
1219     if (mFFmpegInited) {
1220         deInitFFmpeg();
1221     }
1222 }
1223
1224 status_t FFmpegExtractor::startReaderThread() {
1225     ALOGV("Starting reader thread");
1226     Mutex::Autolock autoLock(mLock);
1227
1228     if (mReaderThreadStarted)
1229         return OK;
1230
1231     pthread_attr_t attr;
1232     pthread_attr_init(&attr);
1233     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1234     pthread_create(&mReaderThread, &attr, ReaderWrapper, this);
1235     pthread_attr_destroy(&attr);
1236     mReaderThreadStarted = true;
1237     ALOGD("Reader thread started");
1238
1239     return OK;
1240 }
1241
1242 void FFmpegExtractor::stopReaderThread() {
1243     ALOGV("Stopping reader thread");
1244     Mutex::Autolock autoLock(mLock);
1245
1246     if (!mReaderThreadStarted) {
1247         ALOGD("Reader thread have been stopped");
1248         return;
1249     }
1250
1251     mAbortRequest = 1;
1252
1253     void *dummy;
1254     pthread_join(mReaderThread, &dummy);
1255     mReaderThreadStarted = false;
1256     ALOGD("Reader thread stopped");
1257 }
1258
1259 // static
1260 void *FFmpegExtractor::ReaderWrapper(void *me) {
1261     ((FFmpegExtractor *)me)->readerEntry();
1262
1263     return NULL;
1264 }
1265
1266 void FFmpegExtractor::readerEntry() {
1267     int err, i, ret;
1268     AVPacket pkt1, *pkt = &pkt1;
1269     int eof = 0;
1270     int pkt_in_play_range = 0;
1271
1272     ALOGV("FFmpegExtractor enter thread(readerEntry)");
1273
1274     mVideoEOSReceived = false;
1275     mAudioEOSReceived = false;
1276
1277     for (;;) {
1278         if (mAbortRequest)
1279             break;
1280
1281         if (mPaused != mLastPaused) {
1282             mLastPaused = mPaused;
1283             if (mPaused)
1284                 mReadPauseReturn = av_read_pause(mFormatCtx);
1285             else
1286                 av_read_play(mFormatCtx);
1287         }
1288 #if CONFIG_RTSP_DEMUXER || CONFIG_MMSH_PROTOCOL
1289         if (mPaused &&
1290                 (!strcmp(mFormatCtx->iformat->name, "rtsp") ||
1291                  (mFormatCtx->pb && !strncmp(mFilename, "mmsh:", 5)))) {
1292             /* wait 10 ms to avoid trying to get another packet */
1293             /* XXX: horrible */
1294             usleep(10000);
1295             continue;
1296         }
1297 #endif
1298
1299         if (mSeekReq) {
1300             ALOGV("readerEntry, mSeekReq: %d", mSeekReq);
1301             ret = avformat_seek_file(mFormatCtx, -1, INT64_MIN, mSeekPos, INT64_MAX, mSeekFlags);
1302             if (ret < 0) {
1303                 ALOGE("%s: error while seeking", mFormatCtx->filename);
1304             } else {
1305                 if (mAudioStreamIdx >= 0) {
1306                     packet_queue_flush(&mAudioQ);
1307                     packet_queue_put(&mAudioQ, &flush_pkt);
1308                 }
1309                 if (mVideoStreamIdx >= 0) {
1310                     packet_queue_flush(&mVideoQ);
1311                     packet_queue_put(&mVideoQ, &flush_pkt);
1312                 }
1313             }
1314             mSeekReq = 0;
1315             eof = 0;
1316         }
1317
1318         /* if the queue are full, no need to read more */
1319         if (   mAudioQ.size + mVideoQ.size > MAX_QUEUE_SIZE
1320             || (   (mAudioQ   .size  > MIN_AUDIOQ_SIZE || mAudioStreamIdx < 0)
1321                 && (mVideoQ   .nb_packets > MIN_FRAMES || mVideoStreamIdx < 0))) {
1322 #if DEBUG_READ_ENTRY
1323             ALOGV("readerEntry, is full, fuck");
1324 #endif
1325             /* wait 10 ms */
1326             usleep(10000);
1327             continue;
1328         }
1329
1330         if (eof) {
1331             if (mVideoStreamIdx >= 0) {
1332                 av_init_packet(pkt);
1333                 pkt->data = NULL;
1334                 pkt->size = 0;
1335                 pkt->stream_index = mVideoStreamIdx;
1336                 packet_queue_put(&mVideoQ, pkt);
1337             }
1338             if (mAudioStreamIdx >= 0) {
1339                 av_init_packet(pkt);
1340                 pkt->data = NULL;
1341                 pkt->size = 0;
1342                 pkt->stream_index = mAudioStreamIdx;
1343                 packet_queue_put(&mAudioQ, pkt);
1344             }
1345             usleep(10000);
1346 #if DEBUG_READ_ENTRY
1347             ALOGV("readerEntry, eof = 1, mVideoQ.size: %d, mVideoQ.nb_packets: %d, mAudioQ.size: %d, mAudioQ.nb_packets: %d",
1348                     mVideoQ.size, mVideoQ.nb_packets, mAudioQ.size, mAudioQ.nb_packets);
1349 #endif
1350             if (mAudioQ.size + mVideoQ.size  == 0) {
1351                 if (mAutoExit) {
1352                     ret = AVERROR_EOF;
1353                     goto fail;
1354                 }
1355             }
1356             eof=0;
1357             continue;
1358         }
1359
1360         ret = av_read_frame(mFormatCtx, pkt);
1361         mProbePkts++;
1362         if (ret < 0) {
1363             if (ret == AVERROR_EOF || url_feof(mFormatCtx->pb))
1364                 if (ret == AVERROR_EOF) {
1365                     //ALOGV("ret == AVERROR_EOF");
1366                 }
1367                 if (url_feof(mFormatCtx->pb)) {
1368                     //ALOGV("url_feof(mFormatCtx->pb)");
1369                 }
1370
1371                 eof = 1;
1372                 mEOF = true;
1373             if (mFormatCtx->pb && mFormatCtx->pb->error) {
1374                 ALOGE("mFormatCtx->pb->error: %d", mFormatCtx->pb->error);
1375                 break;
1376             }
1377             usleep(100000);
1378             continue;
1379         }
1380
1381         if (pkt->stream_index == mVideoStreamIdx) {
1382              if (mDefersToCreateVideoTrack) {
1383                 AVCodecContext *avctx = mFormatCtx->streams[mVideoStreamIdx]->codec;
1384
1385                 int i = parser_split(avctx, pkt->data, pkt->size);
1386                 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
1387                     if (avctx->extradata)
1388                         av_freep(&avctx->extradata);
1389                     avctx->extradata_size= i;
1390                     avctx->extradata = (uint8_t *)av_malloc(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1391                     if (!avctx->extradata) {
1392                         //return AVERROR(ENOMEM);
1393                         ret = AVERROR(ENOMEM);
1394                         goto fail;
1395                     }
1396                     // sps + pps(there may be sei in it)
1397                     memcpy(avctx->extradata, pkt->data, avctx->extradata_size);
1398                     memset(avctx->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1399                 } else {
1400                     av_free_packet(pkt);
1401                     continue;
1402                 }
1403
1404                 stream_component_open(mVideoStreamIdx);
1405                 if (!mDefersToCreateVideoTrack)
1406                     ALOGI("probe packet counter: %d when create video track ok", mProbePkts);
1407                 if (mProbePkts == EXTRACTOR_MAX_PROBE_PACKETS)
1408                     ALOGI("probe packet counter to max: %d, create video track: %d",
1409                         mProbePkts, !mDefersToCreateVideoTrack);
1410             }
1411         } else if (pkt->stream_index == mAudioStreamIdx) {
1412             int ret;
1413             uint8_t *outbuf;
1414             int   outbuf_size;
1415             AVCodecContext *avctx = mFormatCtx->streams[mAudioStreamIdx]->codec;
1416             if (mAudioBsfc && pkt && pkt->data) {
1417                 ret = av_bitstream_filter_filter(mAudioBsfc, avctx, NULL, &outbuf, &outbuf_size,
1418                                    pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY);
1419
1420                 if (ret < 0 ||!outbuf_size) {
1421                     av_free_packet(pkt);
1422                     continue;
1423                 }
1424                 if (outbuf && outbuf != pkt->data) {
1425                     memmove(pkt->data, outbuf, outbuf_size);
1426                     pkt->size = outbuf_size;
1427                 }
1428             }
1429             if (mDefersToCreateAudioTrack) {
1430                 if (avctx->extradata_size <= 0) {
1431                     av_free_packet(pkt);
1432                     continue;
1433                 }
1434                 stream_component_open(mAudioStreamIdx);
1435                 if (!mDefersToCreateAudioTrack)
1436                     ALOGI("probe packet counter: %d when create audio track ok", mProbePkts);
1437                 if (mProbePkts == EXTRACTOR_MAX_PROBE_PACKETS)
1438                     ALOGI("probe packet counter to max: %d, create audio track: %d",
1439                         mProbePkts, !mDefersToCreateAudioTrack);
1440             }
1441         }
1442
1443         if (pkt->stream_index == mAudioStreamIdx) {
1444             packet_queue_put(&mAudioQ, pkt);
1445         } else if (pkt->stream_index == mVideoStreamIdx) {
1446             packet_queue_put(&mVideoQ, pkt);
1447         } else {
1448             av_free_packet(pkt);
1449         }
1450     }
1451     /* wait until the end */
1452     while (!mAbortRequest) {
1453         usleep(100000);
1454     }
1455
1456     ret = 0;
1457 fail:
1458     ALOGI("reader thread goto end...");
1459
1460     /* close each stream */
1461     if (mAudioStreamIdx >= 0)
1462         stream_component_close(mAudioStreamIdx);
1463     if (mVideoStreamIdx >= 0)
1464         stream_component_close(mVideoStreamIdx);
1465     if (mFormatCtx) {
1466         avformat_close_input(&mFormatCtx);
1467     }
1468
1469     ALOGV("FFmpegExtractor exit thread(readerEntry)");
1470 }
1471
1472 ////////////////////////////////////////////////////////////////////////////////
1473
1474 FFmpegExtractor::Track::Track(
1475         FFmpegExtractor *extractor, sp<MetaData> meta, bool isAVC,
1476         AVStream *stream, PacketQueue *queue)
1477     : mExtractor(extractor),
1478       mMeta(meta),
1479       mIsAVC(isAVC),
1480       mStream(stream),
1481       mQueue(queue) {
1482     const char *mime;
1483
1484     /* H.264 Video Types */
1485     {
1486         mNal2AnnexB = false;
1487
1488         if (mIsAVC) {
1489             uint32_t type;
1490             const void *data;
1491             size_t size;
1492             CHECK(meta->findData(kKeyAVCC, &type, &data, &size));
1493
1494             const uint8_t *ptr = (const uint8_t *)data;
1495
1496             CHECK(size >= 7);
1497             CHECK_EQ((unsigned)ptr[0], 1u);  // configurationVersion == 1
1498
1499             // The number of bytes used to encode the length of a NAL unit.
1500             mNALLengthSize = 1 + (ptr[4] & 3);
1501
1502             ALOGV("the stream is AVC, the length of a NAL unit: %d", mNALLengthSize);
1503
1504             mNal2AnnexB = true;
1505         }
1506     }
1507
1508     mMediaType = mStream->codec->codec_type;
1509     mFirstKeyPktTimestamp = AV_NOPTS_VALUE;
1510 }
1511
1512 FFmpegExtractor::Track::~Track() {
1513     ALOGV("FFmpegExtractor::Track::~Track %s",
1514             av_get_media_type_string(mMediaType));
1515         mExtractor = NULL;
1516         mMeta = NULL;
1517 }
1518
1519 status_t FFmpegExtractor::Track::start(MetaData *params) {
1520     ALOGV("FFmpegExtractor::Track::start %s",
1521             av_get_media_type_string(mMediaType));
1522     Mutex::Autolock autoLock(mLock);
1523     //mExtractor->startReaderThread();
1524     return OK;
1525 }
1526
1527 status_t FFmpegExtractor::Track::stop() {
1528     ALOGV("FFmpegExtractor::Track::stop %s",
1529             av_get_media_type_string(mMediaType));
1530     Mutex::Autolock autoLock(mLock);
1531     //mExtractor->stopReaderThread();
1532     return OK;
1533 }
1534
1535 sp<MetaData> FFmpegExtractor::Track::getFormat() {
1536     Mutex::Autolock autoLock(mLock);
1537
1538     return mMeta;
1539 }
1540
1541 status_t FFmpegExtractor::Track::read(
1542         MediaBuffer **buffer, const ReadOptions *options) {
1543     *buffer = NULL;
1544
1545     Mutex::Autolock autoLock(mLock);
1546
1547     AVPacket pkt;
1548     bool seeking = false;
1549     bool waitKeyPkt = false;
1550     ReadOptions::SeekMode mode;
1551     int64_t pktTS = AV_NOPTS_VALUE;
1552     int64_t seekTimeUs = AV_NOPTS_VALUE;
1553     int64_t timeUs = AV_NOPTS_VALUE;
1554     int key = 0;
1555     status_t status = OK;
1556
1557     if (options && options->getSeekTo(&seekTimeUs, &mode)) {
1558         ALOGV("~~~%s seekTimeUs: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
1559         /* add the stream start time */
1560         if (mStream->start_time != AV_NOPTS_VALUE)
1561             seekTimeUs += mStream->start_time * av_q2d(mStream->time_base) * 1000000;
1562         ALOGV("~~~%s seekTimeUs[+startTime]: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
1563
1564         if (mExtractor->stream_seek(seekTimeUs, mMediaType) == SEEK)
1565             seeking = true;
1566     }
1567
1568 retry:
1569     if (mExtractor->packet_queue_get(mQueue, &pkt, 1) < 0) {
1570         mExtractor->reachedEOS(mMediaType);
1571         return ERROR_END_OF_STREAM;
1572     }
1573
1574     if (seeking) {
1575         if (pkt.data != flush_pkt.data) {
1576             av_free_packet(&pkt);
1577             goto retry;
1578         } else {
1579             seeking = false;
1580 #if WAIT_KEY_PACKET_AFTER_SEEK
1581             waitKeyPkt = true;
1582 #endif
1583         }
1584     }
1585
1586     if (pkt.data == flush_pkt.data) {
1587         ALOGV("read %s flush pkt", av_get_media_type_string(mMediaType));
1588         av_free_packet(&pkt);
1589         mFirstKeyPktTimestamp = AV_NOPTS_VALUE;
1590         goto retry;
1591     } else if (pkt.data == NULL && pkt.size == 0) {
1592         ALOGD("read %s eos pkt", av_get_media_type_string(mMediaType));
1593         av_free_packet(&pkt);
1594         mExtractor->reachedEOS(mMediaType);
1595             return ERROR_END_OF_STREAM;
1596     }
1597
1598     key = pkt.flags & AV_PKT_FLAG_KEY ? 1 : 0;
1599     pktTS = pkt.pts; //FIXME AV_NOPTS_VALUE??
1600     // use dts when AVI
1601     if (pkt.pts == AV_NOPTS_VALUE)
1602         pktTS = pkt.dts;
1603
1604     if (waitKeyPkt) {
1605         if (!key) {
1606             ALOGV("drop the no key packet");
1607             av_free_packet(&pkt);
1608             goto retry;
1609         } else {
1610             ALOGV("~~~~~~ got the key packet");
1611             waitKeyPkt = false;
1612         }
1613     }
1614
1615     if (pktTS != AV_NOPTS_VALUE && mFirstKeyPktTimestamp == AV_NOPTS_VALUE) {
1616         // update the first key timestamp
1617         mFirstKeyPktTimestamp = pktTS;
1618     }
1619
1620     if (pktTS != AV_NOPTS_VALUE && pktTS < mFirstKeyPktTimestamp) {
1621             ALOGV("drop the packet with the backward timestamp, maybe they are B-frames after I-frame ^_^");
1622             av_free_packet(&pkt);
1623             goto retry;
1624     }
1625
1626     MediaBuffer *mediaBuffer = new MediaBuffer(pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
1627     mediaBuffer->meta_data()->clear();
1628     mediaBuffer->set_range(0, pkt.size);
1629 #if DISABLE_NAL_TO_ANNEXB
1630     mNal2AnnexB = false;
1631 #endif
1632     if (mIsAVC && mNal2AnnexB) {
1633         /* Convert H.264 NAL format to annex b */
1634         if (mNALLengthSize >= 3 && mNALLengthSize <= 4 )
1635         {
1636             uint8_t *dst = (uint8_t *)mediaBuffer->data();
1637
1638             /* This only works for NAL sizes 3-4 */
1639             size_t len = pkt.size, i;
1640             uint8_t *ptr = pkt.data;
1641             while (len >= mNALLengthSize) {
1642                 uint32_t nal_len = 0;
1643                 for( i = 0; i < mNALLengthSize; i++ ) {
1644                     nal_len = (nal_len << 8) | ptr[i];
1645                     dst[i] = 0;
1646                 }
1647                 dst[mNALLengthSize - 1] = 1;
1648                 if (nal_len > INT_MAX || nal_len > (unsigned int)len) {
1649                     status = ERROR_MALFORMED;
1650                     break;
1651                 }
1652                                 dst += mNALLengthSize;
1653                                 ptr += mNALLengthSize;
1654                 len -= mNALLengthSize;
1655
1656                 memcpy(dst, ptr, nal_len);
1657
1658                 dst += nal_len;
1659                 ptr += nal_len;
1660                 len -= nal_len;
1661             }
1662         } else {
1663              status = ERROR_MALFORMED;
1664         }
1665
1666         if (status != OK) {
1667             ALOGV("status != OK");
1668             mediaBuffer->release();
1669             mediaBuffer = NULL;
1670             av_free_packet(&pkt);
1671             return ERROR_MALFORMED;
1672         }
1673     } else {
1674         memcpy(mediaBuffer->data(), pkt.data, pkt.size);
1675     }
1676
1677     int64_t start_time = mStream->start_time != AV_NOPTS_VALUE ? mStream->start_time : 0;
1678     if (pktTS != AV_NOPTS_VALUE)
1679         timeUs = (int64_t)((pktTS - start_time) * av_q2d(mStream->time_base) * 1000000);
1680     else
1681         timeUs = SF_NOPTS_VALUE; //FIXME AV_NOPTS_VALUE is negative, but stagefright need positive
1682
1683 #if DEBUG_PKT
1684     if (pktTS != AV_NOPTS_VALUE)
1685         ALOGV("read %s pkt, size:%d, key:%d, pts:%lld, dts:%lld, timeUs[-startTime]:%lld us (%.2f secs)",
1686             av_get_media_type_string(mMediaType), pkt.size, key, pkt.pts, pkt.dts, timeUs, timeUs/1E6);
1687     else
1688         ALOGV("read %s pkt, size:%d, key:%d, pts:N/A, dts:N/A, timeUs[-startTime]:N/A",
1689             av_get_media_type_string(mMediaType), pkt.size, key);
1690 #endif
1691
1692     mediaBuffer->meta_data()->setInt64(kKeyTime, timeUs);
1693     mediaBuffer->meta_data()->setInt32(kKeyIsSyncFrame, key);
1694
1695     *buffer = mediaBuffer;
1696
1697     av_free_packet(&pkt);
1698
1699     return OK;
1700 }
1701
1702 ////////////////////////////////////////////////////////////////////////////////
1703
1704 typedef struct {
1705     const char *format;
1706     const char *container;
1707 } formatmap;
1708
1709 static formatmap FILE_FORMATS[] = {
1710         {"mpeg",                    MEDIA_MIMETYPE_CONTAINER_MPEG2PS  },
1711         {"mpegts",                  MEDIA_MIMETYPE_CONTAINER_TS       },
1712         {"mov,mp4,m4a,3gp,3g2,mj2", MEDIA_MIMETYPE_CONTAINER_MPEG4    },
1713         {"matroska,webm",           MEDIA_MIMETYPE_CONTAINER_MATROSKA },
1714         {"asf",                     MEDIA_MIMETYPE_CONTAINER_ASF      },
1715         {"rm",                      MEDIA_MIMETYPE_CONTAINER_RM       },
1716         {"flv",                     MEDIA_MIMETYPE_CONTAINER_FLV      },
1717         {"swf",                     MEDIA_MIMETYPE_CONTAINER_FLV      },
1718         {"avi",                     MEDIA_MIMETYPE_CONTAINER_AVI      },
1719         {"ape",                     MEDIA_MIMETYPE_CONTAINER_APE      },
1720         {"dts",                     MEDIA_MIMETYPE_CONTAINER_DTS      },
1721         {"flac",                    MEDIA_MIMETYPE_CONTAINER_FLAC     },
1722         {"ac3",                     MEDIA_MIMETYPE_AUDIO_AC3          },
1723         {"wav",                     MEDIA_MIMETYPE_CONTAINER_WAV      },
1724 };
1725
1726 static void adjustMPEG4Confidence(AVFormatContext *ic, float *confidence)
1727 {
1728         AVDictionary *tags = NULL;
1729         AVDictionaryEntry *tag = NULL;
1730
1731         tags = ic->metadata;
1732
1733         //NOTE: You can use command to show these tags,
1734         //e.g. "ffprobe -show_format 2012.mov"
1735
1736         tag = av_dict_get(tags, "major_brand", NULL, 0);
1737         if (!tag) {
1738                 return;
1739         }
1740
1741         ALOGV("major_brand tag is:%s", tag->value);
1742
1743         //when MEDIA_MIMETYPE_CONTAINER_MPEG4
1744         //WTF, MPEG4Extractor.cpp can not extractor mov format
1745         //NOTE: isCompatibleBrand(MPEG4Extractor.cpp)
1746         //  Won't promise that the following file types can be played.
1747         //  Just give these file types a chance.
1748         //  FOURCC('q', 't', ' ', ' '),  // Apple's QuickTime
1749         //So......
1750         if (!strcmp(tag->value, "qt  ")) {
1751                 ALOGI("format is mov, confidence should be larger than mpeg4");
1752                 //the MEDIA_MIMETYPE_CONTAINER_MPEG4 of confidence is 0.4f
1753                 *confidence = 0.41f;
1754         }
1755 }
1756
1757 static void adjustVideoCodecConfidence(AVFormatContext *ic,
1758                 enum AVCodecID codec_id, float *confidence)
1759 {
1760         //add to here
1761 }
1762
1763 //TODO. if the other stream(e.g. mp3) is supported by stagefright
1764 static void adjustAudioCodecConfidence(AVFormatContext *ic,
1765                 enum AVCodecID codec_id, float *confidence)
1766 {
1767         switch (codec_id) {
1768         case CODEC_ID_AC3:
1769                 ALOGI("ffmpeg can demux ac3 only");
1770                 *confidence = 0.88f;
1771                 break;
1772         case CODEC_ID_MP1:
1773         case CODEC_ID_MP2:
1774                 //TODO. if the other stream(e.g. mp3) is supported by stagefright
1775                 ALOGI("ffmpeg can demux mp1 and mp2 only");
1776                 *confidence = 0.88f;
1777                 break;
1778         default:
1779                 break;
1780         }
1781 }
1782
1783 static void adjustCodecConfidence(AVFormatContext *ic, float *confidence)
1784 {
1785         unsigned int idx = 0;
1786         AVCodecContext *avctx = NULL;
1787         AVMediaType     codec_type = AVMEDIA_TYPE_UNKNOWN;
1788         enum AVCodecID codec_id = AV_CODEC_ID_NONE;
1789         bool haveVideo = false;
1790         bool haveAudio = false;
1791         bool haveMP3 = false;
1792
1793         for (idx = 0; idx < ic->nb_streams; idx++) {
1794                 avctx = ic->streams[idx]->codec;
1795                 codec_type = avctx->codec_type;
1796                 codec_id = avctx->codec_id;
1797
1798                 if (codec_type == AVMEDIA_TYPE_VIDEO) {
1799                         haveVideo = true;
1800                         adjustVideoCodecConfidence(ic, codec_id, confidence);
1801                 } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
1802                         haveAudio = true;
1803                         adjustAudioCodecConfidence(ic, codec_id, confidence);
1804                         if (codec_id == CODEC_ID_MP3)
1805                                 haveMP3 = true;
1806                 }
1807         }
1808
1809         if (haveVideo && haveMP3) {
1810                 *confidence = 0.22f; // larger than MP3Extractor an MP3Extractor
1811         }
1812 }
1813
1814 static void adjustConfidenceIfNeeded(const char *mime,
1815                 AVFormatContext *ic, float *confidence)
1816 {
1817         //check mime
1818         if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4)) {
1819                 adjustMPEG4Confidence(ic, confidence);
1820         } else {
1821                 //add to here;
1822         }
1823
1824         //check codec
1825         adjustCodecConfidence(ic, confidence);
1826 }
1827
1828 static const char *findMatchingContainer(const char *name)
1829 {
1830         size_t i = 0;
1831         const char *container = NULL;
1832
1833         ALOGI("list the formats suppoted by ffmpeg: ");
1834         ALOGI("========================================");
1835         for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
1836                 ALOGV("format_names[%02d]: %s", i, FILE_FORMATS[i].format);
1837         }
1838         ALOGI("========================================");
1839
1840         for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
1841                 int len = strlen(FILE_FORMATS[i].format);
1842                 if (!av_strncasecmp(name, FILE_FORMATS[i].format, len)) {
1843                         container = FILE_FORMATS[i].container;
1844                         break;
1845                 }
1846         }
1847
1848         return container;
1849 }
1850
1851 static const char *SniffFFMPEGCommon(const char *url, float *confidence)
1852 {
1853         size_t i = 0;
1854         int err = 0;
1855         const char *container = NULL;
1856         AVFormatContext *ic = NULL;
1857         AVDictionary **opts = NULL;
1858         size_t orig_nb_streams = 0;
1859
1860         status_t status = initFFmpeg();
1861         if (status != OK) {
1862                 ALOGE("could not init ffmpeg");
1863                 return NULL;
1864         }
1865
1866         ic = avformat_alloc_context();
1867         if (!ic)
1868         {
1869                 ALOGE("oom for alloc avformat context");
1870                 goto fail;
1871         }
1872
1873         err = avformat_open_input(&ic, url, NULL, NULL);
1874         if (err < 0) {
1875         ALOGE("%s: avformat_open_input failed, err:%s", url, av_err2str(err));
1876                 goto fail;
1877         }
1878
1879         opts = setup_find_stream_info_opts(ic, codec_opts);
1880         orig_nb_streams = ic->nb_streams;
1881         err = avformat_find_stream_info(ic, opts);
1882         if (err < 0) {
1883         ALOGE("%s: could not find stream info, err:%s", url, av_err2str(err));
1884                 goto fail;
1885         }
1886         for (i = 0; i < orig_nb_streams; i++) {
1887                 av_dict_free(&opts[i]);
1888         }
1889         av_freep(&opts);
1890
1891         av_dump_format(ic, 0, url, 0);
1892
1893         ALOGI("FFmpegExtrator, url: %s, format_name: %s, format_long_name: %s",
1894                         url, ic->iformat->name, ic->iformat->long_name);
1895
1896         container = findMatchingContainer(ic->iformat->name);
1897
1898         if (container) {
1899                 adjustConfidenceIfNeeded(container, ic, confidence);
1900         }
1901
1902 fail:
1903         if (ic) {
1904                 avformat_close_input(&ic);
1905                 av_free(ic);
1906         }
1907         if (status == OK) {
1908                 deInitFFmpeg();
1909         }
1910
1911         return container;
1912 }
1913
1914 static const char *LegacySniffFFMPEG(const sp<DataSource> &source, float *confidence)
1915 {
1916         String8 uri = source->getUri();
1917         if (uri.empty()) {
1918                 return NULL;
1919         }
1920
1921         ALOGI("source url:%s", uri.string());
1922
1923         return SniffFFMPEGCommon(uri.string(), confidence);
1924 }
1925
1926 static const char *BetterSniffFFMPEG(const sp<DataSource> &source, float *confidence)
1927 {
1928         char url[128] = {0};
1929
1930         ALOGI("android-source:%p", source.get());
1931
1932         // pass the addr of smart pointer("source")
1933         snprintf(url, sizeof(url), "android-source:%p", source.get());
1934
1935         return SniffFFMPEGCommon(url, confidence);
1936 }
1937
1938 bool SniffFFMPEG(
1939         const sp<DataSource> &source, String8 *mimeType, float *confidence,
1940         sp<AMessage> *meta) {
1941         ALOGV("SniffFFMPEG");
1942
1943         *confidence = 0.08f;  // be the last resort, by default
1944
1945         const char *container = BetterSniffFFMPEG(source, confidence);
1946         if (!container) {
1947                 ALOGW("sniff through BetterSniffFFMPEG failed, try LegacySniffFFMPEG");
1948                 container = LegacySniffFFMPEG(source, confidence);
1949                 if (container) {
1950                         ALOGI("sniff through LegacySniffFFMPEG success");
1951                 }
1952         } else {
1953                 ALOGI("sniff through BetterSniffFFMPEG success");
1954         }
1955
1956         if (container == NULL) {
1957                 ALOGD("SniffFFMPEG failed to sniff this source");
1958                 return false;
1959         }
1960
1961         ALOGD("ffmpeg detected media content as '%s' with confidence %.2f",
1962                         container, *confidence);
1963
1964         /* use MPEG4Extractor(not extended extractor) for HTTP source only */
1965         if (!strcasecmp(container, MEDIA_MIMETYPE_CONTAINER_MPEG4)
1966                         && (source->flags() & DataSource::kIsCachingDataSource)) {
1967                 ALOGI("support container: %s, but it is caching data source, "
1968                                 "Don't use ffmpegextractor", container);
1969                 return false;
1970         }
1971
1972         mimeType->setTo(container);
1973
1974         *meta = new AMessage;
1975         (*meta)->setString("extended-extractor", "extended-extractor");
1976         (*meta)->setString("extended-extractor-subtype", "ffmpegextractor");
1977
1978         //debug only
1979         char value[PROPERTY_VALUE_MAX];
1980         property_get("sys.media.parser.ffmpeg", value, "0");
1981         if (atoi(value)) {
1982                 ALOGI("[debug] parser use ffmpeg");
1983                 *confidence = 0.88f;
1984         }
1985
1986         if (*confidence == 0.88f) {
1987                 (*meta)->setString("extended-extractor-use", "ffmpegextractor");
1988         }
1989
1990         return true;
1991 }
1992
1993 MediaExtractor *CreateFFmpegExtractor(const sp<DataSource> &source, const char *mime, const sp<AMessage> &meta) {
1994     MediaExtractor *ret = NULL;
1995     AString notuse;
1996     if (meta.get() && meta->findString("extended-extractor", &notuse) && (
1997             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4)     ||
1998             !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG)          ||
1999             !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AC3)           ||
2000             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MOV)       ||
2001             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA)  ||
2002             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_TS)        ||
2003             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS)   ||
2004             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_AVI)       ||
2005             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_ASF)       ||
2006             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WEBM)      ||
2007             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMV)       ||
2008             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPG)       ||
2009             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLV)       ||
2010             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DIVX)      ||
2011             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RM)        ||
2012             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV)       ||
2013             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLAC)      ||
2014             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_APE)       ||
2015             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DTS)       ||
2016             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MP2)       ||
2017             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RA)        ||
2018             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMA))) {
2019         ret = new FFmpegExtractor(source);
2020     }
2021
2022     ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime);
2023     return ret;
2024 }
2025
2026 }  // namespace android
2027
2028 extern "C" void getExtractorPlugin(android::MediaExtractor::Plugin *plugin)
2029 {
2030     plugin->sniff = android::SniffFFMPEG;
2031     plugin->create = android::CreateFFmpegExtractor;
2032 }