libavcodec/mediacodec_wrapper.h

   1 /*
   2  * Android MediaCodec Wrapper
   3  *
   4  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #ifndef AVCODEC_MEDIACODEC_WRAPPER_H
  24 #define AVCODEC_MEDIACODEC_WRAPPER_H
  25
  26 #include <stdint.h>
  27 #include <sys/types.h>
  28
  29 #include "avcodec.h"
  30 #include "mediacodec_surface.h"
  31
  32 /**
  33  * The following API around MediaCodec and MediaFormat is based on the
  34  * NDK one provided by Google since Android 5.0.
  35  *
  36  * Differences from the NDK API:
  37  *
  38  * Buffers returned by ff_AMediaFormat_toString and ff_AMediaFormat_getString
  39  * are newly allocated buffer and must be freed by the user after use.
  40  *
  41  * The MediaCrypto API is not implemented.
  42  *
  43  * ff_AMediaCodec_infoTryAgainLater, ff_AMediaCodec_infoOutputBuffersChanged,
  44  * ff_AMediaCodec_infoOutputFormatChanged, ff_AMediaCodec_cleanOutputBuffers
  45  * ff_AMediaCodec_getName and ff_AMediaCodec_getBufferFlagEndOfStream are not
  46  * part of the original NDK API and are convenience functions to hide JNI
  47  * implementation.
  48  *
  49  * The API around MediaCodecList is not part of the NDK (and is lacking as
  50  * we still need to retrieve the codec name to work around faulty decoders
  51  * and encoders).
  52  *
  53  * For documentation, please refers to NdkMediaCodec.h NdkMediaFormat.h and
  54  * http://developer.android.com/reference/android/media/MediaCodec.html.
  55  *
  56  */
  57
  58 int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx);
  59
  60 char *ff_AMediaCodecList_getCodecNameByType(const char *mime, int profile, int encoder, void *log_ctx);
  61
  62 typedef struct FFAMediaFormat FFAMediaFormat;
  63 struct FFAMediaFormat {
  64     const AVClass *class;
  65
  66     FFAMediaFormat *(*create)(void);
  67     int (*delete)(FFAMediaFormat *);
  68
  69     char* (*toString)(FFAMediaFormat* format);
  70
  71     int (*getInt32)(FFAMediaFormat* format, const char *name, int32_t *out);
  72     int (*getInt64)(FFAMediaFormat* format, const char *name, int64_t *out);
  73     int (*getFloat)(FFAMediaFormat* format, const char *name, float *out);
  74     int (*getBuffer)(FFAMediaFormat* format, const char *name, void** data, size_t *size);
  75     int (*getString)(FFAMediaFormat* format, const char *name, const char **out);
  76     // NDK only, introduced in API level 28
  77     int (*getRect)(FFAMediaFormat *, const char *name,
  78                    int32_t *left, int32_t *top, int32_t *right, int32_t *bottom);
  79
  80     void (*setInt32)(FFAMediaFormat* format, const char* name, int32_t value);
  81     void (*setInt64)(FFAMediaFormat* format, const char* name, int64_t value);
  82     void (*setFloat)(FFAMediaFormat* format, const char* name, float value);
  83     void (*setString)(FFAMediaFormat* format, const char* name, const char* value);
  84     void (*setBuffer)(FFAMediaFormat* format, const char* name, void* data, size_t size);
  85     // NDK only, introduced in API level 28
  86     void (*setRect)(FFAMediaFormat*, const char* name,
  87                     int32_t left, int32_t top, int32_t right, int32_t bottom);
  88 };
  89
  90 FFAMediaFormat *ff_AMediaFormat_new(int ndk);
  91
  92 static inline int ff_AMediaFormat_delete(FFAMediaFormat* format)
  93 {
  94     return format->delete(format);
  95 }
  96
  97 static inline char* ff_AMediaFormat_toString(FFAMediaFormat* format)
  98 {
  99     return format->toString(format);
 100 }
 101
 102 static inline int ff_AMediaFormat_getInt32(FFAMediaFormat* format, const char *name, int32_t *out)
 103 {
 104     return format->getInt32(format, name, out);
 105 }
 106
 107 static inline int ff_AMediaFormat_getInt64(FFAMediaFormat* format, const char *name, int64_t *out)
 108 {
 109     return format->getInt64(format, name, out);
 110 }
 111
 112 static inline int ff_AMediaFormat_getFloat(FFAMediaFormat* format, const char *name, float *out)
 113 {
 114     return format->getFloat(format, name, out);
 115 }
 116
 117 static inline int ff_AMediaFormat_getBuffer(FFAMediaFormat* format, const char *name, void** data, size_t *size)
 118 {
 119     return format->getBuffer(format, name, data, size);
 120 }
 121
 122 static inline int ff_AMediaFormat_getString(FFAMediaFormat* format, const char *name, const char **out)
 123 {
 124     return format->getString(format, name, out);
 125 }
 126
 127 static inline int ff_AMediaFormat_getRect(FFAMediaFormat *format, const char *name,
 128                                           int32_t *left, int32_t *top, int32_t *right, int32_t *bottom)
 129 {
 130     if (!format->getRect)
 131         return AVERROR_EXTERNAL;
 132     return format->getRect(format, name, left, top, right, bottom);
 133 }
 134
 135 static inline void ff_AMediaFormat_setInt32(FFAMediaFormat* format, const char* name, int32_t value)
 136 {
 137     format->setInt32(format, name, value);
 138 }
 139
 140 static inline void ff_AMediaFormat_setInt64(FFAMediaFormat* format, const char* name, int64_t value)
 141 {
 142     format->setInt64(format, name, value);
 143 }
 144
 145 static inline void ff_AMediaFormat_setFloat(FFAMediaFormat* format, const char* name, float value)
 146 {
 147     format->setFloat(format, name, value);
 148 }
 149
 150 static inline void ff_AMediaFormat_setString(FFAMediaFormat* format, const char* name, const char* value)
 151 {
 152     format->setString(format, name, value);
 153 }
 154
 155 static inline void ff_AMediaFormat_setBuffer(FFAMediaFormat* format, const char* name, void* data, size_t size)
 156 {
 157     format->setBuffer(format, name, data, size);
 158 }
 159
 160 static inline void ff_AMediaFormat_setRect(FFAMediaFormat* format, const char* name,
 161                                            int32_t left, int32_t top, int32_t right, int32_t bottom)
 162 {
 163     if (!format->setRect) {
 164         av_log(format, AV_LOG_WARNING, "Doesn't support setRect\n");
 165         return;
 166     }
 167     format->setRect(format, name, left, top, right, bottom);
 168 }
 169
 170 typedef struct FFAMediaCodecCryptoInfo FFAMediaCodecCryptoInfo;
 171
 172 struct FFAMediaCodecBufferInfo {
 173     int32_t offset;
 174     int32_t size;
 175     int64_t presentationTimeUs;
 176     uint32_t flags;
 177 };
 178 typedef struct FFAMediaCodecBufferInfo FFAMediaCodecBufferInfo;
 179
 180 typedef struct FFAMediaCodec FFAMediaCodec;
 181 struct FFAMediaCodec {
 182     const AVClass *class;
 183
 184     char *(*getName)(FFAMediaCodec *codec);
 185
 186     FFAMediaCodec* (*createCodecByName)(const char *name);
 187     FFAMediaCodec* (*createDecoderByType)(const char *mime_type);
 188     FFAMediaCodec* (*createEncoderByType)(const char *mime_type);
 189     int (*delete)(FFAMediaCodec* codec);
 190
 191     int (*configure)(FFAMediaCodec* codec, const FFAMediaFormat* format, FFANativeWindow* surface, void *crypto, uint32_t flags);
 192     int (*start)(FFAMediaCodec* codec);
 193     int (*stop)(FFAMediaCodec* codec);
 194     int (*flush)(FFAMediaCodec* codec);
 195
 196     uint8_t* (*getInputBuffer)(FFAMediaCodec* codec, size_t idx, size_t *out_size);
 197     uint8_t* (*getOutputBuffer)(FFAMediaCodec* codec, size_t idx, size_t *out_size);
 198
 199     ssize_t (*dequeueInputBuffer)(FFAMediaCodec* codec, int64_t timeoutUs);
 200     int (*queueInputBuffer)(FFAMediaCodec* codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags);
 201
 202     ssize_t (*dequeueOutputBuffer)(FFAMediaCodec* codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs);
 203     FFAMediaFormat* (*getOutputFormat)(FFAMediaCodec* codec);
 204
 205     int (*releaseOutputBuffer)(FFAMediaCodec* codec, size_t idx, int render);
 206     int (*releaseOutputBufferAtTime)(FFAMediaCodec *codec, size_t idx, int64_t timestampNs);
 207
 208     int (*infoTryAgainLater)(FFAMediaCodec *codec, ssize_t idx);
 209     int (*infoOutputBuffersChanged)(FFAMediaCodec *codec, ssize_t idx);
 210     int (*infoOutputFormatChanged)(FFAMediaCodec *codec, ssize_t indx);
 211
 212     int (*getBufferFlagCodecConfig)(FFAMediaCodec *codec);
 213     int (*getBufferFlagEndOfStream)(FFAMediaCodec *codec);
 214     int (*getBufferFlagKeyFrame)(FFAMediaCodec *codec);
 215
 216     int (*getConfigureFlagEncode)(FFAMediaCodec *codec);
 217
 218     int (*cleanOutputBuffers)(FFAMediaCodec *codec);
 219
 220     // For encoder with FFANativeWindow as input.
 221     int (*signalEndOfInputStream)(FFAMediaCodec *);
 222 };
 223
 224 static inline char *ff_AMediaCodec_getName(FFAMediaCodec *codec)
 225 {
 226     return codec->getName(codec);
 227 }
 228
 229 FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name, int ndk);
 230 FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime_type, int ndk);
 231 FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime_type, int ndk);
 232
 233 static inline int ff_AMediaCodec_configure(FFAMediaCodec *codec,
 234                                            const FFAMediaFormat *format,
 235                                            FFANativeWindow *surface,
 236                                            void *crypto, uint32_t flags)
 237 {
 238     return codec->configure(codec, format, surface, crypto, flags);
 239 }
 240
 241 static inline int ff_AMediaCodec_start(FFAMediaCodec* codec)
 242 {
 243     return codec->start(codec);
 244 }
 245
 246 static inline int ff_AMediaCodec_stop(FFAMediaCodec* codec)
 247 {
 248     return codec->stop(codec);
 249 }
 250
 251 static inline int ff_AMediaCodec_flush(FFAMediaCodec* codec)
 252 {
 253     return codec->flush(codec);
 254 }
 255
 256 static inline int ff_AMediaCodec_delete(FFAMediaCodec* codec)
 257 {
 258     return codec->delete(codec);
 259 }
 260
 261 static inline uint8_t* ff_AMediaCodec_getInputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)
 262 {
 263     return codec->getInputBuffer(codec, idx, out_size);
 264 }
 265
 266 static inline uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)
 267 {
 268     return codec->getOutputBuffer(codec, idx, out_size);
 269 }
 270
 271 static inline ssize_t ff_AMediaCodec_dequeueInputBuffer(FFAMediaCodec* codec, int64_t timeoutUs)
 272 {
 273     return codec->dequeueInputBuffer(codec, timeoutUs);
 274 }
 275
 276 static inline int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec *codec, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags)
 277 {
 278     return codec->queueInputBuffer(codec, idx, offset, size, time, flags);
 279 }
 280
 281 static inline ssize_t ff_AMediaCodec_dequeueOutputBuffer(FFAMediaCodec* codec, FFAMediaCodecBufferInfo *info, int64_t timeoutUs)
 282 {
 283     return codec->dequeueOutputBuffer(codec, info, timeoutUs);
 284 }
 285
 286 static inline FFAMediaFormat* ff_AMediaCodec_getOutputFormat(FFAMediaCodec* codec)
 287 {
 288     return codec->getOutputFormat(codec);
 289 }
 290
 291 static inline int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec* codec, size_t idx, int render)
 292 {
 293     return codec->releaseOutputBuffer(codec, idx, render);
 294 }
 295
 296 static inline int ff_AMediaCodec_releaseOutputBufferAtTime(FFAMediaCodec *codec, size_t idx, int64_t timestampNs)
 297 {
 298     return codec->releaseOutputBufferAtTime(codec, idx, timestampNs);
 299 }
 300
 301 static inline int ff_AMediaCodec_infoTryAgainLater(FFAMediaCodec *codec, ssize_t idx)
 302 {
 303     return codec->infoTryAgainLater(codec, idx);
 304 }
 305
 306 static inline int ff_AMediaCodec_infoOutputBuffersChanged(FFAMediaCodec *codec, ssize_t idx)
 307 {
 308     return codec->infoOutputBuffersChanged(codec, idx);
 309 }
 310
 311 static inline int ff_AMediaCodec_infoOutputFormatChanged(FFAMediaCodec *codec, ssize_t idx)
 312 {
 313     return codec->infoOutputFormatChanged(codec, idx);
 314 }
 315
 316 static inline int ff_AMediaCodec_getBufferFlagCodecConfig(FFAMediaCodec *codec)
 317 {
 318     return codec->getBufferFlagCodecConfig(codec);
 319 }
 320
 321 static inline int ff_AMediaCodec_getBufferFlagEndOfStream(FFAMediaCodec *codec)
 322 {
 323     return codec->getBufferFlagEndOfStream(codec);
 324 }
 325
 326 static inline int ff_AMediaCodec_getBufferFlagKeyFrame(FFAMediaCodec *codec)
 327 {
 328     return codec->getBufferFlagKeyFrame(codec);
 329 }
 330
 331 static inline int ff_AMediaCodec_getConfigureFlagEncode(FFAMediaCodec *codec)
 332 {
 333     return codec->getConfigureFlagEncode(codec);
 334 }
 335
 336 static inline int ff_AMediaCodec_cleanOutputBuffers(FFAMediaCodec *codec)
 337 {
 338     return codec->cleanOutputBuffers(codec);
 339 }
 340
 341 static inline int ff_AMediaCodec_signalEndOfInputStream(FFAMediaCodec *codec)
 342 {
 343     return codec->signalEndOfInputStream(codec);
 344 }
 345
 346 int ff_Build_SDK_INT(AVCodecContext *avctx);
 347
 348 enum FFAMediaFormatColorRange {
 349     COLOR_RANGE_UNSPECIFIED = 0x0,
 350     COLOR_RANGE_FULL        = 0x1,
 351     COLOR_RANGE_LIMITED     = 0x2,
 352 };
 353
 354 enum FFAMediaFormatColorStandard {
 355     COLOR_STANDARD_UNSPECIFIED  = 0x0,
 356     COLOR_STANDARD_BT709        = 0x1,
 357     COLOR_STANDARD_BT601_PAL    = 0x2,
 358     COLOR_STANDARD_BT601_NTSC   = 0x4,
 359     COLOR_STANDARD_BT2020       = 0x6,
 360 };
 361
 362 enum FFAMediaFormatColorTransfer {
 363     COLOR_TRANSFER_UNSPECIFIED = 0x0,
 364     COLOR_TRANSFER_LINEAR      = 0x1,
 365     COLOR_TRANSFER_SDR_VIDEO   = 0x3,
 366     COLOR_TRANSFER_ST2084      = 0x6,
 367     COLOR_TRANSFER_HLG         = 0x7,
 368 };
 369
 370 /**
 371  * Map MediaFormat color range to AVColorRange.
 372  *
 373  * return AVCOL_RANGE_UNSPECIFIED when failed.
 374  */
 375 enum AVColorRange ff_AMediaFormatColorRange_to_AVColorRange(int color_range);
 376
 377 /**
 378  * Map AVColorRange to MediaFormat color range.
 379  *
 380  * return COLOR_RANGE_UNSPECIFIED when failed.
 381  */
 382 int ff_AMediaFormatColorRange_from_AVColorRange(enum AVColorRange color_range);
 383
 384 /**
 385  * Map MediaFormat color standard to AVColorSpace.
 386  *
 387  * return AVCOL_SPC_UNSPECIFIED when failed.
 388  */
 389 enum AVColorSpace ff_AMediaFormatColorStandard_to_AVColorSpace(int color_standard);
 390
 391 /**
 392  * Map AVColorSpace to MediaFormat color standard.
 393  *
 394  * return COLOR_STANDARD_UNSPECIFIED when failed.
 395  */
 396 int ff_AMediaFormatColorStandard_from_AVColorSpace(enum AVColorSpace color_space);
 397
 398 /**
 399  * Map MediaFormat color standard to AVColorPrimaries.
 400  *
 401  * return AVCOL_PRI_UNSPECIFIED when failed.
 402  */
 403 enum AVColorPrimaries ff_AMediaFormatColorStandard_to_AVColorPrimaries(int color_standard);
 404
 405 /**
 406  * Map MediaFormat color transfer to AVColorTransferCharacteristic.
 407  *
 408  * return AVCOL_TRC_UNSPECIFIED when failed.
 409  */
 410 enum AVColorTransferCharacteristic
 411 ff_AMediaFormatColorTransfer_to_AVColorTransfer(int color_transfer);
 412
 413 /**
 414  * Map AVColorTransferCharacteristic to MediaFormat color transfer.
 415  *
 416  * return COLOR_TRANSFER_UNSPECIFIED when failed.
 417  */
 418 int ff_AMediaFormatColorTransfer_from_AVColorTransfer(
 419     enum AVColorTransferCharacteristic color_transfer);
 420
 421 #endif /* AVCODEC_MEDIACODEC_WRAPPER_H */