add HEVC(H.265) decoder. plz sync:

1. git@github.com:omxcodec/android_external_ffmpeg (branch:cm_maguro-10.1)
2. https://github.com/omxcodec/android_frameworks_native.git (branch:cm_maguro-10.1)
3. https://github.com/omxcodec/android_frameworks_av.git (branch:cm_maguro-10.1)

How to test hevc decoder:
1. get test media files
wget http://ftp.kw.bbc.co.uk/hevc/hm-10.0-anchors/bitstreams/i_main/BQMall_832x480_60_qp22.bin and push it to /sdcard/Movies/hevc/
2. set prop because hevc decoder is very show
adb shell setprop sys.media.vdec.drop 0
3. play raw hevc file
adb shell am start -a android.intent.action.VIEW -d file:///mnt/sdcard/Movies/hevc/BQMall_832x480_60_qp22.bin -t video/*

diff --git a/config/media_codecs.xml b/config/media_codecs.xml
index 09f4bcd..ab48873 100644 (file)
--- a/config/media_codecs.xml
+++ b/config/media_codecs.xml
@@ -96,6 +96,7 @@ Only the three quirks included above are recognized at this point:
         <MediaCodec name="OMX.ffmpeg.vc1.decoder"    type="video/vc1" />
         <MediaCodec name="OMX.ffmpeg.flv1.decoder"    type="video/x-flv" />
         <MediaCodec name="OMX.ffmpeg.divx.decoder"    type="video/divx" />
+        <MediaCodec name="OMX.ffmpeg.hevc.decoder"    type="video/hevc" />
         <MediaCodec name="OMX.ffmpeg.vtrial.decoder" type="video/ffmpeg" />
 
         <!-- ffmpeg audio codec -->

diff --git a/libstagefright/FFmpegExtractor/FFmpegExtractor.cpp b/libstagefright/FFmpegExtractor/FFmpegExtractor.cpp
index 078a88a..08fa7a2 100644 (file)
--- a/libstagefright/FFmpegExtractor/FFmpegExtractor.cpp
+++ b/libstagefright/FFmpegExtractor/FFmpegExtractor.cpp
@@ -375,7 +375,7 @@ static uint32_t get_sample_rate(const uint8_t sf_index)
 
 int FFmpegExtractor::check_extradata(AVCodecContext *avctx)
 {
-    enum AVCodecID codec_id = CODEC_ID_NONE;
+    enum AVCodecID codec_id = AV_CODEC_ID_NONE;
     const char *name = NULL;
     bool *defersToCreateTrack = NULL;
     AVBitStreamFilterContext **bsfc = NULL;
@@ -392,16 +392,16 @@ int FFmpegExtractor::check_extradata(AVCodecContext *avctx)
        codec_id = avctx->codec_id;
 
     // ignore extradata
-    if (codec_id != CODEC_ID_H264
-            && codec_id != CODEC_ID_MPEG4
-            && codec_id != CODEC_ID_MPEG1VIDEO
-            && codec_id != CODEC_ID_MPEG2VIDEO
-            && codec_id != CODEC_ID_AAC) {
+    if (codec_id != AV_CODEC_ID_H264
+            && codec_id != AV_CODEC_ID_MPEG4
+            && codec_id != AV_CODEC_ID_MPEG1VIDEO
+            && codec_id != AV_CODEC_ID_MPEG2VIDEO
+            && codec_id != AV_CODEC_ID_AAC) {
         return 1;
     }
 
     // is extradata compatible with android?
-    if (codec_id != CODEC_ID_AAC) {
+    if (codec_id != AV_CODEC_ID_AAC) {
         int is_compatible = is_extradata_compatible_with_android(avctx);
         if (!is_compatible) {
             ALOGI("%s extradata is not compatible with android, should to extract it from bitstream",
@@ -413,7 +413,7 @@ int FFmpegExtractor::check_extradata(AVCodecContext *avctx)
         return 1;
     }
 
-    if (codec_id == CODEC_ID_AAC) {
+    if (codec_id == AV_CODEC_ID_AAC) {
         name = "aac_adtstoasc";
     }
 
@@ -461,34 +461,35 @@ bool FFmpegExtractor::is_codec_supported(enum AVCodecID codec_id)
     bool supported = false;
 
     switch(codec_id) {
-    case CODEC_ID_H264:
-    case CODEC_ID_MPEG4:
-    case CODEC_ID_H263:
-    case CODEC_ID_H263P:
-    case CODEC_ID_H263I:
-    case CODEC_ID_AAC:
-    case CODEC_ID_AC3:
-    case CODEC_ID_MP2:
-    case CODEC_ID_MP3:
-    case CODEC_ID_MPEG1VIDEO:
-    case CODEC_ID_MPEG2VIDEO:
-    case CODEC_ID_WMV1:
-    case CODEC_ID_WMV2:
-    case CODEC_ID_WMV3:
-    case CODEC_ID_VC1:
-    case CODEC_ID_WMAV1:
-    case CODEC_ID_WMAV2:
-    case CODEC_ID_WMAPRO:
-    case CODEC_ID_WMALOSSLESS:
-    case CODEC_ID_RV20:
-    case CODEC_ID_RV30:
-    case CODEC_ID_RV40:
-    case CODEC_ID_COOK:
-    case CODEC_ID_APE:
-    case CODEC_ID_DTS:
-    case CODEC_ID_FLAC:
-    case CODEC_ID_FLV1:
-    case CODEC_ID_VORBIS:
+    case AV_CODEC_ID_H264:
+    case AV_CODEC_ID_MPEG4:
+    case AV_CODEC_ID_H263:
+    case AV_CODEC_ID_H263P:
+    case AV_CODEC_ID_H263I:
+    case AV_CODEC_ID_AAC:
+    case AV_CODEC_ID_AC3:
+    case AV_CODEC_ID_MP2:
+    case AV_CODEC_ID_MP3:
+    case AV_CODEC_ID_MPEG1VIDEO:
+    case AV_CODEC_ID_MPEG2VIDEO:
+    case AV_CODEC_ID_WMV1:
+    case AV_CODEC_ID_WMV2:
+    case AV_CODEC_ID_WMV3:
+    case AV_CODEC_ID_VC1:
+    case AV_CODEC_ID_WMAV1:
+    case AV_CODEC_ID_WMAV2:
+    case AV_CODEC_ID_WMAPRO:
+    case AV_CODEC_ID_WMALOSSLESS:
+    case AV_CODEC_ID_RV20:
+    case AV_CODEC_ID_RV30:
+    case AV_CODEC_ID_RV40:
+    case AV_CODEC_ID_COOK:
+    case AV_CODEC_ID_APE:
+    case AV_CODEC_ID_DTS:
+    case AV_CODEC_ID_FLAC:
+    case AV_CODEC_ID_FLV1:
+    case AV_CODEC_ID_VORBIS:
+    case AV_CODEC_ID_HEVC:
 
         supported = true;
         break;
@@ -576,7 +577,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
         meta = new MetaData;
 
         switch(avctx->codec_id) {
-        case CODEC_ID_H264:
+        case AV_CODEC_ID_H264:
             /**
              * H.264 Video Types
              * http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
@@ -612,7 +613,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
                 meta = MakeAVCCodecSpecificData(buffer);
             }
             break;
-        case CODEC_ID_MPEG4:
+        case AV_CODEC_ID_MPEG4:
             ALOGV("MPEG4");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
             {
@@ -622,15 +623,15 @@ int FFmpegExtractor::stream_component_open(int stream_index)
                 meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
             }
             break;
-        case CODEC_ID_H263:
-        case CODEC_ID_H263P:
-        case CODEC_ID_H263I:
+        case AV_CODEC_ID_H263:
+        case AV_CODEC_ID_H263P:
+        case AV_CODEC_ID_H263I:
             ALOGV("H263");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
             break;
-        case CODEC_ID_MPEG1VIDEO:
-        case CODEC_ID_MPEG2VIDEO:
-            ALOGV("MPEG%dVIDEO", avctx->codec_id == CODEC_ID_MPEG2VIDEO ? 2 : 1);
+        case AV_CODEC_ID_MPEG1VIDEO:
+        case AV_CODEC_ID_MPEG2VIDEO:
+            ALOGV("MPEG%dVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
             {
                 sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
@@ -639,50 +640,55 @@ int FFmpegExtractor::stream_component_open(int stream_index)
                 meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
             }
             break;
-        case CODEC_ID_VC1:
+        case AV_CODEC_ID_VC1:
             ALOGV("VC1");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_WMV1:
+        case AV_CODEC_ID_WMV1:
             ALOGV("WMV1");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
             break;
-        case CODEC_ID_WMV2:
+        case AV_CODEC_ID_WMV2:
             ALOGV("WMV2");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
             break;
-        case CODEC_ID_WMV3:
+        case AV_CODEC_ID_WMV3:
             ALOGV("WMV3");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
             break;
-        case CODEC_ID_RV20:
+        case AV_CODEC_ID_RV20:
             ALOGV("RV30");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVideo
-        case CODEC_ID_RV30:
+        case AV_CODEC_ID_RV30:
             ALOGV("RV30");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVideo
             break;
-        case CODEC_ID_RV40:
+        case AV_CODEC_ID_RV40:
             ALOGV("RV40");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVideo
             break;
-        case CODEC_ID_FLV1:
+        case AV_CODEC_ID_FLV1:
             ALOGV("FLV1");
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
+        case AV_CODEC_ID_HEVC:
+            ALOGV("HEVC");
+            meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
+            meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+            break;
         default:
             ALOGD("unsuppoted video codec(id:%d, name:%s), but give it a chance",
                     avctx->codec_id, avcodec_get_name(avctx->codec_id));
@@ -756,28 +762,28 @@ int FFmpegExtractor::stream_component_open(int stream_index)
         }
 
         switch(avctx->codec_id) {
-        case CODEC_ID_MP2:
+        case AV_CODEC_ID_MP2:
             ALOGV("MP2");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
             break;
-        case CODEC_ID_MP3:
+        case AV_CODEC_ID_MP3:
             ALOGV("MP3");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
             break;
-        case CODEC_ID_VORBIS:
+        case AV_CODEC_ID_VORBIS:
             ALOGV("VORBIS");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_AC3:
+        case AV_CODEC_ID_AC3:
             ALOGV("AC3");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
             break;
-        case CODEC_ID_AAC:
+        case AV_CODEC_ID_AAC:
             ALOGV("AAC");
             uint32_t sr;
             const uint8_t *header;
@@ -804,52 +810,52 @@ int FFmpegExtractor::stream_component_open(int stream_index)
             meta = MakeAACCodecSpecificData(profile, sf_index, channel);
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
             break;
-        case CODEC_ID_WMAV1:  // TODO, version?
+        case AV_CODEC_ID_WMAV1:  // TODO, version?
             ALOGV("WMAV1");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_WMAV2:
+        case AV_CODEC_ID_WMAV2:
             ALOGV("WMAV2");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyWMAVersion, kTypeWMA);
             break;
-        case CODEC_ID_WMAPRO:
+        case AV_CODEC_ID_WMAPRO:
             ALOGV("WMAPRO");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
             break;
-        case CODEC_ID_WMALOSSLESS:
+        case AV_CODEC_ID_WMALOSSLESS:
             ALOGV("WMALOSSLESS");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
             break;
-        case CODEC_ID_COOK: // audio codec in RMVB
+        case AV_CODEC_ID_COOK: // audio codec in RMVB
             ALOGV("COOK");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_APE:
+        case AV_CODEC_ID_APE:
             ALOGV("APE");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_DTS:
+        case AV_CODEC_ID_DTS:
             ALOGV("DTS");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
             meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
             break;
-        case CODEC_ID_FLAC:
+        case AV_CODEC_ID_FLAC:
             ALOGV("FLAC");
             meta = new MetaData;
             meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
@@ -1733,6 +1739,7 @@ static formatmap FILE_FORMATS[] = {
         {"ac3",                     MEDIA_MIMETYPE_AUDIO_AC3          },
         {"wav",                     MEDIA_MIMETYPE_CONTAINER_WAV      },
         {"ogg",                     MEDIA_MIMETYPE_CONTAINER_OGG      },
+        {"hevc",                     MEDIA_MIMETYPE_CONTAINER_HEVC    },
 };
 
 static void adjustMPEG4Confidence(AVFormatContext *ic, float *confidence)
@@ -1777,12 +1784,12 @@ static void adjustAudioCodecConfidence(AVFormatContext *ic,
                enum AVCodecID codec_id, float *confidence)
 {
        switch (codec_id) {
-       case CODEC_ID_AC3:
+       case AV_CODEC_ID_AC3:
                ALOGI("ffmpeg can demux ac3 only");
                *confidence = 0.88f;
                break;
-       case CODEC_ID_MP1:
-       case CODEC_ID_MP2:
+       case AV_CODEC_ID_MP1:
+       case AV_CODEC_ID_MP2:
                //TODO. if the other stream(e.g. mp3) is supported by stagefright
                ALOGI("ffmpeg can demux mp1 and mp2 only");
                *confidence = 0.88f;
@@ -1813,7 +1820,7 @@ static void adjustCodecConfidence(AVFormatContext *ic, float *confidence)
                } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
                        haveAudio = true;
                        adjustAudioCodecConfidence(ic, codec_id, confidence);
-                       if (codec_id == CODEC_ID_MP3)
+                       if (codec_id == AV_CODEC_ID_MP3)
                                haveMP3 = true;
                }
        }
@@ -2028,6 +2035,7 @@ MediaExtractor *CreateFFmpegExtractor(const sp<DataSource> &source, const char *
             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MP2)       ||
             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RA)        ||
             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_OGG)       ||
+            !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_HEVC)      ||
             !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMA))) {
         ret = new FFmpegExtractor(source);
     }

diff --git a/libstagefright/codecs/ffmpegdec/adec/SoftFFmpegAudio.cpp b/libstagefright/codecs/ffmpegdec/adec/SoftFFmpegAudio.cpp
index 6918a6b..304f794 100644 (file)
--- a/libstagefright/codecs/ffmpegdec/adec/SoftFFmpegAudio.cpp
+++ b/libstagefright/codecs/ffmpegdec/adec/SoftFFmpegAudio.cpp
@@ -24,8 +24,6 @@
 #include <media/stagefright/foundation/hexdump.h>
 #include <media/stagefright/MediaDefs.h>
 
-#include <OMX_FFExt.h>
-
 #include "utils/ffmpeg_utils.h"
 
 #define DEBUG_PKT 0
@@ -265,37 +263,37 @@ status_t SoftFFmpegAudio::initDecoder() {
     mCtx->codec_type = AVMEDIA_TYPE_AUDIO;
     switch (mMode) {
     case MODE_AAC:
-        mCtx->codec_id = CODEC_ID_AAC;
+        mCtx->codec_id = AV_CODEC_ID_AAC;
         break;
     case MODE_MPEG:
-        mCtx->codec_id = CODEC_ID_MP3;
+        mCtx->codec_id = AV_CODEC_ID_MP3;
         break;
     case MODE_VORBIS:
-        mCtx->codec_id = CODEC_ID_VORBIS;
+        mCtx->codec_id = AV_CODEC_ID_VORBIS;
         break;
     case MODE_WMA:
-        mCtx->codec_id = CODEC_ID_WMAV2; //should be adjusted later
+        mCtx->codec_id = AV_CODEC_ID_WMAV2; //should be adjusted later
         break;
     case MODE_RA:
-        mCtx->codec_id = CODEC_ID_COOK;
+        mCtx->codec_id = AV_CODEC_ID_COOK;
         break;
     case MODE_FLAC:
-        mCtx->codec_id = CODEC_ID_FLAC;
+        mCtx->codec_id = AV_CODEC_ID_FLAC;
         break;
     case MODE_MPEGL2:
-        mCtx->codec_id = CODEC_ID_MP2;
+        mCtx->codec_id = AV_CODEC_ID_MP2;
         break;
     case MODE_AC3:
-        mCtx->codec_id = CODEC_ID_AC3;
+        mCtx->codec_id = AV_CODEC_ID_AC3;
         break;
     case MODE_APE:
-        mCtx->codec_id = CODEC_ID_APE;
+        mCtx->codec_id = AV_CODEC_ID_APE;
         break;
     case MODE_DTS:
-        mCtx->codec_id = CODEC_ID_DTS;
+        mCtx->codec_id = AV_CODEC_ID_DTS;
         break;
     case MODE_TRIAL:
-        mCtx->codec_id = CODEC_ID_NONE;
+        mCtx->codec_id = AV_CODEC_ID_NONE;
         break;
     default:
         CHECK(!"Should not be here. Unsupported codec");
@@ -561,29 +559,30 @@ OMX_ERRORTYPE SoftFFmpegAudio::internalGetParameter(
             return OMX_ErrorNone;
         }
 
-        default:
-            if ((OMX_FF_INDEXTYPE)index == OMX_IndexParamAudioFFmpeg)
-            {
-                OMX_AUDIO_PARAM_FFMPEGTYPE *profile =
-                    (OMX_AUDIO_PARAM_FFMPEGTYPE *)params;
-
-                if (profile->nPortIndex != kInputPortIndex) {
-                    return OMX_ErrorUndefined;
-                }
-
-                CHECK(!isConfigured());
-
-                profile->eCodecId = 0; 
-                profile->nChannels = 0;
-                profile->nBitRate = 0;
-                profile->nBitsPerSample = 0;
-                profile->nSampleRate = 0;
-                profile->nBlockAlign = 0;
-                profile->eSampleFormat = 0;
-
-                return OMX_ErrorNone;
+        case OMX_IndexParamAudioFFmpeg:
+        {
+            OMX_AUDIO_PARAM_FFMPEGTYPE *profile =
+                (OMX_AUDIO_PARAM_FFMPEGTYPE *)params;
+
+            if (profile->nPortIndex != kInputPortIndex) {
+                return OMX_ErrorUndefined;
             }
 
+            CHECK(!isConfigured());
+
+            profile->eCodecId = 0;
+            profile->nChannels = 0;
+            profile->nBitRate = 0;
+            profile->nBitsPerSample = 0;
+            profile->nSampleRate = 0;
+            profile->nBlockAlign = 0;
+            profile->eSampleFormat = 0;
+
+            return OMX_ErrorNone;
+        }
+
+        default:
+
             return SimpleSoftOMXComponent::internalGetParameter(index, params);
     }
 }
@@ -802,11 +801,11 @@ OMX_ERRORTYPE SoftFFmpegAudio::internalSetParameter(
             CHECK(!isConfigured());
 
             if (profile->eFormat == OMX_AUDIO_WMAFormat7) {
-               mCtx->codec_id = CODEC_ID_WMAV2;
+               mCtx->codec_id = AV_CODEC_ID_WMAV2;
             } else if (profile->eFormat == OMX_AUDIO_WMAFormat8) {
-               mCtx->codec_id = CODEC_ID_WMAPRO;
+               mCtx->codec_id = AV_CODEC_ID_WMAPRO;
             } else if (profile->eFormat == OMX_AUDIO_WMAFormat9) {
-               mCtx->codec_id = CODEC_ID_WMALOSSLESS;
+               mCtx->codec_id = AV_CODEC_ID_WMALOSSLESS;
             } else {
                 ALOGE("unsupported wma codec: 0x%x", profile->eFormat);
                 return OMX_ErrorUndefined;
@@ -971,42 +970,42 @@ OMX_ERRORTYPE SoftFFmpegAudio::internalSetParameter(
             return OMX_ErrorNone;
         }
 
-        default:
-            if ((OMX_FF_INDEXTYPE)index == OMX_IndexParamAudioFFmpeg)
-            {
-                OMX_AUDIO_PARAM_FFMPEGTYPE *profile =
-                    (OMX_AUDIO_PARAM_FFMPEGTYPE *)params;
-
-                if (profile->nPortIndex != kInputPortIndex) {
-                    return OMX_ErrorUndefined;
-                }
-
-                CHECK(!isConfigured());
-
-
-                mCtx->codec_id = (enum AVCodecID)profile->eCodecId; 
-                mCtx->channels = profile->nChannels;
-                mCtx->bit_rate = profile->nBitRate;
-                mCtx->bits_per_coded_sample = profile->nBitsPerSample;
-                mCtx->sample_rate = profile->nSampleRate;
-                mCtx->block_align = profile->nBlockAlign;
-                mCtx->sample_fmt = (AVSampleFormat)profile->eSampleFormat;
-
-                adjustAudioParams();
-
-                ALOGD("set OMX_IndexParamAudioFFmpeg, "
-                    "eCodecId:%ld(%s), nChannels:%lu, nBitRate:%lu, "
-                    "nBitsPerSample:%lu, nSampleRate:%lu, "
-                    "nBlockAlign:%lu, eSampleFormat:%lu(%s)",
-                    profile->eCodecId, avcodec_get_name(mCtx->codec_id),
-                    profile->nChannels, profile->nBitRate,
-                    profile->nBitsPerSample, profile->nSampleRate,
-                    profile->nBlockAlign, profile->eSampleFormat,
-                    av_get_sample_fmt_name(mCtx->sample_fmt));
-
-                return OMX_ErrorNone;
+        case OMX_IndexParamAudioFFmpeg:
+        {
+            OMX_AUDIO_PARAM_FFMPEGTYPE *profile =
+                (OMX_AUDIO_PARAM_FFMPEGTYPE *)params;
+
+            if (profile->nPortIndex != kInputPortIndex) {
+                return OMX_ErrorUndefined;
             }
 
+            CHECK(!isConfigured());
+
+
+            mCtx->codec_id = (enum AVCodecID)profile->eCodecId;
+            mCtx->channels = profile->nChannels;
+            mCtx->bit_rate = profile->nBitRate;
+            mCtx->bits_per_coded_sample = profile->nBitsPerSample;
+            mCtx->sample_rate = profile->nSampleRate;
+            mCtx->block_align = profile->nBlockAlign;
+            mCtx->sample_fmt = (AVSampleFormat)profile->eSampleFormat;
+
+            adjustAudioParams();
+
+            ALOGD("set OMX_IndexParamAudioFFmpeg, "
+                "eCodecId:%ld(%s), nChannels:%lu, nBitRate:%lu, "
+                "nBitsPerSample:%lu, nSampleRate:%lu, "
+                "nBlockAlign:%lu, eSampleFormat:%lu(%s)",
+                profile->eCodecId, avcodec_get_name(mCtx->codec_id),
+                profile->nChannels, profile->nBitRate,
+                profile->nBitsPerSample, profile->nSampleRate,
+                profile->nBlockAlign, profile->eSampleFormat,
+                av_get_sample_fmt_name(mCtx->sample_fmt));
+            return OMX_ErrorNone;
+        }
+
+        default:
+
             return SimpleSoftOMXComponent::internalSetParameter(index, params);
     }
 }

diff --git a/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.cpp b/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.cpp
index 27deca4..d6d79c5 100644 (file)
--- a/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.cpp
+++ b/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.cpp
@@ -24,8 +24,6 @@
 #include <media/stagefright/foundation/hexdump.h>
 #include <media/stagefright/MediaDefs.h>
 
-#include <OMX_FFExt.h>
-
 #include "utils/ffmpeg_utils.h"
 
 #define DEBUG_PKT 0
@@ -65,6 +63,8 @@ void SoftFFmpegVideo::setMode(const char *name) {
         mMode = MODE_FLV1;
     } else if (!strcmp(name, "OMX.ffmpeg.divx.decoder")) {
         mMode = MODE_DIVX;
+    } else if (!strcmp(name, "OMX.ffmpeg.hevc.decoder")) {
+        mMode = MODE_HEVC;
     } else if (!strcmp(name, "OMX.ffmpeg.vtrial.decoder")) {
         mMode = MODE_TRIAL;
     } else {
@@ -154,6 +154,10 @@ void SoftFFmpegVideo::initInputFormat(uint32_t mode,
         def.format.video.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_VIDEO_DIVX);
         def.format.video.eCompressionFormat = OMX_VIDEO_CodingDIVX;
         break;
+    case MODE_HEVC:
+        def.format.video.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_VIDEO_HEVC);
+        def.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+        break;
     case MODE_TRIAL:
         def.format.video.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_VIDEO_FFMPEG);
         def.format.video.eCompressionFormat = OMX_VIDEO_CodingAutoDetect;
@@ -264,40 +268,43 @@ status_t SoftFFmpegVideo::initDecoder() {
     mCtx->codec_type = AVMEDIA_TYPE_VIDEO;
     switch (mMode) {
     case MODE_MPEG2:
-        mCtx->codec_id = CODEC_ID_MPEG2VIDEO;
+        mCtx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
         break;
     case MODE_H263:
-        mCtx->codec_id = CODEC_ID_H263;
+        mCtx->codec_id = AV_CODEC_ID_H263;
         //FIXME, which?
-        //mCtx->codec_id = CODEC_ID_H263P;
-        //mCtx->codec_id = CODEC_ID_H263I;
+        //mCtx->codec_id = AV_CODEC_ID_H263P;
+        //mCtx->codec_id = AV_CODEC_ID_H263I;
         break;
     case MODE_MPEG4:
-        mCtx->codec_id = CODEC_ID_MPEG4;
+        mCtx->codec_id = AV_CODEC_ID_MPEG4;
         break;
     case MODE_WMV:
-        mCtx->codec_id = CODEC_ID_WMV2;        // default, adjust in "internalSetParameter" fxn
+        mCtx->codec_id = AV_CODEC_ID_WMV2;     // default, adjust in "internalSetParameter" fxn
         break;
     case MODE_RV:
-        mCtx->codec_id = CODEC_ID_RV40;        // default, adjust in "internalSetParameter" fxn
+        mCtx->codec_id = AV_CODEC_ID_RV40;     // default, adjust in "internalSetParameter" fxn
         break;
     case MODE_H264:
-        mCtx->codec_id = CODEC_ID_H264;
+        mCtx->codec_id = AV_CODEC_ID_H264;
         break;
     case MODE_VPX:
-        mCtx->codec_id = CODEC_ID_VP8;
+        mCtx->codec_id = AV_CODEC_ID_VP8;
         break;
     case MODE_VC1:
-        mCtx->codec_id = CODEC_ID_VC1;
+        mCtx->codec_id = AV_CODEC_ID_VC1;
         break;
     case MODE_FLV1:
-        mCtx->codec_id = CODEC_ID_FLV1;
+        mCtx->codec_id = AV_CODEC_ID_FLV1;
         break;
     case MODE_DIVX:
-        mCtx->codec_id = CODEC_ID_MPEG4;
+        mCtx->codec_id = AV_CODEC_ID_MPEG4;
+        break;
+    case MODE_HEVC:
+        mCtx->codec_id = AV_CODEC_ID_HEVC;
         break;
     case MODE_TRIAL:
-        mCtx->codec_id = CODEC_ID_NONE;
+        mCtx->codec_id = AV_CODEC_ID_NONE;
         break;
     default:
         CHECK(!"Should not be here. Unsupported codec");
@@ -371,6 +378,9 @@ void SoftFFmpegVideo::getInputFormat(uint32_t mode,
     case MODE_DIVX:
         formatParams->eCompressionFormat = OMX_VIDEO_CodingDIVX;
         break;
+    case MODE_HEVC:
+        formatParams->eCompressionFormat = OMX_VIDEO_CodingHEVC;
+        break;
     case MODE_TRIAL:
         formatParams->eCompressionFormat = OMX_VIDEO_CodingAutoDetect;
         break;
@@ -440,22 +450,23 @@ OMX_ERRORTYPE SoftFFmpegVideo::internalGetParameter(
             return OMX_ErrorNone;
         }
 
-        default:
-            if ((OMX_FF_INDEXTYPE)index == OMX_IndexParamVideoFFmpeg)
-            {
-                OMX_VIDEO_PARAM_FFMPEGTYPE *ffmpegParams =
-                    (OMX_VIDEO_PARAM_FFMPEGTYPE *)params;
+               case OMX_IndexParamVideoFFmpeg:
+        {
+            OMX_VIDEO_PARAM_FFMPEGTYPE *profile =
+                (OMX_VIDEO_PARAM_FFMPEGTYPE *)params;
 
-                if (ffmpegParams->nPortIndex != kInputPortIndex) {
-                    return OMX_ErrorUndefined;
-                }
+            if (profile->nPortIndex != kInputPortIndex) {
+                return OMX_ErrorUndefined;
+            }
 
-                ffmpegParams->eCodecId = CODEC_ID_NONE;
-                ffmpegParams->nWidth   = 0;
-                ffmpegParams->nHeight  = 0;
+            profile->eCodecId = AV_CODEC_ID_NONE;
+            profile->nWidth   = 0;
+            profile->nHeight  = 0;
 
-                return OMX_ErrorNone;
-            }
+            return OMX_ErrorNone;
+        }
+
+        default:
 
             return SimpleSoftOMXComponent::internalGetParameter(index, params);
     }
@@ -516,6 +527,11 @@ OMX_ERRORTYPE SoftFFmpegVideo::isRoleSupported(
                 "video_decoder.divx", OMX_MAX_STRINGNAME_SIZE - 1))
             supported = false;
             break;
+    case MODE_HEVC:
+        if (strncmp((const char *)roleParams->cRole,
+                "video_decoder.hevc", OMX_MAX_STRINGNAME_SIZE - 1))
+            supported = false;
+            break;
     case MODE_TRIAL:
         if (strncmp((const char *)roleParams->cRole,
                 "video_decoder.trial", OMX_MAX_STRINGNAME_SIZE - 1))
@@ -595,11 +611,11 @@ OMX_ERRORTYPE SoftFFmpegVideo::internalSetParameter(
             }
 
             if (profile->eFormat == OMX_VIDEO_WMVFormat7) {
-                mCtx->codec_id = CODEC_ID_WMV1;
+                mCtx->codec_id = AV_CODEC_ID_WMV1;
             } else if (profile->eFormat == OMX_VIDEO_WMVFormat8) {
-                mCtx->codec_id = CODEC_ID_WMV2;
+                mCtx->codec_id = AV_CODEC_ID_WMV2;
             } else if (profile->eFormat == OMX_VIDEO_WMVFormat9) {
-                mCtx->codec_id = CODEC_ID_WMV3;
+                mCtx->codec_id = AV_CODEC_ID_WMV3;
             } else {
                 ALOGE("unsupported wmv codec: 0x%x", profile->eFormat);
                 return OMX_ErrorUndefined;
@@ -618,11 +634,11 @@ OMX_ERRORTYPE SoftFFmpegVideo::internalSetParameter(
             }
 
             if (profile->eFormat == OMX_VIDEO_RVFormatG2) {
-                mCtx->codec_id = CODEC_ID_RV20;
+                mCtx->codec_id = AV_CODEC_ID_RV20;
             } else if (profile->eFormat == OMX_VIDEO_RVFormat8) {
-                mCtx->codec_id = CODEC_ID_RV30;
+                mCtx->codec_id = AV_CODEC_ID_RV30;
             } else if (profile->eFormat == OMX_VIDEO_RVFormat9) {
-                mCtx->codec_id = CODEC_ID_RV40;
+                mCtx->codec_id = AV_CODEC_ID_RV40;
             } else {
                 ALOGE("unsupported rv codec: 0x%x", profile->eFormat);
                 return OMX_ErrorUndefined;
@@ -631,29 +647,30 @@ OMX_ERRORTYPE SoftFFmpegVideo::internalSetParameter(
             return OMX_ErrorNone;
         }
 
-        default:
-            if ((OMX_FF_INDEXTYPE)index == OMX_IndexParamVideoFFmpeg)
-            {
-                OMX_VIDEO_PARAM_FFMPEGTYPE *ffmpegParams =
-                    (OMX_VIDEO_PARAM_FFMPEGTYPE *)params;
+        case OMX_IndexParamVideoFFmpeg:
+        {
+            OMX_VIDEO_PARAM_FFMPEGTYPE *profile =
+                (OMX_VIDEO_PARAM_FFMPEGTYPE *)params;
 
-                if (ffmpegParams->nPortIndex != kInputPortIndex) {
-                    return OMX_ErrorUndefined;
-                }
+            if (profile->nPortIndex != kInputPortIndex) {
+                return OMX_ErrorUndefined;
+            }
 
-                mCtx->codec_id = (enum AVCodecID)ffmpegParams->eCodecId;
-                mCtx->width    = ffmpegParams->nWidth;
-                mCtx->height   = ffmpegParams->nHeight;
+            mCtx->codec_id = (enum AVCodecID)profile->eCodecId;
+            mCtx->width    = profile->nWidth;
+            mCtx->height   = profile->nHeight;
 
-                ALOGD("got OMX_IndexParamVideoFFmpeg, "
-                    "eCodecId:%ld(%s), width:%lu, height:%lu",
-                    ffmpegParams->eCodecId,
-                    avcodec_get_name(mCtx->codec_id),
-                    ffmpegParams->nWidth,
-                    ffmpegParams->nHeight); 
+            ALOGD("got OMX_IndexParamVideoFFmpeg, "
+                "eCodecId:%ld(%s), width:%lu, height:%lu",
+                profile->eCodecId,
+                avcodec_get_name(mCtx->codec_id),
+                profile->nWidth,
+                profile->nHeight);
 
-                return OMX_ErrorNone;
-            }
+            return OMX_ErrorNone;
+        }
+
+        default:
 
             return SimpleSoftOMXComponent::internalSetParameter(index, params);
     }

diff --git a/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.h b/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.h
index 653c948..cfb3d53 100644 (file)
--- a/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.h
+++ b/libstagefright/codecs/ffmpegdec/vdec/SoftFFmpegVideo.h
@@ -91,6 +91,7 @@ private:
         MODE_VC1,
         MODE_FLV1,
         MODE_DIVX,
+        MODE_HEVC,
         MODE_TRIAL
     } mMode;
 

diff --git a/tools/set-vdec-drop0 b/tools/set-vdec-drop0
new file mode 100755 (executable)
index 0000000..29023cb
--- /dev/null
+++ b/tools/set-vdec-drop0
@@ -0,0 +1,4 @@
+#!/system/bin/sh
+
+setprop sys.media.vdec.drop 0
+

diff --git a/tools/set-vdec-drop1 b/tools/set-vdec-drop1
new file mode 100755 (executable)
index 0000000..6452e68
--- /dev/null
+++ b/tools/set-vdec-drop1
@@ -0,0 +1,4 @@
+#!/system/bin/sh
+
+setprop sys.media.vdec.drop 1
+

diff --git a/utils/ffmpeg_utils.cpp b/utils/ffmpeg_utils.cpp
index 46f3d9e..5ad31e5 100644 (file)
--- a/utils/ffmpeg_utils.cpp
+++ b/utils/ffmpeg_utils.cpp
@@ -354,10 +354,10 @@ int parser_split(AVCodecContext *avctx,
         return 0;
     }
 
-    if (avctx->codec_id == CODEC_ID_H264) {
+    if (avctx->codec_id == AV_CODEC_ID_H264) {
         return h264_split(avctx, buf, buf_size, 0);
-    } else if (avctx->codec_id == CODEC_ID_MPEG2VIDEO ||
-            avctx->codec_id == CODEC_ID_MPEG4) {
+    } else if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
+            avctx->codec_id == AV_CODEC_ID_MPEG4) {
         return mpegvideo_split(avctx, buf, buf_size, 0);
     } else {
         ALOGE("parser split, unsupport the codec, id: 0x%0x", avctx->codec_id);
@@ -374,7 +374,7 @@ int is_extradata_compatible_with_android(AVCodecContext *avctx)
         return 0;
     }
 
-    if (avctx->codec_id == CODEC_ID_H264
+    if (avctx->codec_id == AV_CODEC_ID_H264
                        && avctx->extradata[0] != 1 /* configurationVersion */) {
         // SPS + PPS
         return !!(h264_split(avctx, avctx->extradata,