1. https://github.com/omxcodec/android_frameworks_native.git (branch:cm_maguro-10.1)
2. 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/*
<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 -->
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;
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",
return 1;
}
- if (codec_id == CODEC_ID_AAC) {
+ if (codec_id == AV_CODEC_ID_AAC) {
name = "aac_adtstoasc";
}
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;
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
meta = MakeAVCCodecSpecificData(buffer);
}
break;
- case CODEC_ID_MPEG4:
+ case AV_CODEC_ID_MPEG4:
ALOGV("MPEG4");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
{
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);
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));
}
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;
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);
{"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)
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;
} 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;
}
}
!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);
}
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/MediaDefs.h>
-#include <OMX_FFExt.h>
-
#include "utils/ffmpeg_utils.h"
#define DEBUG_PKT 0
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");
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);
}
}
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;
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);
}
}
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/MediaDefs.h>
-#include <OMX_FFExt.h>
-
#include "utils/ffmpeg_utils.h"
#define DEBUG_PKT 0
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 {
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;
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");
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;
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);
}
"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))
}
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;
}
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;
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);
}
MODE_VC1,
MODE_FLV1,
MODE_DIVX,
+ MODE_HEVC,
MODE_TRIAL
} mMode;
--- /dev/null
+#!/system/bin/sh
+
+setprop sys.media.vdec.drop 0
+
--- /dev/null
+#!/system/bin/sh
+
+setprop sys.media.vdec.drop 1
+
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);
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,