History

avcodec/mediacodec_wrapper: link to NDK mediacodec API directly

Drop support of Android version before 5.0.

Zhao Zhili committed 2 years ago

Commit 98b5e801 parent 309cff32 files · +36 −130Browse files

Unified · Split

2 files
  1. configure +1 −1
  2. libavcodec/mediacodec_wrapper.c +35 −129
configure+1−1
@@ -3133,7 +3133,7 @@ d3d11va_deps="dxva_h ID3D11VideoDecoder ID3D11VideoContext" · 3132 unmodified lines
31333133 d3d12va_deps="dxva_h ID3D12Device ID3D12VideoDecoder"
31343134 dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32 user32"
31353135 ffnvcodec_deps_any="libdl LoadLibrary"
3136−mediacodec_deps="android"
3136+mediacodec_deps="android mediandk"
31373137 nvdec_deps="ffnvcodec"
31383138 vaapi_x11_deps="xlib_x11"
31393139 videotoolbox_hwaccel_deps="videotoolbox pthreads"
libavcodec/mediacodec_wrapper.c+35−129
@@ -1828,25 +1828,8 @@ typedef struct FFAMediaFormatNdk { · 1827 unmodified lines
18281828 void *libmedia;
18291829 AMediaFormat *impl;
18301830
1831− AMediaFormat *(*new)(void);
1832− media_status_t (*delete)(AMediaFormat*);
1833−
1834− const char* (*toString)(AMediaFormat*);
1835−
1836− bool (*getInt32)(AMediaFormat*, const char *name, int32_t *out);
1837− bool (*getInt64)(AMediaFormat*, const char *name, int64_t *out);
1838− bool (*getFloat)(AMediaFormat*, const char *name, float *out);
1839− bool (*getSize)(AMediaFormat*, const char *name, size_t *out);
1840− bool (*getBuffer)(AMediaFormat*, const char *name, void** data, size_t *size);
1841− bool (*getString)(AMediaFormat*, const char *name, const char **out);
18421831 bool (*getRect)(AMediaFormat *, const char *name,
18431832 int32_t *left, int32_t *top, int32_t *right, int32_t *bottom);
1844−
1845− void (*setInt32)(AMediaFormat*, const char* name, int32_t value);
1846− void (*setInt64)(AMediaFormat*, const char* name, int64_t value);
1847− void (*setFloat)(AMediaFormat*, const char* name, float value);
1848− void (*setString)(AMediaFormat*, const char* name, const char* value);
1849− void (*setBuffer)(AMediaFormat*, const char* name, const void* data, size_t size);
18501833 void (*setRect)(AMediaFormat *, const char *name,
18511834 int32_t left, int32_t top, int32_t right, int32_t bottom);
18521835 } FFAMediaFormatNdk;
@@ -1858,34 +1841,6 @@ typedef struct FFAMediaCodecNdk { · 5 unmodified lines
18581841 AMediaCodec *impl;
18591842 ANativeWindow *window;
18601843
1861− AMediaCodec* (*createCodecByName)(const char *name);
1862− AMediaCodec* (*createDecoderByType)(const char *mime_type);
1863− AMediaCodec* (*createEncoderByType)(const char *mime_type);
1864− media_status_t (*delete)(AMediaCodec*);
1865−
1866− media_status_t (*configure)(AMediaCodec *,
1867− const AMediaFormat *format,
1868− ANativeWindow *surface,
1869− AMediaCrypto *crypto,
1870− uint32_t flags);
1871− media_status_t (*start)(AMediaCodec*);
1872− media_status_t (*stop)(AMediaCodec*);
1873− media_status_t (*flush)(AMediaCodec*);
1874−
1875− uint8_t* (*getInputBuffer)(AMediaCodec*, size_t idx, size_t *out_size);
1876− uint8_t* (*getOutputBuffer)(AMediaCodec*, size_t idx, size_t *out_size);
1877−
1878− ssize_t (*dequeueInputBuffer)(AMediaCodec*, int64_t timeoutUs);
1879− media_status_t (*queueInputBuffer)(AMediaCodec*, size_t idx,
1880− long offset, size_t size,
1881− uint64_t time, uint32_t flags);
1882−
1883− ssize_t (*dequeueOutputBuffer)(AMediaCodec*, AMediaCodecBufferInfo *info, int64_t timeoutUs);
1884− AMediaFormat* (*getOutputFormat)(AMediaCodec*);
1885−
1886− media_status_t (*releaseOutputBuffer)(AMediaCodec*, size_t idx, bool render);
1887− media_status_t (*releaseOutputBufferAtTime)(AMediaCodec *mData, size_t idx, int64_t timestampNs);
1888−
18891844 // Available since API level 28.
18901845 media_status_t (*getName)(AMediaCodec*, char** out_name);
18911846 void (*releaseName)(AMediaCodec*, char* name);
@@ -1925,38 +1880,15 @@ static FFAMediaFormat *mediaformat_ndk_create(AMediaFormat *impl) · 33 unmodified lines
19251880 #define GET_OPTIONAL_SYMBOL(sym) \
19261881 format->sym = dlsym(format->libmedia, "AMediaFormat_" #sym);
19271882
1928−#define GET_SYMBOL(sym) \
1929− GET_OPTIONAL_SYMBOL(sym) \
1930− if (!format->sym) \
1931− goto error;
1932−
1933− GET_SYMBOL(new)
1934− GET_SYMBOL(delete)
1935−
1936− GET_SYMBOL(toString)
1937−
1938− GET_SYMBOL(getInt32)
1939− GET_SYMBOL(getInt64)
1940− GET_SYMBOL(getFloat)
1941− GET_SYMBOL(getSize)
1942− GET_SYMBOL(getBuffer)
1943− GET_SYMBOL(getString)
19441883 GET_OPTIONAL_SYMBOL(getRect)
1945−
1946− GET_SYMBOL(setInt32)
1947− GET_SYMBOL(setInt64)
1948− GET_SYMBOL(setFloat)
1949− GET_SYMBOL(setString)
1950− GET_SYMBOL(setBuffer)
19511884 GET_OPTIONAL_SYMBOL(setRect)
19521885
1953−#undef GET_SYMBOL
19541886 #undef GET_OPTIONAL_SYMBOL
19551887
19561888 if (impl) {
19571889 format->impl = impl;
19581890 } else {
1959− format->impl = format->new();
1891+ format->impl = AMediaFormat_new();
19601892 if (!format->impl)
19611893 goto error;
19621894 }
@@ -1984,7 +1916,7 @@ static int mediaformat_ndk_delete(FFAMediaFormat* ctx) · 21 unmodified lines
19841916
19851917 av_assert0(format->api.class == &amediaformat_ndk_class);
19861918
1987− if (format->impl && (format->delete(format->impl) != AMEDIA_OK))
1919+ if (format->impl && (AMediaFormat_delete(format->impl) != AMEDIA_OK))
19881920 ret = AVERROR_EXTERNAL;
19891921 if (format->libmedia)
19901922 dlclose(format->libmedia);
@@ -1996,39 +1928,39 @@ static int mediaformat_ndk_delete(FFAMediaFormat* ctx) · 5 unmodified lines
19961928 static char* mediaformat_ndk_toString(FFAMediaFormat* ctx)
19971929 {
19981930 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
1999− const char *str = format->toString(format->impl);
1931+ const char *str = AMediaFormat_toString(format->impl);
20001932 return av_strdup(str);
20011933 }
20021934
20031935 static int mediaformat_ndk_getInt32(FFAMediaFormat* ctx, const char *name, int32_t *out)
20041936 {
20051937 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2006− return format->getInt32(format->impl, name, out);
1938+ return AMediaFormat_getInt32(format->impl, name, out);
20071939 }
20081940
20091941 static int mediaformat_ndk_getInt64(FFAMediaFormat* ctx, const char *name, int64_t *out)
20101942 {
20111943 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2012− return format->getInt64(format->impl, name, out);
1944+ return AMediaFormat_getInt64(format->impl, name, out);
20131945 }
20141946
20151947 static int mediaformat_ndk_getFloat(FFAMediaFormat* ctx, const char *name, float *out)
20161948 {
20171949 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2018− return format->getFloat(format->impl, name, out);
1950+ return AMediaFormat_getFloat(format->impl, name, out);
20191951 }
20201952
20211953 static int mediaformat_ndk_getBuffer(FFAMediaFormat* ctx, const char *name, void** data, size_t *size)
20221954 {
20231955 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2024− return format->getBuffer(format->impl, name, data, size);
1956+ return AMediaFormat_getBuffer(format->impl, name, data, size);
20251957 }
20261958
20271959 static int mediaformat_ndk_getString(FFAMediaFormat* ctx, const char *name, const char **out)
20281960 {
20291961 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
20301962 const char *tmp = NULL;
2031− int ret = format->getString(format->impl, name, &tmp);
1963+ int ret = AMediaFormat_getString(format->impl, name, &tmp);
20321964
20331965 if (tmp)
20341966 *out = av_strdup(tmp);
@@ -2047,31 +1979,31 @@ static int mediaformat_ndk_getRect(FFAMediaFormat *ctx, const char *name, · 12 unmodified lines
20471979 static void mediaformat_ndk_setInt32(FFAMediaFormat* ctx, const char* name, int32_t value)
20481980 {
20491981 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2050− format->setInt32(format->impl, name, value);
1982+ AMediaFormat_setInt32(format->impl, name, value);
20511983 }
20521984
20531985 static void mediaformat_ndk_setInt64(FFAMediaFormat* ctx, const char* name, int64_t value)
20541986 {
20551987 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2056− format->setInt64(format->impl, name, value);
1988+ AMediaFormat_setInt64(format->impl, name, value);
20571989 }
20581990
20591991 static void mediaformat_ndk_setFloat(FFAMediaFormat* ctx, const char* name, float value)
20601992 {
20611993 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2062− format->setFloat(format->impl, name, value);
1994+ AMediaFormat_setFloat(format->impl, name, value);
20631995 }
20641996
20651997 static void mediaformat_ndk_setString(FFAMediaFormat* ctx, const char* name, const char* value)
20661998 {
20671999 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2068− format->setString(format->impl, name, value);
2000+ AMediaFormat_setString(format->impl, name, value);
20692001 }
20702002
20712003 static void mediaformat_ndk_setBuffer(FFAMediaFormat* ctx, const char* name, void* data, size_t size)
20722004 {
20732005 FFAMediaFormatNdk *format = (FFAMediaFormatNdk *)ctx;
2074− format->setBuffer(format->impl, name, data, size);
2006+ AMediaFormat_setBuffer(format->impl, name, data, size);
20752007 }
20762008
20772009 static void mediaformat_ndk_setRect(FFAMediaFormat *ctx, const char *name,
@@ -2117,54 +2049,28 @@ static inline FFAMediaCodec *ndk_codec_create(int method, const char *arg) { · 39 unmodified lines
21172049 if (!codec->libmedia)
21182050 goto error;
21192051
2120−#define GET_SYMBOL(sym, required) \
2052+#define GET_SYMBOL(sym) \
21212053 codec->sym = dlsym(codec->libmedia, "AMediaCodec_" #sym); \
2122− if (!codec->sym) { \
2123− av_log(codec, required ? AV_LOG_ERROR : AV_LOG_INFO, \
2124− #sym "() unavailable from %s\n", lib_name); \
2125− if (required) \
2126− goto error; \
2127− }
2128−
2129− GET_SYMBOL(createCodecByName, 1)
2130− GET_SYMBOL(createDecoderByType, 1)
2131− GET_SYMBOL(createEncoderByType, 1)
2132− GET_SYMBOL(delete, 1)
2133−
2134− GET_SYMBOL(configure, 1)
2135− GET_SYMBOL(start, 1)
2136− GET_SYMBOL(stop, 1)
2137− GET_SYMBOL(flush, 1)
2138−
2139− GET_SYMBOL(getInputBuffer, 1)
2140− GET_SYMBOL(getOutputBuffer, 1)
2141−
2142− GET_SYMBOL(dequeueInputBuffer, 1)
2143− GET_SYMBOL(queueInputBuffer, 1)
2144−
2145− GET_SYMBOL(dequeueOutputBuffer, 1)
2146− GET_SYMBOL(getOutputFormat, 1)
2147−
2148− GET_SYMBOL(releaseOutputBuffer, 1)
2149− GET_SYMBOL(releaseOutputBufferAtTime, 1)
2054+ if (!codec->sym) \
2055+ av_log(codec, AV_LOG_INFO, #sym "() unavailable from %s\n", lib_name);
21502056
2151− GET_SYMBOL(getName, 0)
2152− GET_SYMBOL(releaseName, 0)
2057+ GET_SYMBOL(getName)
2058+ GET_SYMBOL(releaseName)
21532059
2154− GET_SYMBOL(setInputSurface, 0)
2155− GET_SYMBOL(signalEndOfInputStream, 0)
2060+ GET_SYMBOL(setInputSurface)
2061+ GET_SYMBOL(signalEndOfInputStream)
21562062
21572063 #undef GET_SYMBOL
21582064
21592065 switch (method) {
21602066 case CREATE_CODEC_BY_NAME:
2161− codec->impl = codec->createCodecByName(arg);
2067+ codec->impl = AMediaCodec_createCodecByName(arg);
21622068 break;
21632069 case CREATE_DECODER_BY_TYPE:
2164− codec->impl = codec->createDecoderByType(arg);
2070+ codec->impl = AMediaCodec_createDecoderByType(arg);
21652071 break;
21662072 case CREATE_ENCODER_BY_TYPE:
2167− codec->impl = codec->createEncoderByType(arg);
2073+ codec->impl = AMediaCodec_createEncoderByType(arg);
21682074 break;
21692075 default:
21702076 av_assert0(0);
@@ -2201,7 +2107,7 @@ static int mediacodec_ndk_delete(FFAMediaCodec* ctx) · 30 unmodified lines
22012107
22022108 av_assert0(codec->api.class == &amediacodec_ndk_class);
22032109
2204− if (codec->impl && (codec->delete(codec->impl) != AMEDIA_OK))
2110+ if (codec->impl && (AMediaCodec_delete(codec->impl) != AMEDIA_OK))
22052111 ret = AVERROR_EXTERNAL;
22062112 if (codec->window)
22072113 ANativeWindow_release(codec->window);
@@ -2246,7 +2152,7 @@ static int mediacodec_ndk_configure(FFAMediaCodec* ctx, · 38 unmodified lines
22462152 return AVERROR_EXTERNAL;
22472153 }
22482154
2249− status = codec->configure(codec->impl, format->impl, NULL, NULL, flags);
2155+ status = AMediaCodec_configure(codec->impl, format->impl, NULL, NULL, flags);
22502156 if (status != AMEDIA_OK) {
22512157 av_log(codec, AV_LOG_ERROR, "Encoder configure failed, %d\n", status);
22522158 return AVERROR_EXTERNAL;
@@ -2261,7 +2167,7 @@ static int mediacodec_ndk_configure(FFAMediaCodec* ctx, · 8 unmodified lines
22612167 return AVERROR_EXTERNAL;
22622168 }
22632169 } else {
2264− status = codec->configure(codec->impl, format->impl, native_window, NULL, flags);
2170+ status = AMediaCodec_configure(codec->impl, format->impl, native_window, NULL, flags);
22652171 if (status != AMEDIA_OK) {
22662172 av_log(codec, AV_LOG_ERROR, "Decoder configure failed, %d\n", status);
22672173 return AVERROR_EXTERNAL;
@@ -2275,7 +2181,7 @@ static int mediacodec_ndk_configure(FFAMediaCodec* ctx, · 7 unmodified lines
22752181 static int mediacodec_ndk_ ## method(FFAMediaCodec* ctx) \
22762182 { \
22772183 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx; \
2278− media_status_t status = codec->method(codec->impl); \
2184+ media_status_t status = AMediaCodec_ ## method (codec->impl); \
22792185 \
22802186 if (status != AMEDIA_OK) { \
22812187 av_log(codec, AV_LOG_ERROR, #method " failed, %d\n", status); \
@@ -2292,19 +2198,19 @@ MEDIACODEC_NDK_WRAPPER(flush) · 10 unmodified lines
22922198 static uint8_t* mediacodec_ndk_getInputBuffer(FFAMediaCodec* ctx, size_t idx, size_t *out_size)
22932199 {
22942200 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
2295− return codec->getInputBuffer(codec->impl, idx, out_size);
2201+ return AMediaCodec_getInputBuffer(codec->impl, idx, out_size);
22962202 }
22972203
22982204 static uint8_t* mediacodec_ndk_getOutputBuffer(FFAMediaCodec* ctx, size_t idx, size_t *out_size)
22992205 {
23002206 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
2301− return codec->getOutputBuffer(codec->impl, idx, out_size);
2207+ return AMediaCodec_getOutputBuffer(codec->impl, idx, out_size);
23022208 }
23032209
23042210 static ssize_t mediacodec_ndk_dequeueInputBuffer(FFAMediaCodec* ctx, int64_t timeoutUs)
23052211 {
23062212 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
2307− return codec->dequeueInputBuffer(codec->impl, timeoutUs);
2213+ return AMediaCodec_dequeueInputBuffer(codec->impl, timeoutUs);
23082214 }
23092215
23102216 static int mediacodec_ndk_queueInputBuffer(FFAMediaCodec *ctx, size_t idx,
@@ -2312,7 +2218,7 @@ static int mediacodec_ndk_queueInputBuffer(FFAMediaCodec *ctx, size_t idx, · 1 unmodified line
23122218 uint64_t time, uint32_t flags)
23132219 {
23142220 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
2315− return codec->queueInputBuffer(codec->impl, idx, offset, size, time, flags);
2221+ return AMediaCodec_queueInputBuffer(codec->impl, idx, offset, size, time, flags);
23162222 }
23172223
23182224 static ssize_t mediacodec_ndk_dequeueOutputBuffer(FFAMediaCodec* ctx, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)
@@ -2321,7 +2227,7 @@ static ssize_t mediacodec_ndk_dequeueOutputBuffer(FFAMediaCodec* ctx, FFAMediaCo · 2 unmodified lines
23212227 AMediaCodecBufferInfo buf_info = {0};
23222228 ssize_t ret;
23232229
2324− ret = codec->dequeueOutputBuffer(codec->impl, &buf_info, timeoutUs);
2230+ ret = AMediaCodec_dequeueOutputBuffer(codec->impl, &buf_info, timeoutUs);
23252231 info->offset = buf_info.offset;
23262232 info->size = buf_info.size;
23272233 info->presentationTimeUs = buf_info.presentationTimeUs;
@@ -2333,7 +2239,7 @@ static ssize_t mediacodec_ndk_dequeueOutputBuffer(FFAMediaCodec* ctx, FFAMediaCo · 5 unmodified lines
23332239 static FFAMediaFormat* mediacodec_ndk_getOutputFormat(FFAMediaCodec* ctx)
23342240 {
23352241 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
2336− AMediaFormat *format = codec->getOutputFormat(codec->impl);
2242+ AMediaFormat *format = AMediaCodec_getOutputFormat(codec->impl);
23372243
23382244 if (!format)
23392245 return NULL;
@@ -2345,7 +2251,7 @@ static int mediacodec_ndk_releaseOutputBuffer(FFAMediaCodec* ctx, size_t idx, in · 5 unmodified lines
23452251 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
23462252 media_status_t status;
23472253
2348− status = codec->releaseOutputBuffer(codec->impl, idx, render);
2254+ status = AMediaCodec_releaseOutputBuffer(codec->impl, idx, render);
23492255 if (status != AMEDIA_OK) {
23502256 av_log(codec, AV_LOG_ERROR, "release output buffer failed, %d\n", status);
23512257 return AVERROR_EXTERNAL;
@@ -2359,7 +2265,7 @@ static int mediacodec_ndk_releaseOutputBufferAtTime(FFAMediaCodec *ctx, size_t i · 7 unmodified lines
23592265 FFAMediaCodecNdk *codec = (FFAMediaCodecNdk *)ctx;
23602266 media_status_t status;
23612267
2362− status = codec->releaseOutputBufferAtTime(codec->impl, idx, timestampNs);
2268+ status = AMediaCodec_releaseOutputBufferAtTime(codec->impl, idx, timestampNs);
23632269 if (status != AMEDIA_OK) {
23642270 av_log(codec, AV_LOG_ERROR, "releaseOutputBufferAtTime failed, %d\n", status);
23652271 return AVERROR_EXTERNAL;

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t