Port renaming changes from AOMedia Cherry-Picked the following commits: 0defd8f Changed "WebM" to "AOMedia" & "webm" to "aomedia" 54e6676 Replace "VPx" by "AVx" 5082a36 Change "Vpx" to "Avx" 7df44f1 Replace "Vp9" w/ "Av1" 967f722 Remove kVp9CodecId 828f30c Change "Vp8" to "AOM" 030b5ff AUTHORS regenerated 2524cae Add ref-mv experimental flag 016762b Change copyright notice to AOMedia form 81e5526 Replace vp9 w/ av1 9b94565 Add missing files fa8ca9f Change "vp9" to "av1" ec838b7 Convert "vp8" to "aom" 80edfa0 Change "VP9" to "AV1" d1a11fb Change "vp8" to "aom" 7b58251 Point to WebM test data dd1a5c8 Replace "VP8" with "AOM" ff00fc0 Change "VPX" to "AOM" 01dee0b Change "vp10" to "av1" in source code cebe6f0 Convert "vpx" to "aom" 17b0567 rename vp10*.mk to av1_*.mk fe5f8a8 rename files vp10_* to av1_* Change-Id: I6fc3d18eb11fc171e46140c836ad5339cf6c9419
diff --git a/aom/aom.h b/aom/aom.h new file mode 100644 index 0000000..31df675 --- /dev/null +++ b/aom/aom.h
@@ -0,0 +1,159 @@ +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/*!\defgroup aom AOM + * \ingroup codecs + * AOM is aom's newest video compression algorithm that uses motion + * compensated prediction, Discrete Cosine Transform (DCT) coding of the + * prediction error signal and context dependent entropy coding techniques + * based on arithmetic principles. It features: + * - YUV 4:2:0 image format + * - Macro-block based coding (16x16 luma plus two 8x8 chroma) + * - 1/4 (1/8) pixel accuracy motion compensated prediction + * - 4x4 DCT transform + * - 128 level linear quantizer + * - In loop deblocking filter + * - Context-based entropy coding + * + * @{ + */ +/*!\file + * \brief Provides controls common to both the AOM encoder and decoder. + */ +#ifndef AOM_AOM_H_ +#define AOM_AOM_H_ + +#include "./aom_codec.h" +#include "./aom_image.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*!\brief Control functions + * + * The set of macros define the control functions of AOM interface + */ +enum aom_com_control_id { + /*!\brief pass in an external frame into decoder to be used as reference frame + */ + AOM_SET_REFERENCE = 1, + AOM_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */ + AOM_SET_POSTPROC = 3, /**< set the decoder's post processing settings */ + AOM_SET_DBG_COLOR_REF_FRAME = + 4, /**< set the reference frames to color for each macroblock */ + AOM_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */ + AOM_SET_DBG_COLOR_B_MODES = 6, /**< set which blocks modes to color */ + AOM_SET_DBG_DISPLAY_MV = 7, /**< set which motion vector modes to draw */ + + /* TODO(jkoleszar): The encoder incorrectly reuses some of these values (5+) + * for its control ids. These should be migrated to something like the + * AOM_DECODER_CTRL_ID_START range next time we're ready to break the ABI. + */ + AV1_GET_REFERENCE = 128, /**< get a pointer to a reference frame */ + AOM_COMMON_CTRL_ID_MAX, + + AV1_GET_NEW_FRAME_IMAGE = 192, /**< get a pointer to the new frame */ + + AOM_DECODER_CTRL_ID_START = 256 +}; + +/*!\brief post process flags + * + * The set of macros define AOM decoder post processing flags + */ +enum aom_postproc_level { + AOM_NOFILTERING = 0, + AOM_DEBLOCK = 1 << 0, + AOM_DEMACROBLOCK = 1 << 1, + AOM_ADDNOISE = 1 << 2, + AOM_DEBUG_TXT_FRAME_INFO = 1 << 3, /**< print frame information */ + AOM_DEBUG_TXT_MBLK_MODES = + 1 << 4, /**< print macro block modes over each macro block */ + AOM_DEBUG_TXT_DC_DIFF = 1 << 5, /**< print dc diff for each macro block */ + AOM_DEBUG_TXT_RATE_INFO = 1 << 6, /**< print video rate info (encoder only) */ + AOM_MFQE = 1 << 10 +}; + +/*!\brief post process flags + * + * This define a structure that describe the post processing settings. For + * the best objective measure (using the PSNR metric) set post_proc_flag + * to AOM_DEBLOCK and deblocking_level to 1. + */ + +typedef struct aom_postproc_cfg { + /*!\brief the types of post processing to be done, should be combination of + * "aom_postproc_level" */ + int post_proc_flag; + int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */ + int noise_level; /**< the strength of additive noise, valid range [0, 16] */ +} aom_postproc_cfg_t; + +/*!\brief reference frame type + * + * The set of macros define the type of AOM reference frames + */ +typedef enum aom_ref_frame_type { + AOM_LAST_FRAME = 1, + AOM_GOLD_FRAME = 2, + AOM_ALTR_FRAME = 4 +} aom_ref_frame_type_t; + +/*!\brief reference frame data struct + * + * Define the data struct to access aom reference frames. + */ +typedef struct aom_ref_frame { + aom_ref_frame_type_t frame_type; /**< which reference frame */ + aom_image_t img; /**< reference frame data in image format */ +} aom_ref_frame_t; + +/*!\brief AV1 specific reference frame data struct + * + * Define the data struct to access av1 reference frames. + */ +typedef struct av1_ref_frame { + int idx; /**< frame index to get (input) */ + aom_image_t img; /**< img structure to populate (output) */ +} av1_ref_frame_t; + +/*!\cond */ +/*!\brief aom decoder control function parameter type + * + * defines the data type for each of AOM decoder control function requires + */ +AOM_CTRL_USE_TYPE(AOM_SET_REFERENCE, aom_ref_frame_t *) +#define AOM_CTRL_AOM_SET_REFERENCE +AOM_CTRL_USE_TYPE(AOM_COPY_REFERENCE, aom_ref_frame_t *) +#define AOM_CTRL_AOM_COPY_REFERENCE +AOM_CTRL_USE_TYPE(AOM_SET_POSTPROC, aom_postproc_cfg_t *) +#define AOM_CTRL_AOM_SET_POSTPROC +AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_REF_FRAME, int) +#define AOM_CTRL_AOM_SET_DBG_COLOR_REF_FRAME +AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_MB_MODES, int) +#define AOM_CTRL_AOM_SET_DBG_COLOR_MB_MODES +AOM_CTRL_USE_TYPE(AOM_SET_DBG_COLOR_B_MODES, int) +#define AOM_CTRL_AOM_SET_DBG_COLOR_B_MODES +AOM_CTRL_USE_TYPE(AOM_SET_DBG_DISPLAY_MV, int) +#define AOM_CTRL_AOM_SET_DBG_DISPLAY_MV +AOM_CTRL_USE_TYPE(AV1_GET_REFERENCE, av1_ref_frame_t *) +#define AOM_CTRL_AV1_GET_REFERENCE +AOM_CTRL_USE_TYPE(AV1_GET_NEW_FRAME_IMAGE, aom_image_t *) +#define AOM_CTRL_AV1_GET_NEW_FRAME_IMAGE + +/*!\endcond */ +/*! @} - end defgroup aom */ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AOM_AOM_H_
diff --git a/aom/vpx_codec.h b/aom/aom_codec.h similarity index 68% rename from aom/vpx_codec.h rename to aom/aom_codec.h index 107469f..b41a799 100644 --- a/aom/vpx_codec.h +++ b/aom/aom_codec.h
@@ -22,28 +22,28 @@ * video codec algorithm. * * An application instantiates a specific codec instance by using - * vpx_codec_init() and a pointer to the algorithm's interface structure: + * aom_codec_init() and a pointer to the algorithm's interface structure: * <pre> * my_app.c: - * extern vpx_codec_iface_t my_codec; + * extern aom_codec_iface_t my_codec; * { - * vpx_codec_ctx_t algo; - * res = vpx_codec_init(&algo, &my_codec); + * aom_codec_ctx_t algo; + * res = aom_codec_init(&algo, &my_codec); * } * </pre> * * Once initialized, the instance is manged using other functions from - * the vpx_codec_* family. + * the aom_codec_* family. */ -#ifndef VPX_VPX_CODEC_H_ -#define VPX_VPX_CODEC_H_ +#ifndef AOM_AOM_CODEC_H_ +#define AOM_AOM_CODEC_H_ #ifdef __cplusplus extern "C" { #endif -#include "./vpx_integer.h" -#include "./vpx_image.h" +#include "./aom_integer.h" +#include "./aom_image.h" /*!\brief Decorator indicating a function is deprecated */ #ifndef DEPRECATED @@ -83,31 +83,31 @@ * types, removing or reassigning enums, adding/removing/rearranging * fields to structures */ -#define VPX_CODEC_ABI_VERSION (3 + VPX_IMAGE_ABI_VERSION) /**<\hideinitializer*/ +#define AOM_CODEC_ABI_VERSION (3 + AOM_IMAGE_ABI_VERSION) /**<\hideinitializer*/ /*!\brief Algorithm return codes */ typedef enum { /*!\brief Operation completed without error */ - VPX_CODEC_OK, + AOM_CODEC_OK, /*!\brief Unspecified error */ - VPX_CODEC_ERROR, + AOM_CODEC_ERROR, /*!\brief Memory operation failed */ - VPX_CODEC_MEM_ERROR, + AOM_CODEC_MEM_ERROR, /*!\brief ABI version mismatch */ - VPX_CODEC_ABI_MISMATCH, + AOM_CODEC_ABI_MISMATCH, /*!\brief Algorithm does not have required capability */ - VPX_CODEC_INCAPABLE, + AOM_CODEC_INCAPABLE, /*!\brief The given bitstream is not supported. * * The bitstream was unable to be parsed at the highest level. The decoder * is unable to proceed. This error \ref SHOULD be treated as fatal to the * stream. */ - VPX_CODEC_UNSUP_BITSTREAM, + AOM_CODEC_UNSUP_BITSTREAM, /*!\brief Encoded bitstream uses an unsupported feature * @@ -116,7 +116,7 @@ * pictures from being properly decoded. This error \ref MAY be treated as * fatal to the stream or \ref MAY be treated as fatal to the current GOP. */ - VPX_CODEC_UNSUP_FEATURE, + AOM_CODEC_UNSUP_FEATURE, /*!\brief The coded data for this stream is corrupt or incomplete * @@ -126,60 +126,60 @@ * stream or \ref MAY be treated as fatal to the current GOP. If decoding * is continued for the current GOP, artifacts may be present. */ - VPX_CODEC_CORRUPT_FRAME, + AOM_CODEC_CORRUPT_FRAME, /*!\brief An application-supplied parameter is not valid. * */ - VPX_CODEC_INVALID_PARAM, + AOM_CODEC_INVALID_PARAM, /*!\brief An iterator reached the end of list. * */ - VPX_CODEC_LIST_END + AOM_CODEC_LIST_END -} vpx_codec_err_t; +} aom_codec_err_t; /*! \brief Codec capabilities bitfield * * Each codec advertises the capabilities it supports as part of its - * ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces + * ::aom_codec_iface_t interface structure. Capabilities are extra interfaces * or functionality, and are not required to be supported. * - * The available flags are specified by VPX_CODEC_CAP_* defines. + * The available flags are specified by AOM_CODEC_CAP_* defines. */ -typedef long vpx_codec_caps_t; -#define VPX_CODEC_CAP_DECODER 0x1 /**< Is a decoder */ -#define VPX_CODEC_CAP_ENCODER 0x2 /**< Is an encoder */ +typedef long aom_codec_caps_t; +#define AOM_CODEC_CAP_DECODER 0x1 /**< Is a decoder */ +#define AOM_CODEC_CAP_ENCODER 0x2 /**< Is an encoder */ /*! \brief Initialization-time Feature Enabling * * Certain codec features must be known at initialization time, to allow for * proper memory allocation. * - * The available flags are specified by VPX_CODEC_USE_* defines. + * The available flags are specified by AOM_CODEC_USE_* defines. */ -typedef long vpx_codec_flags_t; +typedef long aom_codec_flags_t; /*!\brief Codec interface structure. * * Contains function pointers and other data private to the codec * implementation. This structure is opaque to the application. */ -typedef const struct vpx_codec_iface vpx_codec_iface_t; +typedef const struct aom_codec_iface aom_codec_iface_t; /*!\brief Codec private data structure. * * Contains data private to the codec implementation. This structure is opaque * to the application. */ -typedef struct vpx_codec_priv vpx_codec_priv_t; +typedef struct aom_codec_priv aom_codec_priv_t; /*!\brief Iterator * * Opaque storage used for iterating over lists. */ -typedef const void *vpx_codec_iter_t; +typedef const void *aom_codec_iter_t; /*!\brief Codec context structure * @@ -189,31 +189,31 @@ * may reference the 'name' member to get a printable description of the * algorithm. */ -typedef struct vpx_codec_ctx { +typedef struct aom_codec_ctx { const char *name; /**< Printable interface name */ - vpx_codec_iface_t *iface; /**< Interface pointers */ - vpx_codec_err_t err; /**< Last returned error */ + aom_codec_iface_t *iface; /**< Interface pointers */ + aom_codec_err_t err; /**< Last returned error */ const char *err_detail; /**< Detailed info, if available */ - vpx_codec_flags_t init_flags; /**< Flags passed at init time */ + aom_codec_flags_t init_flags; /**< Flags passed at init time */ union { /**< Decoder Configuration Pointer */ - const struct vpx_codec_dec_cfg *dec; + const struct aom_codec_dec_cfg *dec; /**< Encoder Configuration Pointer */ - const struct vpx_codec_enc_cfg *enc; + const struct aom_codec_enc_cfg *enc; const void *raw; } config; /**< Configuration pointer aliasing union */ - vpx_codec_priv_t *priv; /**< Algorithm private storage */ -} vpx_codec_ctx_t; + aom_codec_priv_t *priv; /**< Algorithm private storage */ +} aom_codec_ctx_t; /*!\brief Bit depth for codec * * * This enumeration determines the bit depth of the codec. */ -typedef enum vpx_bit_depth { - VPX_BITS_8 = 8, /**< 8 bits */ - VPX_BITS_10 = 10, /**< 10 bits */ - VPX_BITS_12 = 12, /**< 12 bits */ -} vpx_bit_depth_t; +typedef enum aom_bit_depth { + AOM_BITS_8 = 8, /**< 8 bits */ + AOM_BITS_10 = 10, /**< 10 bits */ + AOM_BITS_12 = 12, /**< 12 bits */ +} aom_bit_depth_t; /*!\brief Superblock size selection. * @@ -221,19 +221,19 @@ * either be fixed at 64x64 or 128x128 pixels, or it can be dynamically * selected by the encoder for each frame. */ -typedef enum vpx_superblock_size { - VPX_SUPERBLOCK_SIZE_64X64, /**< Always use 64x64 superblocks. */ - VPX_SUPERBLOCK_SIZE_128X128, /**< Always use 128x128 superblocks. */ - VPX_SUPERBLOCK_SIZE_DYNAMIC /**< Select superblock size dynamically. */ -} vpx_superblock_size_t; +typedef enum aom_superblock_size { + AOM_SUPERBLOCK_SIZE_64X64, /**< Always use 64x64 superblocks. */ + AOM_SUPERBLOCK_SIZE_128X128, /**< Always use 128x128 superblocks. */ + AOM_SUPERBLOCK_SIZE_DYNAMIC /**< Select superblock size dynamically. */ +} aom_superblock_size_t; /* * Library Version Number Interface * * For example, see the following sample return values: - * vpx_codec_version() (1<<16 | 2<<8 | 3) - * vpx_codec_version_str() "v1.2.3-rc1-16-gec6a1ba" - * vpx_codec_version_extra_str() "rc1-16-gec6a1ba" + * aom_codec_version() (1<<16 | 2<<8 | 3) + * aom_codec_version_str() "v1.2.3-rc1-16-gec6a1ba" + * aom_codec_version_extra_str() "rc1-16-gec6a1ba" */ /*!\brief Return the version information (as an integer) @@ -246,22 +246,22 @@ * in the future. * */ -int vpx_codec_version(void); -#define VPX_VERSION_MAJOR(v) \ +int aom_codec_version(void); +#define AOM_VERSION_MAJOR(v) \ ((v >> 16) & 0xff) /**< extract major from packed version */ -#define VPX_VERSION_MINOR(v) \ +#define AOM_VERSION_MINOR(v) \ ((v >> 8) & 0xff) /**< extract minor from packed version */ -#define VPX_VERSION_PATCH(v) \ +#define AOM_VERSION_PATCH(v) \ ((v >> 0) & 0xff) /**< extract patch from packed version */ /*!\brief Return the version major number */ -#define vpx_codec_version_major() ((vpx_codec_version() >> 16) & 0xff) +#define aom_codec_version_major() ((aom_codec_version() >> 16) & 0xff) /*!\brief Return the version minor number */ -#define vpx_codec_version_minor() ((vpx_codec_version() >> 8) & 0xff) +#define aom_codec_version_minor() ((aom_codec_version() >> 8) & 0xff) /*!\brief Return the version patch number */ -#define vpx_codec_version_patch() ((vpx_codec_version() >> 0) & 0xff) +#define aom_codec_version_patch() ((aom_codec_version() >> 0) & 0xff) /*!\brief Return the version information (as a string) * @@ -272,24 +272,24 @@ * release candidates, prerelease versions, etc. * */ -const char *vpx_codec_version_str(void); +const char *aom_codec_version_str(void); /*!\brief Return the version information (as a string) * * Returns a printable "extra string". This is the component of the string * returned - * by vpx_codec_version_str() following the three digit version number. + * by aom_codec_version_str() following the three digit version number. * */ -const char *vpx_codec_version_extra_str(void); +const char *aom_codec_version_extra_str(void); /*!\brief Return the build configuration * * Returns a printable string containing an encoded version of the build - * configuration. This may be useful to vpx support. + * configuration. This may be useful to aom support. * */ -const char *vpx_codec_build_config(void); +const char *aom_codec_build_config(void); /*!\brief Return the name for a given interface * @@ -298,7 +298,7 @@ * \param[in] iface Interface pointer * */ -const char *vpx_codec_iface_name(vpx_codec_iface_t *iface); +const char *aom_codec_iface_name(aom_codec_iface_t *iface); /*!\brief Convert error number to printable string * @@ -310,7 +310,7 @@ * \param[in] err Error number. * */ -const char *vpx_codec_err_to_string(vpx_codec_err_t err); +const char *aom_codec_err_to_string(aom_codec_err_t err); /*!\brief Retrieve error synopsis for codec context * @@ -322,7 +322,7 @@ * \param[in] ctx Pointer to this instance's context. * */ -const char *vpx_codec_error(vpx_codec_ctx_t *ctx); +const char *aom_codec_error(aom_codec_ctx_t *ctx); /*!\brief Retrieve detailed error information for codec context * @@ -334,7 +334,7 @@ * \retval NULL * No detailed information is available. */ -const char *vpx_codec_error_detail(vpx_codec_ctx_t *ctx); +const char *aom_codec_error_detail(aom_codec_ctx_t *ctx); /* REQUIRED FUNCTIONS * @@ -348,12 +348,12 @@ * * \param[in] ctx Pointer to this instance's context * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The codec algorithm initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory allocation failed. */ -vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx); +aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx); /*!\brief Get the capabilities of an algorithm. * @@ -362,7 +362,7 @@ * \param[in] iface Pointer to the algorithm interface * */ -vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface); +aom_codec_caps_t aom_codec_get_caps(aom_codec_iface_t *iface); /*!\brief Control algorithm * @@ -372,46 +372,46 @@ * * This wrapper function dispatches the request to the helper function * associated with the given ctrl_id. It tries to call this function - * transparently, but will return #VPX_CODEC_ERROR if the request could not + * transparently, but will return #AOM_CODEC_ERROR if the request could not * be dispatched. * * Note that this function should not be used directly. Call the - * #vpx_codec_control wrapper macro instead. + * #aom_codec_control wrapper macro instead. * * \param[in] ctx Pointer to this instance's context * \param[in] ctrl_id Algorithm specific control identifier * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The control request was processed. - * \retval #VPX_CODEC_ERROR + * \retval #AOM_CODEC_ERROR * The control request was not processed. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * The data was not valid. */ -vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id, ...); -#if defined(VPX_DISABLE_CTRL_TYPECHECKS) && VPX_DISABLE_CTRL_TYPECHECKS -#define vpx_codec_control(ctx, id, data) vpx_codec_control_(ctx, id, data) -#define VPX_CTRL_USE_TYPE(id, typ) -#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) -#define VPX_CTRL_VOID(id, typ) +aom_codec_err_t aom_codec_control_(aom_codec_ctx_t *ctx, int ctrl_id, ...); +#if defined(AOM_DISABLE_CTRL_TYPECHECKS) && AOM_DISABLE_CTRL_TYPECHECKS +#define aom_codec_control(ctx, id, data) aom_codec_control_(ctx, id, data) +#define AOM_CTRL_USE_TYPE(id, typ) +#define AOM_CTRL_USE_TYPE_DEPRECATED(id, typ) +#define AOM_CTRL_VOID(id, typ) #else -/*!\brief vpx_codec_control wrapper macro +/*!\brief aom_codec_control wrapper macro * * This macro allows for type safe conversions across the variadic parameter - * to vpx_codec_control_(). + * to aom_codec_control_(). * * \internal * It works by dispatching the call to the control function through a wrapper * function named with the id parameter. */ -#define vpx_codec_control(ctx, id, data) \ - vpx_codec_control_##id(ctx, id, data) /**<\hideinitializer*/ +#define aom_codec_control(ctx, id, data) \ + aom_codec_control_##id(ctx, id, data) /**<\hideinitializer*/ -/*!\brief vpx_codec_control type definition macro +/*!\brief aom_codec_control type definition macro * * This macro allows for type safe conversions across the variadic parameter - * to vpx_codec_control_(). It defines the type of the argument for a given + * to aom_codec_control_(). It defines the type of the argument for a given * control identifier. * * \internal @@ -419,18 +419,18 @@ * the correctly typed arguments as a wrapper to the type-unsafe internal * function. */ -#define VPX_CTRL_USE_TYPE(id, typ) \ - static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *, int, typ) \ +#define AOM_CTRL_USE_TYPE(id, typ) \ + static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *, int, typ) \ UNUSED; \ \ - static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *ctx, \ + static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *ctx, \ int ctrl_id, typ data) { \ - return vpx_codec_control_(ctx, ctrl_id, data); \ + return aom_codec_control_(ctx, ctrl_id, data); \ } /**<\hideinitializer*/ -/*!\brief vpx_codec_control deprecated type definition macro +/*!\brief aom_codec_control deprecated type definition macro * - * Like #VPX_CTRL_USE_TYPE, but indicates that the specified control is + * Like #AOM_CTRL_USE_TYPE, but indicates that the specified control is * deprecated and should not be used. Consult the documentation for your * codec for more information. * @@ -438,32 +438,32 @@ * It defines a static function with the correctly typed arguments as a * wrapper to the type-unsafe internal function. */ -#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) \ - DECLSPEC_DEPRECATED static vpx_codec_err_t vpx_codec_control_##id( \ - vpx_codec_ctx_t *, int, typ) DEPRECATED UNUSED; \ +#define AOM_CTRL_USE_TYPE_DEPRECATED(id, typ) \ + DECLSPEC_DEPRECATED static aom_codec_err_t aom_codec_control_##id( \ + aom_codec_ctx_t *, int, typ) DEPRECATED UNUSED; \ \ - DECLSPEC_DEPRECATED static vpx_codec_err_t vpx_codec_control_##id( \ - vpx_codec_ctx_t *ctx, int ctrl_id, typ data) { \ - return vpx_codec_control_(ctx, ctrl_id, data); \ + DECLSPEC_DEPRECATED static aom_codec_err_t aom_codec_control_##id( \ + aom_codec_ctx_t *ctx, int ctrl_id, typ data) { \ + return aom_codec_control_(ctx, ctrl_id, data); \ } /**<\hideinitializer*/ -/*!\brief vpx_codec_control void type definition macro +/*!\brief aom_codec_control void type definition macro * * This macro allows for type safe conversions across the variadic parameter - * to vpx_codec_control_(). It indicates that a given control identifier takes + * to aom_codec_control_(). It indicates that a given control identifier takes * no argument. * * \internal * It defines a static function without a data argument as a wrapper to the * type-unsafe internal function. */ -#define VPX_CTRL_VOID(id) \ - static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *, int) \ +#define AOM_CTRL_VOID(id) \ + static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *, int) \ UNUSED; \ \ - static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *ctx, \ + static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *ctx, \ int ctrl_id) { \ - return vpx_codec_control_(ctx, ctrl_id); \ + return aom_codec_control_(ctx, ctrl_id); \ } /**<\hideinitializer*/ #endif @@ -472,4 +472,4 @@ #ifdef __cplusplus } #endif -#endif // VPX_VPX_CODEC_H_ +#endif // AOM_AOM_CODEC_H_
diff --git a/aom/aom_codec.mk b/aom/aom_codec.mk new file mode 100644 index 0000000..9a31306 --- /dev/null +++ b/aom/aom_codec.mk
@@ -0,0 +1,41 @@ +## +## Copyright (c) 2010 The WebM project authors. All Rights Reserved. +## +## Use of this source code is governed by a BSD-style license +## that can be found in the LICENSE file in the root of the source +## tree. An additional intellectual property rights grant can be found +## in the file PATENTS. All contributing project authors may +## be found in the AUTHORS file in the root of the source tree. +## + + +API_EXPORTS += exports + +API_SRCS-$(CONFIG_AV1_ENCODER) += aom.h +API_SRCS-$(CONFIG_AV1_ENCODER) += aomcx.h +API_DOC_SRCS-$(CONFIG_AV1_ENCODER) += aom.h +API_DOC_SRCS-$(CONFIG_AV1_ENCODER) += aomcx.h + +API_SRCS-$(CONFIG_AV1_DECODER) += aom.h +API_SRCS-$(CONFIG_AV1_DECODER) += aomdx.h +API_DOC_SRCS-$(CONFIG_AV1_DECODER) += aom.h +API_DOC_SRCS-$(CONFIG_AV1_DECODER) += aomdx.h + +API_DOC_SRCS-yes += aom_codec.h +API_DOC_SRCS-yes += aom_decoder.h +API_DOC_SRCS-yes += aom_encoder.h +API_DOC_SRCS-yes += aom_frame_buffer.h +API_DOC_SRCS-yes += aom_image.h + +API_SRCS-yes += src/aom_decoder.c +API_SRCS-yes += aom_decoder.h +API_SRCS-yes += src/aom_encoder.c +API_SRCS-yes += aom_encoder.h +API_SRCS-yes += internal/aom_codec_internal.h +API_SRCS-yes += src/aom_codec.c +API_SRCS-yes += src/aom_image.c +API_SRCS-yes += aom_codec.h +API_SRCS-yes += aom_codec.mk +API_SRCS-yes += aom_frame_buffer.h +API_SRCS-yes += aom_image.h +API_SRCS-yes += aom_integer.h
diff --git a/aom/vpx_decoder.h b/aom/aom_decoder.h similarity index 72% rename from aom/vpx_decoder.h rename to aom/aom_decoder.h index 2fb3be1..affb6fc 100644 --- a/aom/vpx_decoder.h +++ b/aom/aom_decoder.h
@@ -7,8 +7,8 @@ * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VPX_VPX_DECODER_H_ -#define VPX_VPX_DECODER_H_ +#ifndef AOM_AOM_DECODER_H_ +#define AOM_AOM_DECODER_H_ /*!\defgroup decoder Decoder Algorithm Interface * \ingroup codec @@ -29,8 +29,8 @@ extern "C" { #endif -#include "./vpx_codec.h" -#include "./vpx_frame_buffer.h" +#include "./aom_codec.h" +#include "./aom_frame_buffer.h" /*!\brief Current ABI version number * @@ -40,45 +40,45 @@ * types, removing or reassigning enums, adding/removing/rearranging * fields to structures */ -#define VPX_DECODER_ABI_VERSION \ - (3 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/ +#define AOM_DECODER_ABI_VERSION \ + (3 + AOM_CODEC_ABI_VERSION) /**<\hideinitializer*/ /*! \brief Decoder capabilities bitfield * * Each decoder advertises the capabilities it supports as part of its - * ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces + * ::aom_codec_iface_t interface structure. Capabilities are extra interfaces * or functionality, and are not required to be supported by a decoder. * - * The available flags are specified by VPX_CODEC_CAP_* defines. + * The available flags are specified by AOM_CODEC_CAP_* defines. */ -#define VPX_CODEC_CAP_PUT_SLICE 0x10000 /**< Will issue put_slice callbacks */ -#define VPX_CODEC_CAP_PUT_FRAME 0x20000 /**< Will issue put_frame callbacks */ -#define VPX_CODEC_CAP_POSTPROC 0x40000 /**< Can postprocess decoded frame */ +#define AOM_CODEC_CAP_PUT_SLICE 0x10000 /**< Will issue put_slice callbacks */ +#define AOM_CODEC_CAP_PUT_FRAME 0x20000 /**< Will issue put_frame callbacks */ +#define AOM_CODEC_CAP_POSTPROC 0x40000 /**< Can postprocess decoded frame */ /*!\brief Can conceal errors due to packet loss */ -#define VPX_CODEC_CAP_ERROR_CONCEALMENT 0x80000 +#define AOM_CODEC_CAP_ERROR_CONCEALMENT 0x80000 /*!\brief Can receive encoded frames one fragment at a time */ -#define VPX_CODEC_CAP_INPUT_FRAGMENTS 0x100000 +#define AOM_CODEC_CAP_INPUT_FRAGMENTS 0x100000 /*! \brief Initialization-time Feature Enabling * * Certain codec features must be known at initialization time, to allow for * proper memory allocation. * - * The available flags are specified by VPX_CODEC_USE_* defines. + * The available flags are specified by AOM_CODEC_USE_* defines. */ /*!\brief Can support frame-based multi-threading */ -#define VPX_CODEC_CAP_FRAME_THREADING 0x200000 +#define AOM_CODEC_CAP_FRAME_THREADING 0x200000 /*!brief Can support external frame buffers */ -#define VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER 0x400000 +#define AOM_CODEC_CAP_EXTERNAL_FRAME_BUFFER 0x400000 -#define VPX_CODEC_USE_POSTPROC 0x10000 /**< Postprocess decoded frame */ +#define AOM_CODEC_USE_POSTPROC 0x10000 /**< Postprocess decoded frame */ /*!\brief Conceal errors in decoded frames */ -#define VPX_CODEC_USE_ERROR_CONCEALMENT 0x20000 +#define AOM_CODEC_USE_ERROR_CONCEALMENT 0x20000 /*!\brief The input frame should be passed to the decoder one fragment at a * time */ -#define VPX_CODEC_USE_INPUT_FRAGMENTS 0x40000 +#define AOM_CODEC_USE_INPUT_FRAGMENTS 0x40000 /*!\brief Enable frame-based multi-threading */ -#define VPX_CODEC_USE_FRAME_THREADING 0x80000 +#define AOM_CODEC_USE_FRAME_THREADING 0x80000 /*!\brief Stream properties * @@ -86,12 +86,12 @@ * stream. Algorithms may extend this structure with data specific * to their bitstream by setting the sz member appropriately. */ -typedef struct vpx_codec_stream_info { +typedef struct aom_codec_stream_info { unsigned int sz; /**< Size of this structure */ unsigned int w; /**< Width (or 0 for unknown/default) */ unsigned int h; /**< Height (or 0 for unknown/default) */ unsigned int is_kf; /**< Current frame is a keyframe */ -} vpx_codec_stream_info_t; +} aom_codec_stream_info_t; /* REQUIRED FUNCTIONS * @@ -104,16 +104,16 @@ * This structure is used to pass init time configuration options to the * decoder. */ -typedef struct vpx_codec_dec_cfg { +typedef struct aom_codec_dec_cfg { unsigned int threads; /**< Maximum number of threads to use, default 1 */ unsigned int w; /**< Width */ unsigned int h; /**< Height */ -} vpx_codec_dec_cfg_t; /**< alias for struct vpx_codec_dec_cfg */ +} aom_codec_dec_cfg_t; /**< alias for struct aom_codec_dec_cfg */ /*!\brief Initialize a decoder instance * * Initializes a decoder context using the given interface. Applications - * should call the vpx_codec_dec_init convenience macro instead of this + * should call the aom_codec_dec_init convenience macro instead of this * function directly, to ensure that the ABI version number parameter * is properly initialized. * @@ -124,25 +124,25 @@ * \param[in] ctx Pointer to this instance's context. * \param[in] iface Pointer to the algorithm interface to use. * \param[in] cfg Configuration to use, if known. May be NULL. - * \param[in] flags Bitfield of VPX_CODEC_USE_* flags + * \param[in] flags Bitfield of AOM_CODEC_USE_* flags * \param[in] ver ABI version number. Must be set to - * VPX_DECODER_ABI_VERSION - * \retval #VPX_CODEC_OK + * AOM_DECODER_ABI_VERSION + * \retval #AOM_CODEC_OK * The decoder algorithm initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory allocation failed. */ -vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t *ctx, - vpx_codec_iface_t *iface, - const vpx_codec_dec_cfg_t *cfg, - vpx_codec_flags_t flags, int ver); +aom_codec_err_t aom_codec_dec_init_ver(aom_codec_ctx_t *ctx, + aom_codec_iface_t *iface, + const aom_codec_dec_cfg_t *cfg, + aom_codec_flags_t flags, int ver); -/*!\brief Convenience macro for vpx_codec_dec_init_ver() +/*!\brief Convenience macro for aom_codec_dec_init_ver() * * Ensures the ABI version parameter is properly set. */ -#define vpx_codec_dec_init(ctx, iface, cfg, flags) \ - vpx_codec_dec_init_ver(ctx, iface, cfg, flags, VPX_DECODER_ABI_VERSION) +#define aom_codec_dec_init(ctx, iface, cfg, flags) \ + aom_codec_dec_init_ver(ctx, iface, cfg, flags, AOM_DECODER_ABI_VERSION) /*!\brief Parse stream info from a buffer * @@ -158,13 +158,13 @@ * clobbered by the algorithm. This parameter \ref MAY * be NULL. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Bitstream is parsable and stream information updated */ -vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t *iface, +aom_codec_err_t aom_codec_peek_stream_info(aom_codec_iface_t *iface, const uint8_t *data, unsigned int data_sz, - vpx_codec_stream_info_t *si); + aom_codec_stream_info_t *si); /*!\brief Return information about the current stream. * @@ -176,11 +176,11 @@ * clobbered by the algorithm. This parameter \ref MAY * be NULL. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Bitstream is parsable and stream information updated */ -vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t *ctx, - vpx_codec_stream_info_t *si); +aom_codec_err_t aom_codec_get_stream_info(aom_codec_ctx_t *ctx, + aom_codec_stream_info_t *si); /*!\brief Decode data * @@ -189,7 +189,7 @@ * generated, as appropriate. Encoded data \ref MUST be passed in DTS (decode * time stamp) order. Frames produced will always be in PTS (presentation * time stamp) order. - * If the decoder is configured with VPX_CODEC_USE_INPUT_FRAGMENTS enabled, + * If the decoder is configured with AOM_CODEC_USE_INPUT_FRAGMENTS enabled, * data and data_sz can contain a fragment of the encoded frame. Fragment * \#n must contain at least partition \#n, but can also contain subsequent * partitions (\#n+1 - \#n+i), and if so, fragments \#n+1, .., \#n+i must @@ -199,7 +199,7 @@ * * \param[in] ctx Pointer to this instance's context * \param[in] data Pointer to this block of new coded data. If - * NULL, a VPX_CODEC_CB_PUT_FRAME event is posted + * NULL, a AOM_CODEC_CB_PUT_FRAME event is posted * for the previously decoded frame. * \param[in] data_sz Size of the coded data, in bytes. * \param[in] user_priv Application specific data to associate with @@ -207,12 +207,12 @@ * \param[in] deadline Soft deadline the decoder should attempt to meet, * in us. Set to zero for unlimited. * - * \return Returns #VPX_CODEC_OK if the coded data was processed completely + * \return Returns #AOM_CODEC_OK if the coded data was processed completely * and future pictures can be decoded without error. Otherwise, - * see the descriptions of the other error codes in ::vpx_codec_err_t + * see the descriptions of the other error codes in ::aom_codec_err_t * for recoverability capabilities. */ -vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data, +aom_codec_err_t aom_codec_decode(aom_codec_ctx_t *ctx, const uint8_t *data, unsigned int data_sz, void *user_priv, long deadline); @@ -223,8 +223,8 @@ * complete when this function returns NULL. * * The list of available frames becomes valid upon completion of the - * vpx_codec_decode call, and remains valid until the next call to - * vpx_codec_decode. + * aom_codec_decode call, and remains valid until the next call to + * aom_codec_decode. * * \param[in] ctx Pointer to this instance's context * \param[in,out] iter Iterator storage, initialized to NULL @@ -232,15 +232,15 @@ * \return Returns a pointer to an image, if one is ready for display. Frames * produced will always be in PTS (presentation time stamp) order. */ -vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter); +aom_image_t *aom_codec_get_frame(aom_codec_ctx_t *ctx, aom_codec_iter_t *iter); /*!\defgroup cap_put_frame Frame-Based Decoding Functions * * The following functions are required to be implemented for all decoders - * that advertise the VPX_CODEC_CAP_PUT_FRAME capability. Calling these + * that advertise the AOM_CODEC_CAP_PUT_FRAME capability. Calling these * functions * for codecs that don't advertise this capability will result in an error - * code being returned, usually VPX_CODEC_ERROR + * code being returned, usually AOM_CODEC_ERROR * @{ */ @@ -249,8 +249,8 @@ * This callback is invoked by the decoder to notify the application of * the availability of decoded image data. */ -typedef void (*vpx_codec_put_frame_cb_fn_t)(void *user_priv, - const vpx_image_t *img); +typedef void (*aom_codec_put_frame_cb_fn_t)(void *user_priv, + const aom_image_t *img); /*!\brief Register for notification of frame completion. * @@ -261,14 +261,14 @@ * \param[in] cb Pointer to the callback function * \param[in] user_priv User's private data * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Callback successfully registered. - * \retval #VPX_CODEC_ERROR + * \retval #AOM_CODEC_ERROR * Decoder context not initialized, or algorithm not capable of * posting slice completion. */ -vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t *ctx, - vpx_codec_put_frame_cb_fn_t cb, +aom_codec_err_t aom_codec_register_put_frame_cb(aom_codec_ctx_t *ctx, + aom_codec_put_frame_cb_fn_t cb, void *user_priv); /*!@} - end defgroup cap_put_frame */ @@ -276,10 +276,10 @@ /*!\defgroup cap_put_slice Slice-Based Decoding Functions * * The following functions are required to be implemented for all decoders - * that advertise the VPX_CODEC_CAP_PUT_SLICE capability. Calling these + * that advertise the AOM_CODEC_CAP_PUT_SLICE capability. Calling these * functions * for codecs that don't advertise this capability will result in an error - * code being returned, usually VPX_CODEC_ERROR + * code being returned, usually AOM_CODEC_ERROR * @{ */ @@ -288,10 +288,10 @@ * This callback is invoked by the decoder to notify the application of * the availability of partially decoded image data. The */ -typedef void (*vpx_codec_put_slice_cb_fn_t)(void *user_priv, - const vpx_image_t *img, - const vpx_image_rect_t *valid, - const vpx_image_rect_t *update); +typedef void (*aom_codec_put_slice_cb_fn_t)(void *user_priv, + const aom_image_t *img, + const aom_image_rect_t *valid, + const aom_image_rect_t *update); /*!\brief Register for notification of slice completion. * @@ -302,14 +302,14 @@ * \param[in] cb Pointer to the callback function * \param[in] user_priv User's private data * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Callback successfully registered. - * \retval #VPX_CODEC_ERROR + * \retval #AOM_CODEC_ERROR * Decoder context not initialized, or algorithm not capable of * posting slice completion. */ -vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t *ctx, - vpx_codec_put_slice_cb_fn_t cb, +aom_codec_err_t aom_codec_register_put_slice_cb(aom_codec_ctx_t *ctx, + aom_codec_put_slice_cb_fn_t cb, void *user_priv); /*!@} - end defgroup cap_put_slice*/ @@ -317,12 +317,12 @@ /*!\defgroup cap_external_frame_buffer External Frame Buffer Functions * * The following section is required to be implemented for all decoders - * that advertise the VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER capability. + * that advertise the AOM_CODEC_CAP_EXTERNAL_FRAME_BUFFER capability. * Calling this function for codecs that don't advertise this capability - * will result in an error code being returned, usually VPX_CODEC_ERROR. + * will result in an error code being returned, usually AOM_CODEC_ERROR. * * \note - * Currently this only works with VP9. + * Currently this only works with AV1. * @{ */ @@ -339,22 +339,22 @@ * \param[in] cb_release Pointer to the release callback function * \param[in] cb_priv Callback's private data * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * External frame buffers will be used by libaom. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * One or more of the callbacks were NULL. - * \retval #VPX_CODEC_ERROR + * \retval #AOM_CODEC_ERROR * Decoder context not initialized, or algorithm not capable of * using external frame buffers. * * \note - * When decoding VP9, the application may be required to pass in at least - * #VPX_MAXIMUM_WORK_BUFFERS external frame + * When decoding AV1, the application may be required to pass in at least + * #AOM_MAXIMUM_WORK_BUFFERS external frame * buffers. */ -vpx_codec_err_t vpx_codec_set_frame_buffer_functions( - vpx_codec_ctx_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get, - vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv); +aom_codec_err_t aom_codec_set_frame_buffer_functions( + aom_codec_ctx_t *ctx, aom_get_frame_buffer_cb_fn_t cb_get, + aom_release_frame_buffer_cb_fn_t cb_release, void *cb_priv); /*!@} - end defgroup cap_external_frame_buffer */ @@ -362,4 +362,4 @@ #ifdef __cplusplus } #endif -#endif // VPX_VPX_DECODER_H_ +#endif // AOM_AOM_DECODER_H_
diff --git a/aom/vpx_encoder.h b/aom/aom_encoder.h similarity index 78% rename from aom/vpx_encoder.h rename to aom/aom_encoder.h index 62c3ce0..f0c3d2d 100644 --- a/aom/vpx_encoder.h +++ b/aom/aom_encoder.h
@@ -7,8 +7,8 @@ * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VPX_VPX_ENCODER_H_ -#define VPX_VPX_ENCODER_H_ +#ifndef AOM_AOM_ENCODER_H_ +#define AOM_AOM_ENCODER_H_ /*!\defgroup encoder Encoder Algorithm Interface * \ingroup codec @@ -29,7 +29,7 @@ extern "C" { #endif -#include "./vpx_codec.h" +#include "./aom_codec.h" /*!\brief Current ABI version number * @@ -39,58 +39,58 @@ * types, removing or reassigning enums, adding/removing/rearranging * fields to structures */ -#define VPX_ENCODER_ABI_VERSION \ - (5 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/ +#define AOM_ENCODER_ABI_VERSION \ + (5 + AOM_CODEC_ABI_VERSION) /**<\hideinitializer*/ /*! \brief Encoder capabilities bitfield * * Each encoder advertises the capabilities it supports as part of its - * ::vpx_codec_iface_t interface structure. Capabilities are extra + * ::aom_codec_iface_t interface structure. Capabilities are extra * interfaces or functionality, and are not required to be supported * by an encoder. * - * The available flags are specified by VPX_CODEC_CAP_* defines. + * The available flags are specified by AOM_CODEC_CAP_* defines. */ -#define VPX_CODEC_CAP_PSNR 0x10000 /**< Can issue PSNR packets */ +#define AOM_CODEC_CAP_PSNR 0x10000 /**< Can issue PSNR packets */ /*! Can output one partition at a time. Each partition is returned in its - * own VPX_CODEC_CX_FRAME_PKT, with the FRAME_IS_FRAGMENT flag set for + * own AOM_CODEC_CX_FRAME_PKT, with the FRAME_IS_FRAGMENT flag set for * every partition but the last. In this mode all frames are always * returned partition by partition. */ -#define VPX_CODEC_CAP_OUTPUT_PARTITION 0x20000 +#define AOM_CODEC_CAP_OUTPUT_PARTITION 0x20000 /*! Can support input images at greater than 8 bitdepth. */ -#define VPX_CODEC_CAP_HIGHBITDEPTH 0x40000 +#define AOM_CODEC_CAP_HIGHBITDEPTH 0x40000 /*! \brief Initialization-time Feature Enabling * * Certain codec features must be known at initialization time, to allow * for proper memory allocation. * - * The available flags are specified by VPX_CODEC_USE_* defines. + * The available flags are specified by AOM_CODEC_USE_* defines. */ -#define VPX_CODEC_USE_PSNR 0x10000 /**< Calculate PSNR on each frame */ +#define AOM_CODEC_USE_PSNR 0x10000 /**< Calculate PSNR on each frame */ /*!\brief Make the encoder output one partition at a time. */ -#define VPX_CODEC_USE_OUTPUT_PARTITION 0x20000 -#define VPX_CODEC_USE_HIGHBITDEPTH 0x40000 /**< Use high bitdepth */ +#define AOM_CODEC_USE_OUTPUT_PARTITION 0x20000 +#define AOM_CODEC_USE_HIGHBITDEPTH 0x40000 /**< Use high bitdepth */ /*!\brief Generic fixed size buffer structure * * This structure is able to hold a reference to any fixed size buffer. */ -typedef struct vpx_fixed_buf { +typedef struct aom_fixed_buf { void *buf; /**< Pointer to the data */ size_t sz; /**< Length of the buffer, in chars */ -} vpx_fixed_buf_t; /**< alias for struct vpx_fixed_buf */ +} aom_fixed_buf_t; /**< alias for struct aom_fixed_buf */ /*!\brief Time Stamp Type * * An integer, which when multiplied by the stream's time base, provides * the absolute time of a sample. */ -typedef int64_t vpx_codec_pts_t; +typedef int64_t aom_codec_pts_t; /*!\brief Compressed Frame Flags * @@ -99,43 +99,43 @@ * can be used by an algorithm to provide additional detail, for example to * support frame types that are codec specific (MPEG-1 D-frames for example) */ -typedef uint32_t vpx_codec_frame_flags_t; -#define VPX_FRAME_IS_KEY 0x1 /**< frame is the start of a GOP */ +typedef uint32_t aom_codec_frame_flags_t; +#define AOM_FRAME_IS_KEY 0x1 /**< frame is the start of a GOP */ /*!\brief frame can be dropped without affecting the stream (no future frame * depends on this one) */ -#define VPX_FRAME_IS_DROPPABLE 0x2 +#define AOM_FRAME_IS_DROPPABLE 0x2 /*!\brief frame should be decoded but will not be shown */ -#define VPX_FRAME_IS_INVISIBLE 0x4 +#define AOM_FRAME_IS_INVISIBLE 0x4 /*!\brief this is a fragment of the encoded frame */ -#define VPX_FRAME_IS_FRAGMENT 0x8 +#define AOM_FRAME_IS_FRAGMENT 0x8 /*!\brief Error Resilient flags * * These flags define which error resilient features to enable in the * encoder. The flags are specified through the - * vpx_codec_enc_cfg::g_error_resilient variable. + * aom_codec_enc_cfg::g_error_resilient variable. */ -typedef uint32_t vpx_codec_er_flags_t; +typedef uint32_t aom_codec_er_flags_t; /*!\brief Improve resiliency against losses of whole frames */ -#define VPX_ERROR_RESILIENT_DEFAULT 0x1 +#define AOM_ERROR_RESILIENT_DEFAULT 0x1 /*!\brief The frame partitions are independently decodable by the bool decoder, * meaning that partitions can be decoded even though earlier partitions have * been lost. Note that intra prediction is still done over the partition * boundary. */ -#define VPX_ERROR_RESILIENT_PARTITIONS 0x2 +#define AOM_ERROR_RESILIENT_PARTITIONS 0x2 /*!\brief Encoder output packet variants * * This enumeration lists the different kinds of data packets that can be - * returned by calls to vpx_codec_get_cx_data(). Algorithms \ref MAY + * returned by calls to aom_codec_get_cx_data(). Algorithms \ref MAY * extend this list to provide additional functionality. */ -enum vpx_codec_cx_pkt_kind { - VPX_CODEC_CX_FRAME_PKT, /**< Compressed video frame */ - VPX_CODEC_STATS_PKT, /**< Two-pass statistics for this frame */ - VPX_CODEC_FPMB_STATS_PKT, /**< first pass mb statistics for this frame */ - VPX_CODEC_PSNR_PKT, /**< PSNR statistics for this frame */ - VPX_CODEC_CUSTOM_PKT = 256 /**< Algorithm extensions */ +enum aom_codec_cx_pkt_kind { + AOM_CODEC_CX_FRAME_PKT, /**< Compressed video frame */ + AOM_CODEC_STATS_PKT, /**< Two-pass statistics for this frame */ + AOM_CODEC_FPMB_STATS_PKT, /**< first pass mb statistics for this frame */ + AOM_CODEC_PSNR_PKT, /**< PSNR statistics for this frame */ + AOM_CODEC_CUSTOM_PKT = 256 /**< Algorithm extensions */ }; /*!\brief Encoder output packet @@ -143,87 +143,87 @@ * This structure contains the different kinds of output data the encoder * may produce while compressing a frame. */ -typedef struct vpx_codec_cx_pkt { - enum vpx_codec_cx_pkt_kind kind; /**< packet variant */ +typedef struct aom_codec_cx_pkt { + enum aom_codec_cx_pkt_kind kind; /**< packet variant */ union { struct { void *buf; /**< compressed data buffer */ size_t sz; /**< length of compressed data */ /*!\brief time stamp to show frame (in timebase units) */ - vpx_codec_pts_t pts; + aom_codec_pts_t pts; /*!\brief duration to show frame (in timebase units) */ unsigned long duration; - vpx_codec_frame_flags_t flags; /**< flags for this frame */ + aom_codec_frame_flags_t flags; /**< flags for this frame */ /*!\brief the partition id defines the decoding order of the partitions. * Only applicable when "output partition" mode is enabled. First * partition has id 0.*/ int partition_id; } frame; /**< data for compressed frame packet */ - vpx_fixed_buf_t twopass_stats; /**< data for two-pass packet */ - vpx_fixed_buf_t firstpass_mb_stats; /**< first pass mb packet */ - struct vpx_psnr_pkt { + aom_fixed_buf_t twopass_stats; /**< data for two-pass packet */ + aom_fixed_buf_t firstpass_mb_stats; /**< first pass mb packet */ + struct aom_psnr_pkt { unsigned int samples[4]; /**< Number of samples, total/y/u/v */ uint64_t sse[4]; /**< sum squared error, total/y/u/v */ double psnr[4]; /**< PSNR, total/y/u/v */ } psnr; /**< data for PSNR packet */ - vpx_fixed_buf_t raw; /**< data for arbitrary packets */ + aom_fixed_buf_t raw; /**< data for arbitrary packets */ /* This packet size is fixed to allow codecs to extend this * interface without having to manage storage for raw packets, * i.e., if it's smaller than 128 bytes, you can store in the * packet list directly. */ - char pad[128 - sizeof(enum vpx_codec_cx_pkt_kind)]; /**< fixed sz */ + char pad[128 - sizeof(enum aom_codec_cx_pkt_kind)]; /**< fixed sz */ } data; /**< packet data */ -} vpx_codec_cx_pkt_t; /**< alias for struct vpx_codec_cx_pkt */ +} aom_codec_cx_pkt_t; /**< alias for struct aom_codec_cx_pkt */ /*!\brief Rational Number * * This structure holds a fractional value. */ -typedef struct vpx_rational { +typedef struct aom_rational { int num; /**< fraction numerator */ int den; /**< fraction denominator */ -} vpx_rational_t; /**< alias for struct vpx_rational */ +} aom_rational_t; /**< alias for struct aom_rational */ /*!\brief Multi-pass Encoding Pass */ -enum vpx_enc_pass { - VPX_RC_ONE_PASS, /**< Single pass mode */ - VPX_RC_FIRST_PASS, /**< First pass of multi-pass mode */ - VPX_RC_LAST_PASS /**< Final pass of multi-pass mode */ +enum aom_enc_pass { + AOM_RC_ONE_PASS, /**< Single pass mode */ + AOM_RC_FIRST_PASS, /**< First pass of multi-pass mode */ + AOM_RC_LAST_PASS /**< Final pass of multi-pass mode */ }; /*!\brief Rate control mode */ -enum vpx_rc_mode { - VPX_VBR, /**< Variable Bit Rate (VBR) mode */ - VPX_CBR, /**< Constant Bit Rate (CBR) mode */ - VPX_CQ, /**< Constrained Quality (CQ) mode */ - VPX_Q, /**< Constant Quality (Q) mode */ +enum aom_rc_mode { + AOM_VBR, /**< Variable Bit Rate (VBR) mode */ + AOM_CBR, /**< Constant Bit Rate (CBR) mode */ + AOM_CQ, /**< Constrained Quality (CQ) mode */ + AOM_Q, /**< Constant Quality (Q) mode */ }; /*!\brief Keyframe placement mode. * * This enumeration determines whether keyframes are placed automatically by * the encoder or whether this behavior is disabled. Older releases of this - * SDK were implemented such that VPX_KF_FIXED meant keyframes were disabled. + * SDK were implemented such that AOM_KF_FIXED meant keyframes were disabled. * This name is confusing for this behavior, so the new symbols to be used - * are VPX_KF_AUTO and VPX_KF_DISABLED. + * are AOM_KF_AUTO and AOM_KF_DISABLED. */ -enum vpx_kf_mode { - VPX_KF_FIXED, /**< deprecated, implies VPX_KF_DISABLED */ - VPX_KF_AUTO, /**< Encoder determines optimal placement automatically */ - VPX_KF_DISABLED = 0 /**< Encoder does not place keyframes. */ +enum aom_kf_mode { + AOM_KF_FIXED, /**< deprecated, implies AOM_KF_DISABLED */ + AOM_KF_AUTO, /**< Encoder determines optimal placement automatically */ + AOM_KF_DISABLED = 0 /**< Encoder does not place keyframes. */ }; /*!\brief Encoded Frame Flags * - * This type indicates a bitfield to be passed to vpx_codec_encode(), defining + * This type indicates a bitfield to be passed to aom_codec_encode(), defining * per-frame boolean values. By convention, bits common to all codecs will be - * named VPX_EFLAG_*, and bits specific to an algorithm will be named + * named AOM_EFLAG_*, and bits specific to an algorithm will be named * /algo/_eflag_*. The lower order 16 bits are reserved for common use. */ -typedef long vpx_enc_frame_flags_t; -#define VPX_EFLAG_FORCE_KF (1 << 0) /**< Force this frame to be a keyframe */ +typedef long aom_enc_frame_flags_t; +#define AOM_EFLAG_FORCE_KF (1 << 0) /**< Force this frame to be a keyframe */ /*!\brief Encoder configuration structure * @@ -231,7 +231,7 @@ * across all codecs. This doesn't imply that all codecs support all features, * however. */ -typedef struct vpx_codec_enc_cfg { +typedef struct aom_codec_enc_cfg { /* * generic settings (g) */ @@ -285,9 +285,9 @@ * * This value identifies the bit_depth of the codec, * Only certain bit-depths are supported as identified in the - * vpx_bit_depth_t enum. + * aom_bit_depth_t enum. */ - vpx_bit_depth_t g_bit_depth; + aom_bit_depth_t g_bit_depth; /*!\brief Bit-depth of the input frames * @@ -309,7 +309,7 @@ * \ref RECOMMENDED method is to set the timebase to that of the parent * container or multimedia framework (ex: 1/1000 for ms, as in FLV). */ - struct vpx_rational g_timebase; + struct aom_rational g_timebase; /*!\brief Enable error resilient modes. * @@ -317,14 +317,14 @@ * it should enable to take measures for streaming over lossy or noisy * links. */ - vpx_codec_er_flags_t g_error_resilient; + aom_codec_er_flags_t g_error_resilient; /*!\brief Multi-pass Encoding Mode * * This value should be set to the current phase for multi-pass encoding. - * For single pass, set to #VPX_RC_ONE_PASS. + * For single pass, set to #AOM_RC_ONE_PASS. */ - enum vpx_enc_pass g_pass; + enum aom_enc_pass g_pass; /*!\brief Allow lagged encoding * @@ -352,7 +352,7 @@ * trade-off is often acceptable, but for many applications is not. It can * be disabled in these cases. * - * Note that not all codecs support this feature. All vpx VPx codecs do. + * Note that not all codecs support this feature. All aom AVx codecs do. * For other codecs, consult the documentation for that algorithm. * * This threshold is described as a percentage of the target data buffer. @@ -409,21 +409,21 @@ * bandwidth link, as from a local disk, where higher variations in * bitrate are acceptable. */ - enum vpx_rc_mode rc_end_usage; + enum aom_rc_mode rc_end_usage; /*!\brief Two-pass stats buffer. * * A buffer containing all of the stats packets produced in the first * pass, concatenated. */ - vpx_fixed_buf_t rc_twopass_stats_in; + aom_fixed_buf_t rc_twopass_stats_in; /*!\brief first pass mb stats buffer. * * A buffer containing all of the first pass mb stats packets produced * in the first pass, concatenated. */ - vpx_fixed_buf_t rc_firstpass_mb_stats_in; + aom_fixed_buf_t rc_firstpass_mb_stats_in; /*!\brief Target data rate * @@ -441,7 +441,7 @@ * encoded image. The range of valid values for the quantizer is codec * specific. Consult the documentation for the codec to determine the * values to use. To determine the range programmatically, call - * vpx_codec_enc_config_default() with a usage value of 0. + * aom_codec_enc_config_default() with a usage value of 0. */ unsigned int rc_min_quantizer; @@ -451,7 +451,7 @@ * encoded image. The range of valid values for the quantizer is codec * specific. Consult the documentation for the codec to determine the * values to use. To determine the range programmatically, call - * vpx_codec_enc_config_default() with a usage value of 0. + * aom_codec_enc_config_default() with a usage value of 0. */ unsigned int rc_max_quantizer; @@ -554,7 +554,7 @@ * fixed interval, or determine the optimal placement automatically * (as governed by the #kf_min_dist and #kf_max_dist parameters) */ - enum vpx_kf_mode kf_mode; + enum aom_kf_mode kf_mode; /*!\brief Keyframe minimum interval * @@ -573,12 +573,12 @@ * equal to kf_max_dist for a fixed interval. */ unsigned int kf_max_dist; -} vpx_codec_enc_cfg_t; /**< alias for struct vpx_codec_enc_cfg */ +} aom_codec_enc_cfg_t; /**< alias for struct aom_codec_enc_cfg */ /*!\brief Initialize an encoder instance * * Initializes a encoder context using the given interface. Applications - * should call the vpx_codec_enc_init convenience macro instead of this + * should call the aom_codec_enc_init convenience macro instead of this * function directly, to ensure that the ABI version number parameter * is properly initialized. * @@ -589,30 +589,30 @@ * \param[in] ctx Pointer to this instance's context. * \param[in] iface Pointer to the algorithm interface to use. * \param[in] cfg Configuration to use, if known. May be NULL. - * \param[in] flags Bitfield of VPX_CODEC_USE_* flags + * \param[in] flags Bitfield of AOM_CODEC_USE_* flags * \param[in] ver ABI version number. Must be set to - * VPX_ENCODER_ABI_VERSION - * \retval #VPX_CODEC_OK + * AOM_ENCODER_ABI_VERSION + * \retval #AOM_CODEC_OK * The decoder algorithm initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory allocation failed. */ -vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t *ctx, - vpx_codec_iface_t *iface, - const vpx_codec_enc_cfg_t *cfg, - vpx_codec_flags_t flags, int ver); +aom_codec_err_t aom_codec_enc_init_ver(aom_codec_ctx_t *ctx, + aom_codec_iface_t *iface, + const aom_codec_enc_cfg_t *cfg, + aom_codec_flags_t flags, int ver); -/*!\brief Convenience macro for vpx_codec_enc_init_ver() +/*!\brief Convenience macro for aom_codec_enc_init_ver() * * Ensures the ABI version parameter is properly set. */ -#define vpx_codec_enc_init(ctx, iface, cfg, flags) \ - vpx_codec_enc_init_ver(ctx, iface, cfg, flags, VPX_ENCODER_ABI_VERSION) +#define aom_codec_enc_init(ctx, iface, cfg, flags) \ + aom_codec_enc_init_ver(ctx, iface, cfg, flags, AOM_ENCODER_ABI_VERSION) /*!\brief Initialize multi-encoder instance * * Initializes multi-encoder context using the given interface. - * Applications should call the vpx_codec_enc_init_multi convenience macro + * Applications should call the aom_codec_enc_init_multi convenience macro * instead of this function directly, to ensure that the ABI version number * parameter is properly initialized. * @@ -620,26 +620,26 @@ * \param[in] iface Pointer to the algorithm interface to use. * \param[in] cfg Configuration to use, if known. May be NULL. * \param[in] num_enc Total number of encoders. - * \param[in] flags Bitfield of VPX_CODEC_USE_* flags + * \param[in] flags Bitfield of AOM_CODEC_USE_* flags * \param[in] dsf Pointer to down-sampling factors. * \param[in] ver ABI version number. Must be set to - * VPX_ENCODER_ABI_VERSION - * \retval #VPX_CODEC_OK + * AOM_ENCODER_ABI_VERSION + * \retval #AOM_CODEC_OK * The decoder algorithm initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory allocation failed. */ -vpx_codec_err_t vpx_codec_enc_init_multi_ver( - vpx_codec_ctx_t *ctx, vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg, - int num_enc, vpx_codec_flags_t flags, vpx_rational_t *dsf, int ver); +aom_codec_err_t aom_codec_enc_init_multi_ver( + aom_codec_ctx_t *ctx, aom_codec_iface_t *iface, aom_codec_enc_cfg_t *cfg, + int num_enc, aom_codec_flags_t flags, aom_rational_t *dsf, int ver); -/*!\brief Convenience macro for vpx_codec_enc_init_multi_ver() +/*!\brief Convenience macro for aom_codec_enc_init_multi_ver() * * Ensures the ABI version parameter is properly set. */ -#define vpx_codec_enc_init_multi(ctx, iface, cfg, num_enc, flags, dsf) \ - vpx_codec_enc_init_multi_ver(ctx, iface, cfg, num_enc, flags, dsf, \ - VPX_ENCODER_ABI_VERSION) +#define aom_codec_enc_init_multi(ctx, iface, cfg, num_enc, flags, dsf) \ + aom_codec_enc_init_multi_ver(ctx, iface, cfg, num_enc, flags, dsf, \ + AOM_ENCODER_ABI_VERSION) /*!\brief Get a default configuration * @@ -651,17 +651,17 @@ * * \param[in] iface Pointer to the algorithm interface to use. * \param[out] cfg Configuration buffer to populate. - * \param[in] reserved Must set to 0 for VP8 and VP9. + * \param[in] reserved Must set to 0 for VP8 and AV1. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The configuration was populated. - * \retval #VPX_CODEC_INCAPABLE + * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, or the usage value was not recognized. */ -vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface, - vpx_codec_enc_cfg_t *cfg, +aom_codec_err_t aom_codec_enc_config_default(aom_codec_iface_t *iface, + aom_codec_enc_cfg_t *cfg, unsigned int reserved); /*!\brief Set or change configuration @@ -671,15 +671,15 @@ * \param[in] ctx Pointer to this instance's context * \param[in] cfg Configuration buffer to use * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The configuration was populated. - * \retval #VPX_CODEC_INCAPABLE + * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, or the usage value was not recognized. */ -vpx_codec_err_t vpx_codec_enc_config_set(vpx_codec_ctx_t *ctx, - const vpx_codec_enc_cfg_t *cfg); +aom_codec_err_t aom_codec_enc_config_set(aom_codec_ctx_t *ctx, + const aom_codec_enc_cfg_t *cfg); /*!\brief Get global stream headers * @@ -692,14 +692,14 @@ * \retval Non-NULL * Pointer to buffer containing global header packet */ -vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t *ctx); +aom_fixed_buf_t *aom_codec_get_global_headers(aom_codec_ctx_t *ctx); -/*!\brief deadline parameter analogous to VPx REALTIME mode. */ -#define VPX_DL_REALTIME (1) -/*!\brief deadline parameter analogous to VPx GOOD QUALITY mode. */ -#define VPX_DL_GOOD_QUALITY (1000000) -/*!\brief deadline parameter analogous to VPx BEST QUALITY mode. */ -#define VPX_DL_BEST_QUALITY (0) +/*!\brief deadline parameter analogous to AVx REALTIME mode. */ +#define AOM_DL_REALTIME (1) +/*!\brief deadline parameter analogous to AVx GOOD QUALITY mode. */ +#define AOM_DL_GOOD_QUALITY (1000000) +/*!\brief deadline parameter analogous to AVx BEST QUALITY mode. */ +#define AOM_DL_BEST_QUALITY (0) /*!\brief Encode a frame * * Encodes a video frame at the given "presentation time." The presentation @@ -711,16 +711,16 @@ * implicit that limiting the available time to encode will degrade the * output quality. The encoder can be given an unlimited time to produce the * best possible frame by specifying a deadline of '0'. This deadline - * supercedes the VPx notion of "best quality, good quality, realtime". + * supercedes the AVx notion of "best quality, good quality, realtime". * Applications that wish to map these former settings to the new deadline - * based system can use the symbols #VPX_DL_REALTIME, #VPX_DL_GOOD_QUALITY, - * and #VPX_DL_BEST_QUALITY. + * based system can use the symbols #AOM_DL_REALTIME, #AOM_DL_GOOD_QUALITY, + * and #AOM_DL_BEST_QUALITY. * * When the last frame has been passed to the encoder, this function should * continue to be called, with the img parameter set to NULL. This will * signal the end-of-stream condition to the encoder and allow it to encode - * any held buffers. Encoding is complete when vpx_codec_encode() is called - * and vpx_codec_get_cx_data() returns no data. + * any held buffers. Encoding is complete when aom_codec_encode() is called + * and aom_codec_get_cx_data() returns no data. * * \param[in] ctx Pointer to this instance's context * \param[in] img Image data to encode, NULL to flush. @@ -729,23 +729,23 @@ * \param[in] flags Flags to use for encoding this frame. * \param[in] deadline Time to spend encoding, in microseconds. (0=infinite) * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The configuration was populated. - * \retval #VPX_CODEC_INCAPABLE + * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, the image format is unsupported, etc. */ -vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img, - vpx_codec_pts_t pts, unsigned long duration, - vpx_enc_frame_flags_t flags, +aom_codec_err_t aom_codec_encode(aom_codec_ctx_t *ctx, const aom_image_t *img, + aom_codec_pts_t pts, unsigned long duration, + aom_enc_frame_flags_t flags, unsigned long deadline); /*!\brief Set compressed data output buffer * * Sets the buffer that the codec should output the compressed data * into. This call effectively sets the buffer pointer returned in the - * next VPX_CODEC_CX_FRAME_PKT packet. Subsequent packets will be + * next AOM_CODEC_CX_FRAME_PKT packet. Subsequent packets will be * appended into this buffer. The buffer is preserved across frames, * so applications must periodically call this function after flushing * the accumulated compressed data to disk or to the network to reset @@ -772,20 +772,20 @@ * buffer. * * Applications \ref MUSTNOT call this function during iteration of - * vpx_codec_get_cx_data(). + * aom_codec_get_cx_data(). * * \param[in] ctx Pointer to this instance's context * \param[in] buf Buffer to store compressed data into * \param[in] pad_before Bytes to skip before writing compressed data * \param[in] pad_after Bytes to skip after writing compressed data * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The buffer was set successfully. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, the image format is unsupported, etc. */ -vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t *ctx, - const vpx_fixed_buf_t *buf, +aom_codec_err_t aom_codec_set_cx_data_buf(aom_codec_ctx_t *ctx, + const aom_fixed_buf_t *buf, unsigned int pad_before, unsigned int pad_after); @@ -793,17 +793,17 @@ * * Iterates over a list of data packets to be passed from the encoder to the * application. The different kinds of packets available are enumerated in - * #vpx_codec_cx_pkt_kind. + * #aom_codec_cx_pkt_kind. * - * #VPX_CODEC_CX_FRAME_PKT packets should be passed to the application's + * #AOM_CODEC_CX_FRAME_PKT packets should be passed to the application's * muxer. Multiple compressed frames may be in the list. - * #VPX_CODEC_STATS_PKT packets should be appended to a global buffer. + * #AOM_CODEC_STATS_PKT packets should be appended to a global buffer. * * The application \ref MUST silently ignore any packet kinds that it does * not recognize or support. * * The data buffers returned from this function are only guaranteed to be - * valid until the application makes another call to any vpx_codec_* function. + * valid until the application makes another call to any aom_codec_* function. * * \param[in] ctx Pointer to this instance's context * \param[in,out] iter Iterator storage, initialized to NULL @@ -812,8 +812,8 @@ * two-pass statistics, etc.) or NULL to signal end-of-list. * */ -const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx, - vpx_codec_iter_t *iter); +const aom_codec_cx_pkt_t *aom_codec_get_cx_data(aom_codec_ctx_t *ctx, + aom_codec_iter_t *iter); /*!\brief Get Preview Frame * @@ -827,10 +827,10 @@ * available. * */ -const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t *ctx); +const aom_image_t *aom_codec_get_preview_frame(aom_codec_ctx_t *ctx); /*!@} - end defgroup encoder*/ #ifdef __cplusplus } #endif -#endif // VPX_VPX_ENCODER_H_ +#endif // AOM_AOM_ENCODER_H_
diff --git a/aom/vpx_frame_buffer.h b/aom/aom_frame_buffer.h similarity index 76% rename from aom/vpx_frame_buffer.h rename to aom/aom_frame_buffer.h index 86945f7..15e06d8 100644 --- a/aom/vpx_frame_buffer.h +++ b/aom/aom_frame_buffer.h
@@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VPX_VPX_FRAME_BUFFER_H_ -#define VPX_VPX_FRAME_BUFFER_H_ +#ifndef AOM_AOM_FRAME_BUFFER_H_ +#define AOM_AOM_FRAME_BUFFER_H_ /*!\file * \brief Describes the decoder external frame buffer interface. @@ -19,28 +19,28 @@ extern "C" { #endif -#include "./vpx_integer.h" +#include "./aom_integer.h" /*!\brief The maximum number of work buffers used by libaom. * Support maximum 4 threads to decode video in parallel. * Each thread will use one work buffer. * TODO(hkuang): Add support to set number of worker threads dynamically. */ -#define VPX_MAXIMUM_WORK_BUFFERS 8 +#define AOM_MAXIMUM_WORK_BUFFERS 8 -/*!\brief The maximum number of reference buffers that a VP9 encoder may use. +/*!\brief The maximum number of reference buffers that a AV1 encoder may use. */ -#define VPX_MAXIMUM_REF_BUFFERS 8 +#define AOM_MAXIMUM_REF_BUFFERS 8 /*!\brief External frame buffer * * This structure holds allocated frame buffers used by the decoder. */ -typedef struct vpx_codec_frame_buffer { +typedef struct aom_codec_frame_buffer { uint8_t *data; /**< Pointer to the data buffer */ size_t size; /**< Size of data in bytes */ void *priv; /**< Frame's private data */ -} vpx_codec_frame_buffer_t; +} aom_codec_frame_buffer_t; /*!\brief get frame buffer callback prototype * @@ -51,17 +51,17 @@ * to the allocated size. The application does not need to align the allocated * data. The callback is triggered when the decoder needs a frame buffer to * decode a compressed image into. This function may be called more than once - * for every call to vpx_codec_decode. The application may set fb->priv to + * for every call to aom_codec_decode. The application may set fb->priv to * some data which will be passed back in the ximage and the release function * call. |fb| is guaranteed to not be NULL. On success the callback must * return 0. Any failure the callback must return a value less than 0. * * \param[in] priv Callback's private data * \param[in] new_size Size in bytes needed by the buffer - * \param[in,out] fb Pointer to vpx_codec_frame_buffer_t + * \param[in,out] fb Pointer to aom_codec_frame_buffer_t */ -typedef int (*vpx_get_frame_buffer_cb_fn_t)(void *priv, size_t min_size, - vpx_codec_frame_buffer_t *fb); +typedef int (*aom_get_frame_buffer_cb_fn_t)(void *priv, size_t min_size, + aom_codec_frame_buffer_t *fb); /*!\brief release frame buffer callback prototype * @@ -71,13 +71,13 @@ * a value less than 0. * * \param[in] priv Callback's private data - * \param[in] fb Pointer to vpx_codec_frame_buffer_t + * \param[in] fb Pointer to aom_codec_frame_buffer_t */ -typedef int (*vpx_release_frame_buffer_cb_fn_t)(void *priv, - vpx_codec_frame_buffer_t *fb); +typedef int (*aom_release_frame_buffer_cb_fn_t)(void *priv, + aom_codec_frame_buffer_t *fb); #ifdef __cplusplus } // extern "C" #endif -#endif // VPX_VPX_FRAME_BUFFER_H_ +#endif // AOM_AOM_FRAME_BUFFER_H_
diff --git a/aom/vpx_image.h b/aom/aom_image.h similarity index 61% rename from aom/vpx_image.h rename to aom/aom_image.h index d6d3166..1c0b2d5 100644 --- a/aom/vpx_image.h +++ b/aom/aom_image.h
@@ -9,11 +9,11 @@ */ /*!\file - * \brief Describes the vpx image descriptor and associated operations + * \brief Describes the aom image descriptor and associated operations * */ -#ifndef VPX_VPX_IMAGE_H_ -#define VPX_VPX_IMAGE_H_ +#ifndef AOM_AOM_IMAGE_H_ +#define AOM_AOM_IMAGE_H_ #ifdef __cplusplus extern "C" { @@ -27,68 +27,68 @@ * types, removing or reassigning enums, adding/removing/rearranging * fields to structures */ -#define VPX_IMAGE_ABI_VERSION (4) /**<\hideinitializer*/ +#define AOM_IMAGE_ABI_VERSION (4) /**<\hideinitializer*/ -#define VPX_IMG_FMT_PLANAR 0x100 /**< Image is a planar format. */ -#define VPX_IMG_FMT_UV_FLIP 0x200 /**< V plane precedes U in memory. */ -#define VPX_IMG_FMT_HAS_ALPHA 0x400 /**< Image has an alpha channel. */ -#define VPX_IMG_FMT_HIGHBITDEPTH 0x800 /**< Image uses 16bit framebuffer. */ +#define AOM_IMG_FMT_PLANAR 0x100 /**< Image is a planar format. */ +#define AOM_IMG_FMT_UV_FLIP 0x200 /**< V plane precedes U in memory. */ +#define AOM_IMG_FMT_HAS_ALPHA 0x400 /**< Image has an alpha channel. */ +#define AOM_IMG_FMT_HIGHBITDEPTH 0x800 /**< Image uses 16bit framebuffer. */ /*!\brief List of supported image formats */ -typedef enum vpx_img_fmt { - VPX_IMG_FMT_NONE, - VPX_IMG_FMT_RGB24, /**< 24 bit per pixel packed RGB */ - VPX_IMG_FMT_RGB32, /**< 32 bit per pixel packed 0RGB */ - VPX_IMG_FMT_RGB565, /**< 16 bit per pixel, 565 */ - VPX_IMG_FMT_RGB555, /**< 16 bit per pixel, 555 */ - VPX_IMG_FMT_UYVY, /**< UYVY packed YUV */ - VPX_IMG_FMT_YUY2, /**< YUYV packed YUV */ - VPX_IMG_FMT_YVYU, /**< YVYU packed YUV */ - VPX_IMG_FMT_BGR24, /**< 24 bit per pixel packed BGR */ - VPX_IMG_FMT_RGB32_LE, /**< 32 bit packed BGR0 */ - VPX_IMG_FMT_ARGB, /**< 32 bit packed ARGB, alpha=255 */ - VPX_IMG_FMT_ARGB_LE, /**< 32 bit packed BGRA, alpha=255 */ - VPX_IMG_FMT_RGB565_LE, /**< 16 bit per pixel, gggbbbbb rrrrrggg */ - VPX_IMG_FMT_RGB555_LE, /**< 16 bit per pixel, gggbbbbb 0rrrrrgg */ - VPX_IMG_FMT_YV12 = - VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP | 1, /**< planar YVU */ - VPX_IMG_FMT_I420 = VPX_IMG_FMT_PLANAR | 2, - VPX_IMG_FMT_VPXYV12 = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP | - 3, /** < planar 4:2:0 format with vpx color space */ - VPX_IMG_FMT_VPXI420 = VPX_IMG_FMT_PLANAR | 4, - VPX_IMG_FMT_I422 = VPX_IMG_FMT_PLANAR | 5, - VPX_IMG_FMT_I444 = VPX_IMG_FMT_PLANAR | 6, - VPX_IMG_FMT_I440 = VPX_IMG_FMT_PLANAR | 7, - VPX_IMG_FMT_444A = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_HAS_ALPHA | 6, - VPX_IMG_FMT_I42016 = VPX_IMG_FMT_I420 | VPX_IMG_FMT_HIGHBITDEPTH, - VPX_IMG_FMT_I42216 = VPX_IMG_FMT_I422 | VPX_IMG_FMT_HIGHBITDEPTH, - VPX_IMG_FMT_I44416 = VPX_IMG_FMT_I444 | VPX_IMG_FMT_HIGHBITDEPTH, - VPX_IMG_FMT_I44016 = VPX_IMG_FMT_I440 | VPX_IMG_FMT_HIGHBITDEPTH -} vpx_img_fmt_t; /**< alias for enum vpx_img_fmt */ +typedef enum aom_img_fmt { + AOM_IMG_FMT_NONE, + AOM_IMG_FMT_RGB24, /**< 24 bit per pixel packed RGB */ + AOM_IMG_FMT_RGB32, /**< 32 bit per pixel packed 0RGB */ + AOM_IMG_FMT_RGB565, /**< 16 bit per pixel, 565 */ + AOM_IMG_FMT_RGB555, /**< 16 bit per pixel, 555 */ + AOM_IMG_FMT_UYVY, /**< UYVY packed YUV */ + AOM_IMG_FMT_YUY2, /**< YUYV packed YUV */ + AOM_IMG_FMT_YVYU, /**< YVYU packed YUV */ + AOM_IMG_FMT_BGR24, /**< 24 bit per pixel packed BGR */ + AOM_IMG_FMT_RGB32_LE, /**< 32 bit packed BGR0 */ + AOM_IMG_FMT_ARGB, /**< 32 bit packed ARGB, alpha=255 */ + AOM_IMG_FMT_ARGB_LE, /**< 32 bit packed BGRA, alpha=255 */ + AOM_IMG_FMT_RGB565_LE, /**< 16 bit per pixel, gggbbbbb rrrrrggg */ + AOM_IMG_FMT_RGB555_LE, /**< 16 bit per pixel, gggbbbbb 0rrrrrgg */ + AOM_IMG_FMT_YV12 = + AOM_IMG_FMT_PLANAR | AOM_IMG_FMT_UV_FLIP | 1, /**< planar YVU */ + AOM_IMG_FMT_I420 = AOM_IMG_FMT_PLANAR | 2, + AOM_IMG_FMT_AOMYV12 = AOM_IMG_FMT_PLANAR | AOM_IMG_FMT_UV_FLIP | + 3, /** < planar 4:2:0 format with aom color space */ + AOM_IMG_FMT_AOMI420 = AOM_IMG_FMT_PLANAR | 4, + AOM_IMG_FMT_I422 = AOM_IMG_FMT_PLANAR | 5, + AOM_IMG_FMT_I444 = AOM_IMG_FMT_PLANAR | 6, + AOM_IMG_FMT_I440 = AOM_IMG_FMT_PLANAR | 7, + AOM_IMG_FMT_444A = AOM_IMG_FMT_PLANAR | AOM_IMG_FMT_HAS_ALPHA | 6, + AOM_IMG_FMT_I42016 = AOM_IMG_FMT_I420 | AOM_IMG_FMT_HIGHBITDEPTH, + AOM_IMG_FMT_I42216 = AOM_IMG_FMT_I422 | AOM_IMG_FMT_HIGHBITDEPTH, + AOM_IMG_FMT_I44416 = AOM_IMG_FMT_I444 | AOM_IMG_FMT_HIGHBITDEPTH, + AOM_IMG_FMT_I44016 = AOM_IMG_FMT_I440 | AOM_IMG_FMT_HIGHBITDEPTH +} aom_img_fmt_t; /**< alias for enum aom_img_fmt */ /*!\brief List of supported color spaces */ -typedef enum vpx_color_space { - VPX_CS_UNKNOWN = 0, /**< Unknown */ - VPX_CS_BT_601 = 1, /**< BT.601 */ - VPX_CS_BT_709 = 2, /**< BT.709 */ - VPX_CS_SMPTE_170 = 3, /**< SMPTE.170 */ - VPX_CS_SMPTE_240 = 4, /**< SMPTE.240 */ - VPX_CS_BT_2020 = 5, /**< BT.2020 */ - VPX_CS_RESERVED = 6, /**< Reserved */ - VPX_CS_SRGB = 7 /**< sRGB */ -} vpx_color_space_t; /**< alias for enum vpx_color_space */ +typedef enum aom_color_space { + AOM_CS_UNKNOWN = 0, /**< Unknown */ + AOM_CS_BT_601 = 1, /**< BT.601 */ + AOM_CS_BT_709 = 2, /**< BT.709 */ + AOM_CS_SMPTE_170 = 3, /**< SMPTE.170 */ + AOM_CS_SMPTE_240 = 4, /**< SMPTE.240 */ + AOM_CS_BT_2020 = 5, /**< BT.2020 */ + AOM_CS_RESERVED = 6, /**< Reserved */ + AOM_CS_SRGB = 7 /**< sRGB */ +} aom_color_space_t; /**< alias for enum aom_color_space */ /*!\brief List of supported color range */ -typedef enum vpx_color_range { - VPX_CR_STUDIO_RANGE = 0, /**< Y [16..235], UV [16..240] */ - VPX_CR_FULL_RANGE = 1 /**< YUV/RGB [0..255] */ -} vpx_color_range_t; /**< alias for enum vpx_color_range */ +typedef enum aom_color_range { + AOM_CR_STUDIO_RANGE = 0, /**< Y [16..235], UV [16..240] */ + AOM_CR_FULL_RANGE = 1 /**< YUV/RGB [0..255] */ +} aom_color_range_t; /**< alias for enum aom_color_range */ /**\brief Image Descriptor */ -typedef struct vpx_image { - vpx_img_fmt_t fmt; /**< Image Format */ - vpx_color_space_t cs; /**< Color Space */ - vpx_color_range_t range; /**< Color Range */ +typedef struct aom_image { + aom_img_fmt_t fmt; /**< Image Format */ + aom_color_space_t cs; /**< Color Space */ + aom_color_range_t range; /**< Color Range */ /* Image storage dimensions */ unsigned int w; /**< Stored image width */ @@ -108,11 +108,11 @@ unsigned int y_chroma_shift; /**< subsampling order, Y */ /* Image data pointers. */ -#define VPX_PLANE_PACKED 0 /**< To be used for all packed formats */ -#define VPX_PLANE_Y 0 /**< Y (Luminance) plane */ -#define VPX_PLANE_U 1 /**< U (Chroma) plane */ -#define VPX_PLANE_V 2 /**< V (Chroma) plane */ -#define VPX_PLANE_ALPHA 3 /**< A (Transparency) plane */ +#define AOM_PLANE_PACKED 0 /**< To be used for all packed formats */ +#define AOM_PLANE_Y 0 /**< Y (Luminance) plane */ +#define AOM_PLANE_U 1 /**< U (Chroma) plane */ +#define AOM_PLANE_V 2 /**< V (Chroma) plane */ +#define AOM_PLANE_ALPHA 3 /**< A (Transparency) plane */ unsigned char *planes[4]; /**< pointer to the top left pixel for each plane */ int stride[4]; /**< stride between rows for each plane */ @@ -129,15 +129,15 @@ int self_allocd; /**< private */ void *fb_priv; /**< Frame buffer data associated with the image. */ -} vpx_image_t; /**< alias for struct vpx_image */ +} aom_image_t; /**< alias for struct aom_image */ /**\brief Representation of a rectangle on a surface */ -typedef struct vpx_image_rect { +typedef struct aom_image_rect { unsigned int x; /**< leftmost column */ unsigned int y; /**< topmost row */ unsigned int w; /**< width */ unsigned int h; /**< height */ -} vpx_image_rect_t; /**< alias for struct vpx_image_rect */ +} aom_image_rect_t; /**< alias for struct aom_image_rect */ /*!\brief Open a descriptor, allocating storage for the underlying image * @@ -157,7 +157,7 @@ * parameter is non-null, the value of the img parameter will be * returned. */ -vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt, +aom_image_t *aom_img_alloc(aom_image_t *img, aom_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align); @@ -180,7 +180,7 @@ * parameter is non-null, the value of the img parameter will be * returned. */ -vpx_image_t *vpx_img_wrap(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, +aom_image_t *aom_img_wrap(aom_image_t *img, aom_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align, unsigned char *img_data); @@ -197,7 +197,7 @@ * * \return 0 if the requested rectangle is valid, nonzero otherwise. */ -int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y, +int aom_img_set_rect(aom_image_t *img, unsigned int x, unsigned int y, unsigned int w, unsigned int h); /*!\brief Flip the image vertically (top for bottom) @@ -207,7 +207,7 @@ * * \param[in] img Image descriptor */ -void vpx_img_flip(vpx_image_t *img); +void aom_img_flip(aom_image_t *img); /*!\brief Close an image descriptor * @@ -215,10 +215,10 @@ * * \param[in] img Image descriptor */ -void vpx_img_free(vpx_image_t *img); +void aom_img_free(aom_image_t *img); #ifdef __cplusplus } // extern "C" #endif -#endif // VPX_VPX_IMAGE_H_ +#endif // AOM_AOM_IMAGE_H_
diff --git a/aom/vpx_integer.h b/aom/aom_integer.h similarity index 82% rename from aom/vpx_integer.h rename to aom/aom_integer.h index 09bad92..0148e66 100644 --- a/aom/vpx_integer.h +++ b/aom/aom_integer.h
@@ -8,22 +8,22 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VPX_VPX_INTEGER_H_ -#define VPX_VPX_INTEGER_H_ +#ifndef AOM_AOM_INTEGER_H_ +#define AOM_AOM_INTEGER_H_ /* get ptrdiff_t, size_t, wchar_t, NULL */ #include <stddef.h> #if defined(_MSC_VER) -#define VPX_FORCE_INLINE __forceinline -#define VPX_INLINE __inline +#define AOM_FORCE_INLINE __forceinline +#define AOM_INLINE __inline #else -#define VPX_FORCE_INLINE __inline__ __attribute__(always_inline) +#define AOM_FORCE_INLINE __inline__ __attribute__(always_inline) // TODO(jbb): Allow a way to force inline off for older compilers. -#define VPX_INLINE inline +#define AOM_INLINE inline #endif -#if defined(VPX_EMULATE_INTTYPES) +#if defined(AOM_EMULATE_INTTYPES) typedef signed char int8_t; typedef signed short int16_t; typedef signed int int32_t; @@ -60,4 +60,4 @@ #include <inttypes.h> #endif -#endif // VPX_VPX_INTEGER_H_ +#endif // AOM_AOM_INTEGER_H_
diff --git a/aom/vp8cx.h b/aom/aomcx.h similarity index 61% rename from aom/vp8cx.h rename to aom/aomcx.h index 087604d..903068f 100644 --- a/aom/vp8cx.h +++ b/aom/aomcx.h
@@ -7,33 +7,33 @@ * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ -#ifndef VPX_VP8CX_H_ -#define VPX_VP8CX_H_ +#ifndef AOM_AOMCX_H_ +#define AOM_AOMCX_H_ -/*!\defgroup vp8_encoder WebM VP8/VP9 Encoder +/*!\defgroup vp8_encoder WebM VP8/AV1 Encoder * \ingroup vp8 * * @{ */ -#include "./vp8.h" -#include "./vpx_encoder.h" +#include "./aom.h" +#include "./aom_encoder.h" /*!\file - * \brief Provides definitions for using VP8 or VP9 encoder algorithm within the - * vpx Codec Interface. + * \brief Provides definitions for using VP8 or AV1 encoder algorithm within the + * aom Codec Interface. */ #ifdef __cplusplus extern "C" { #endif -/*!\name Algorithm interface for VP10 +/*!\name Algorithm interface for AV1 * - * This interface provides the capability to encode raw VP10 streams. + * This interface provides the capability to encode raw AV1 streams. * @{ */ -extern vpx_codec_iface_t vpx_codec_vp10_cx_algo; -extern vpx_codec_iface_t *vpx_codec_vp10_cx(void); +extern aom_codec_iface_t aom_codec_av1_cx_algo; +extern aom_codec_iface_t *aom_codec_av1_cx(void); /*!@} - end algorithm interface member group*/ /* @@ -46,7 +46,7 @@ * predictor. When not set, the encoder will choose whether to use the * last frame or not automatically. */ -#define VP8_EFLAG_NO_REF_LAST (1 << 16) +#define AOM_EFLAG_NO_REF_LAST (1 << 16) /*!\brief Don't reference the golden frame * @@ -54,7 +54,7 @@ * predictor. When not set, the encoder will choose whether to use the * golden frame or not automatically. */ -#define VP8_EFLAG_NO_REF_GF (1 << 17) +#define AOM_EFLAG_NO_REF_GF (1 << 17) /*!\brief Don't reference the alternate reference frame * @@ -62,81 +62,81 @@ * predictor. When not set, the encoder will choose whether to use the * alt ref frame or not automatically. */ -#define VP8_EFLAG_NO_REF_ARF (1 << 21) +#define AOM_EFLAG_NO_REF_ARF (1 << 21) /*!\brief Don't update the last frame * * When this flag is set, the encoder will not update the last frame with * the contents of the current frame. */ -#define VP8_EFLAG_NO_UPD_LAST (1 << 18) +#define AOM_EFLAG_NO_UPD_LAST (1 << 18) /*!\brief Don't update the golden frame * * When this flag is set, the encoder will not update the golden frame with * the contents of the current frame. */ -#define VP8_EFLAG_NO_UPD_GF (1 << 22) +#define AOM_EFLAG_NO_UPD_GF (1 << 22) /*!\brief Don't update the alternate reference frame * * When this flag is set, the encoder will not update the alt ref frame with * the contents of the current frame. */ -#define VP8_EFLAG_NO_UPD_ARF (1 << 23) +#define AOM_EFLAG_NO_UPD_ARF (1 << 23) /*!\brief Force golden frame update * * When this flag is set, the encoder copy the contents of the current frame * to the golden frame buffer. */ -#define VP8_EFLAG_FORCE_GF (1 << 19) +#define AOM_EFLAG_FORCE_GF (1 << 19) /*!\brief Force alternate reference frame update * * When this flag is set, the encoder copy the contents of the current frame * to the alternate reference frame buffer. */ -#define VP8_EFLAG_FORCE_ARF (1 << 24) +#define AOM_EFLAG_FORCE_ARF (1 << 24) /*!\brief Disable entropy update * * When this flag is set, the encoder will not update its internal entropy * model based on the entropy of this frame. */ -#define VP8_EFLAG_NO_UPD_ENTROPY (1 << 20) +#define AOM_EFLAG_NO_UPD_ENTROPY (1 << 20) -/*!\brief VPx encoder control functions +/*!\brief AVx encoder control functions * - * This set of macros define the control functions available for VPx + * This set of macros define the control functions available for AVx * encoder interface. * - * \sa #vpx_codec_control + * \sa #aom_codec_control */ -enum vp8e_enc_control_id { +enum aome_enc_control_id { /*!\brief Codec control function to set which reference frame encoder can use. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_USE_REFERENCE = 7, + AOME_USE_REFERENCE = 7, /*!\brief Codec control function to pass an ROI map to encoder. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_ROI_MAP = 8, + AOME_SET_ROI_MAP = 8, /*!\brief Codec control function to pass an Active map to encoder. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_ACTIVEMAP, + AOME_SET_ACTIVEMAP, /*!\brief Codec control function to set encoder scaling mode. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_SCALEMODE = 11, + AOME_SET_SCALEMODE = 11, /*!\brief Codec control function to set encoder internal speed settings. * @@ -145,25 +145,25 @@ * speed at the expense of quality. * * \note Valid range for VP8: -16..16 - * \note Valid range for VP9: -8..8 + * \note Valid range for AV1: -8..8 * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_CPUUSED = 13, + AOME_SET_CPUUSED = 13, /*!\brief Codec control function to enable automatic set and use alf frames. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_ENABLEAUTOALTREF, + AOME_SET_ENABLEAUTOALTREF, #if CONFIG_EXT_REFS /*!\brief Codec control function to enable automatic set and use * bwd-pred frames. * - * Supported in codecs: VP10 + * Supported in codecs: AV1 */ - VP8E_SET_ENABLEAUTOBWDREF, + AOME_SET_ENABLEAUTOBWDREF, #endif // CONFIG_EXT_REFS /*!\brief control function to set noise sensitivity @@ -173,73 +173,73 @@ * * Supported in codecs: VP8 */ - VP8E_SET_NOISE_SENSITIVITY, + AOME_SET_NOISE_SENSITIVITY, /*!\brief Codec control function to set sharpness. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_SHARPNESS, + AOME_SET_SHARPNESS, /*!\brief Codec control function to set the threshold for MBs treated static. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_STATIC_THRESHOLD, + AOME_SET_STATIC_THRESHOLD, /*!\brief Codec control function to set the number of token partitions. * * Supported in codecs: VP8 */ - VP8E_SET_TOKEN_PARTITIONS, + AOME_SET_TOKEN_PARTITIONS, /*!\brief Codec control function to get last quantizer chosen by the encoder. * * Return value uses internal quantizer scale defined by the codec. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_GET_LAST_QUANTIZER, + AOME_GET_LAST_QUANTIZER, /*!\brief Codec control function to get last quantizer chosen by the encoder. * * Return value uses the 0..63 scale as used by the rc_*_quantizer config * parameters. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_GET_LAST_QUANTIZER_64, + AOME_GET_LAST_QUANTIZER_64, /*!\brief Codec control function to set the max no of frames to create arf. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_ARNR_MAXFRAMES, + AOME_SET_ARNR_MAXFRAMES, /*!\brief Codec control function to set the filter strength for the arf. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_ARNR_STRENGTH, + AOME_SET_ARNR_STRENGTH, /*!\deprecated control function to set the filter type to use for the arf. */ - VP8E_SET_ARNR_TYPE, + AOME_SET_ARNR_TYPE, /*!\brief Codec control function to set visual tuning. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_TUNING, + AOME_SET_TUNING, /*!\brief Codec control function to set constrained quality level. * - * \attention For this value to be used vpx_codec_enc_cfg_t::g_usage must be - * set to #VPX_CQ. + * \attention For this value to be used aom_codec_enc_cfg_t::g_usage must be + * set to #AOM_CQ. * \note Valid range: 0..63 * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_CQ_LEVEL, + AOME_SET_CQ_LEVEL, /*!\brief Codec control function to set Max data rate for Intra frames. * @@ -252,15 +252,15 @@ * For example, to allocate no more than 4.5 frames worth of bitrate * to a keyframe, set this to 450. * - * Supported in codecs: VP8, VP9 + * Supported in codecs: VP8, AV1 */ - VP8E_SET_MAX_INTRA_BITRATE_PCT, + AOME_SET_MAX_INTRA_BITRATE_PCT, /*!\brief Codec control function to set reference and update frame flags. * * Supported in codecs: VP8 */ - VP8E_SET_FRAME_FLAGS, + AOME_SET_FRAME_FLAGS, /*!\brief Codec control function to set max data rate for Inter frames. * @@ -273,9 +273,9 @@ * For example, to allow no more than 4.5 frames worth of bitrate * to an inter frame, set this to 450. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_MAX_INTER_BITRATE_PCT, + AV1E_SET_MAX_INTER_BITRATE_PCT, /*!\brief Boost percentage for Golden Frame in CBR mode. * @@ -288,9 +288,9 @@ * For example, to allow 100% more bits, i.e, 2X, in a golden frame * than average frame, set this to 100. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_GF_CBR_BOOST_PCT, + AV1E_SET_GF_CBR_BOOST_PCT, /*!\brief Codec control function to set encoder screen content mode. * @@ -298,11 +298,11 @@ * * Supported in codecs: VP8 */ - VP8E_SET_SCREEN_CONTENT_MODE, + AOME_SET_SCREEN_CONTENT_MODE, /*!\brief Codec control function to set lossless encoding mode. * - * VP9 can operate in lossless encoding mode, in which the bitstream + * AV1 can operate in lossless encoding mode, in which the bitstream * produced will be able to decode and reconstruct a perfect copy of * input source. This control function provides a mean to switch encoder * into lossless coding mode(1) or normal coding mode(0) that may be lossy. @@ -311,9 +311,9 @@ * * By default, encoder operates in normal coding mode (maybe lossy). * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_LOSSLESS, + AV1E_SET_LOSSLESS, #if CONFIG_AOM_QM /*!\brief Codec control function to encode with quantisation matrices. * @@ -327,7 +327,7 @@ * Supported in codecs: AOM */ - VP9E_SET_ENABLE_QM, + AV1E_SET_ENABLE_QM, /*!\brief Codec control function to set the min quant matrix flatness. * @@ -341,7 +341,7 @@ * * Supported in codecs: AOM */ - VP9E_SET_QM_MIN, + AV1E_SET_QM_MIN, /*!\brief Codec control function to set the max quant matrix flatness. * @@ -354,12 +354,12 @@ * * Supported in codecs: AOM */ - VP9E_SET_QM_MAX, + AV1E_SET_QM_MAX, #endif /*!\brief Codec control function to set number of tile columns. * - * In encoding and decoding, VP9 allows an input image frame be partitioned + * In encoding and decoding, AV1 allows an input image frame be partitioned * into separated vertical tile columns, which can be encoded or decoded * independently. This enables easy implementation of parallel encoding and * decoding. This control requests the encoder to use column tiles in @@ -376,13 +376,13 @@ * * By default, the value is 0, i.e. one single column tile for entire image. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_TILE_COLUMNS, + AV1E_SET_TILE_COLUMNS, /*!\brief Codec control function to set number of tile rows. * - * In encoding and decoding, VP9 allows an input image frame be partitioned + * In encoding and decoding, AV1 allows an input image frame be partitioned * into separated horizontal tile rows. Tile rows are encoded or decoded * sequentially. Even though encoding/decoding of later tile rows depends on * earlier ones, this allows the encoder to output data packets for tile rows @@ -396,13 +396,13 @@ * * By default, the value is 0, i.e. one single row tile for entire image. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_TILE_ROWS, + AV1E_SET_TILE_ROWS, /*!\brief Codec control function to enable frame parallel decoding feature. * - * VP9 has a bitstream feature to reduce decoding dependency between frames + * AV1 has a bitstream feature to reduce decoding dependency between frames * by turning off backward update of probability context used in encoding * and decoding. This allows staged parallel processing of more than one * video frames in the decoder. This control function provides a mean to @@ -410,26 +410,26 @@ * * By default, this feature is off. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_FRAME_PARALLEL_DECODING, + AV1E_SET_FRAME_PARALLEL_DECODING, /*!\brief Codec control function to set adaptive quantization mode. * - * VP9 has a segment based feature that allows encoder to adaptively change + * AV1 has a segment based feature that allows encoder to adaptively change * quantization parameter for each segment within a frame to improve the * subjective quality. This control makes encoder operate in one of the * several AQ_modes supported. * * By default, encoder operates with AQ_Mode 0(adaptive quantization off). * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_AQ_MODE, + AV1E_SET_AQ_MODE, /*!\brief Codec control function to enable/disable periodic Q boost. * - * One VP9 encoder speed feature is to enable quality boost by lowering + * One AV1 encoder speed feature is to enable quality boost by lowering * frame level Q periodically. This control function provides a mean to * turn on/off this feature. * 0 = off @@ -438,26 +438,26 @@ * By default, the encoder is allowed to use this feature for appropriate * encoding modes. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_FRAME_PERIODIC_BOOST, + AV1E_SET_FRAME_PERIODIC_BOOST, /*!\brief Codec control function to set noise sensitivity. * * 0: off, 1: On(YOnly) * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_NOISE_SENSITIVITY, + AV1E_SET_NOISE_SENSITIVITY, /*!\brief Codec control function to set content type. * \note Valid parameter range: - * VPX_CONTENT_DEFAULT = Regular video content (Default) - * VPX_CONTENT_SCREEN = Screen capture content + * AOM_CONTENT_DEFAULT = Regular video content (Default) + * AOM_CONTENT_SCREEN = Screen capture content * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_TUNE_CONTENT, + AV1E_SET_TUNE_CONTENT, /*!\brief Codec control function to set color space info. * \note Valid ranges: 0..7, default is "UNKNOWN". @@ -470,127 +470,127 @@ * 6 = RESERVED * 7 = SRGB * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_COLOR_SPACE, + AV1E_SET_COLOR_SPACE, /*!\brief Codec control function to set minimum interval between GF/ARF frames * * By default the value is set as 4. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_MIN_GF_INTERVAL, + AV1E_SET_MIN_GF_INTERVAL, /*!\brief Codec control function to set minimum interval between GF/ARF frames * * By default the value is set as 16. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_MAX_GF_INTERVAL, + AV1E_SET_MAX_GF_INTERVAL, /*!\brief Codec control function to get an Active map back from the encoder. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_GET_ACTIVEMAP, + AV1E_GET_ACTIVEMAP, /*!\brief Codec control function to set color range bit. * \note Valid ranges: 0..1, default is 0 * 0 = Limited range (16..235 or HBD equivalent) * 1 = Full range (0..255 or HBD equivalent) * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_COLOR_RANGE, + AV1E_SET_COLOR_RANGE, /*!\brief Codec control function to set intended rendering image size. * * By default, this is identical to the image size in pixels. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_RENDER_SIZE, + AV1E_SET_RENDER_SIZE, /*!\brief Codec control function to set target level. * * 255: off (default); 0: only keep level stats; 10: target for level 1.0; * 11: target for level 1.1; ... 62: target for level 6.2 * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_SET_TARGET_LEVEL, + AV1E_SET_TARGET_LEVEL, /*!\brief Codec control function to get bitstream level. * - * Supported in codecs: VP9 + * Supported in codecs: AV1 */ - VP9E_GET_LEVEL, + AV1E_GET_LEVEL, /*!\brief Codec control function to set intended superblock size. * * By default, the superblock size is determined separately for each * frame by the encoder. * - * Supported in codecs: VP10 + * Supported in codecs: AV1 */ - VP10E_SET_SUPERBLOCK_SIZE, + AV1E_SET_SUPERBLOCK_SIZE, }; -/*!\brief vpx 1-D scaling mode +/*!\brief aom 1-D scaling mode * - * This set of constants define 1-D vpx scaling modes + * This set of constants define 1-D aom scaling modes */ -typedef enum vpx_scaling_mode_1d { - VP8E_NORMAL = 0, - VP8E_FOURFIVE = 1, - VP8E_THREEFIVE = 2, - VP8E_ONETWO = 3 -} VPX_SCALING_MODE; +typedef enum aom_scaling_mode_1d { + AOME_NORMAL = 0, + AOME_FOURFIVE = 1, + AOME_THREEFIVE = 2, + AOME_ONETWO = 3 +} AOM_SCALING_MODE; -/*!\brief vpx region of interest map +/*!\brief aom region of interest map * * These defines the data structures for the region of interest map * */ -typedef struct vpx_roi_map { +typedef struct aom_roi_map { /*! An id between 0 and 3 for each 16x16 region within a frame. */ unsigned char *roi_map; unsigned int rows; /**< Number of rows. */ unsigned int cols; /**< Number of columns. */ - // TODO(paulwilkins): broken for VP9 which has 8 segments + // TODO(paulwilkins): broken for AV1 which has 8 segments // q and loop filter deltas for each segment // (see MAX_MB_SEGMENTS) int delta_q[4]; /**< Quantizer deltas. */ int delta_lf[4]; /**< Loop filter deltas. */ /*! Static breakout threshold for each segment. */ unsigned int static_threshold[4]; -} vpx_roi_map_t; +} aom_roi_map_t; -/*!\brief vpx active region map +/*!\brief aom active region map * * These defines the data structures for active region map * */ -typedef struct vpx_active_map { +typedef struct aom_active_map { /*!\brief specify an on (1) or off (0) each 16x16 region within a frame */ unsigned char *active_map; unsigned int rows; /**< number of rows */ unsigned int cols; /**< number of cols */ -} vpx_active_map_t; +} aom_active_map_t; -/*!\brief vpx image scaling mode +/*!\brief aom image scaling mode * * This defines the data structure for image scaling mode * */ -typedef struct vpx_scaling_mode { - VPX_SCALING_MODE h_scaling_mode; /**< horizontal scaling mode */ - VPX_SCALING_MODE v_scaling_mode; /**< vertical scaling mode */ -} vpx_scaling_mode_t; +typedef struct aom_scaling_mode { + AOM_SCALING_MODE h_scaling_mode; /**< horizontal scaling mode */ + AOM_SCALING_MODE v_scaling_mode; /**< vertical scaling mode */ +} aom_scaling_mode_t; /*!\brief VP8 token partition mode * @@ -600,159 +600,159 @@ */ typedef enum { - VP8_ONE_TOKENPARTITION = 0, - VP8_TWO_TOKENPARTITION = 1, - VP8_FOUR_TOKENPARTITION = 2, - VP8_EIGHT_TOKENPARTITION = 3 -} vp8e_token_partitions; + AOM_ONE_TOKENPARTITION = 0, + AOM_TWO_TOKENPARTITION = 1, + AOM_FOUR_TOKENPARTITION = 2, + AOM_EIGHT_TOKENPARTITION = 3 +} aome_token_partitions; -/*!brief VP9 encoder content type */ +/*!brief AV1 encoder content type */ typedef enum { - VPX_CONTENT_DEFAULT, - VPX_CONTENT_SCREEN, - VPX_CONTENT_INVALID -} vpx_tune_content; + AOM_CONTENT_DEFAULT, + AOM_CONTENT_SCREEN, + AOM_CONTENT_INVALID +} aom_tune_content; /*!\brief VP8 model tuning parameters * * Changes the encoder to tune for certain types of input material. * */ -typedef enum { VPX_TUNE_PSNR, VPX_TUNE_SSIM } vpx_tune_metric; +typedef enum { AOM_TUNE_PSNR, AOM_TUNE_SSIM } aom_tune_metric; /*!\cond */ /*!\brief VP8 encoder control function parameter type * * Defines the data types that VP8E control functions take. Note that - * additional common controls are defined in vp8.h + * additional common controls are defined in aom.h * */ -VPX_CTRL_USE_TYPE_DEPRECATED(VP8E_USE_REFERENCE, int) -#define VPX_CTRL_VP8E_USE_REFERENCE -VPX_CTRL_USE_TYPE(VP8E_SET_FRAME_FLAGS, int) -#define VPX_CTRL_VP8E_SET_FRAME_FLAGS -VPX_CTRL_USE_TYPE(VP8E_SET_ROI_MAP, vpx_roi_map_t *) -#define VPX_CTRL_VP8E_SET_ROI_MAP -VPX_CTRL_USE_TYPE(VP8E_SET_ACTIVEMAP, vpx_active_map_t *) -#define VPX_CTRL_VP8E_SET_ACTIVEMAP -VPX_CTRL_USE_TYPE(VP8E_SET_SCALEMODE, vpx_scaling_mode_t *) -#define VPX_CTRL_VP8E_SET_SCALEMODE +AOM_CTRL_USE_TYPE_DEPRECATED(AOME_USE_REFERENCE, int) +#define AOM_CTRL_AOME_USE_REFERENCE +AOM_CTRL_USE_TYPE(AOME_SET_FRAME_FLAGS, int) +#define AOM_CTRL_AOME_SET_FRAME_FLAGS +AOM_CTRL_USE_TYPE(AOME_SET_ROI_MAP, aom_roi_map_t *) +#define AOM_CTRL_AOME_SET_ROI_MAP +AOM_CTRL_USE_TYPE(AOME_SET_ACTIVEMAP, aom_active_map_t *) +#define AOM_CTRL_AOME_SET_ACTIVEMAP +AOM_CTRL_USE_TYPE(AOME_SET_SCALEMODE, aom_scaling_mode_t *) +#define AOM_CTRL_AOME_SET_SCALEMODE -VPX_CTRL_USE_TYPE(VP8E_SET_CPUUSED, int) -#define VPX_CTRL_VP8E_SET_CPUUSED -VPX_CTRL_USE_TYPE(VP8E_SET_ENABLEAUTOALTREF, unsigned int) -#define VPX_CTRL_VP8E_SET_ENABLEAUTOALTREF +AOM_CTRL_USE_TYPE(AOME_SET_CPUUSED, int) +#define AOM_CTRL_AOME_SET_CPUUSED +AOM_CTRL_USE_TYPE(AOME_SET_ENABLEAUTOALTREF, unsigned int) +#define AOM_CTRL_AOME_SET_ENABLEAUTOALTREF #if CONFIG_EXT_REFS -VPX_CTRL_USE_TYPE(VP8E_SET_ENABLEAUTOBWDREF, unsigned int) -#define VPX_CTRL_VP8E_SET_ENABLEAUTOBWDREF +AOM_CTRL_USE_TYPE(AOME_SET_ENABLEAUTOBWDREF, unsigned int) +#define AOM_CTRL_AOME_SET_ENABLEAUTOBWDREF #endif // CONFIG_EXT_REFS -VPX_CTRL_USE_TYPE(VP8E_SET_NOISE_SENSITIVITY, unsigned int) -#define VPX_CTRL_VP8E_SET_NOISE_SENSITIVITY -VPX_CTRL_USE_TYPE(VP8E_SET_SHARPNESS, unsigned int) -#define VPX_CTRL_VP8E_SET_SHARPNESS -VPX_CTRL_USE_TYPE(VP8E_SET_STATIC_THRESHOLD, unsigned int) -#define VPX_CTRL_VP8E_SET_STATIC_THRESHOLD -VPX_CTRL_USE_TYPE(VP8E_SET_TOKEN_PARTITIONS, int) /* vp8e_token_partitions */ -#define VPX_CTRL_VP8E_SET_TOKEN_PARTITIONS +AOM_CTRL_USE_TYPE(AOME_SET_NOISE_SENSITIVITY, unsigned int) +#define AOM_CTRL_AOME_SET_NOISE_SENSITIVITY +AOM_CTRL_USE_TYPE(AOME_SET_SHARPNESS, unsigned int) +#define AOM_CTRL_AOME_SET_SHARPNESS +AOM_CTRL_USE_TYPE(AOME_SET_STATIC_THRESHOLD, unsigned int) +#define AOM_CTRL_AOME_SET_STATIC_THRESHOLD +AOM_CTRL_USE_TYPE(AOME_SET_TOKEN_PARTITIONS, int) /* aome_token_partitions */ +#define AOM_CTRL_AOME_SET_TOKEN_PARTITIONS -VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_MAXFRAMES, unsigned int) -#define VPX_CTRL_VP8E_SET_ARNR_MAXFRAMES -VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_STRENGTH, unsigned int) -#define VPX_CTRL_VP8E_SET_ARNR_STRENGTH -VPX_CTRL_USE_TYPE_DEPRECATED(VP8E_SET_ARNR_TYPE, unsigned int) -#define VPX_CTRL_VP8E_SET_ARNR_TYPE -VPX_CTRL_USE_TYPE(VP8E_SET_TUNING, int) /* vpx_tune_metric */ -#define VPX_CTRL_VP8E_SET_TUNING -VPX_CTRL_USE_TYPE(VP8E_SET_CQ_LEVEL, unsigned int) -#define VPX_CTRL_VP8E_SET_CQ_LEVEL +AOM_CTRL_USE_TYPE(AOME_SET_ARNR_MAXFRAMES, unsigned int) +#define AOM_CTRL_AOME_SET_ARNR_MAXFRAMES +AOM_CTRL_USE_TYPE(AOME_SET_ARNR_STRENGTH, unsigned int) +#define AOM_CTRL_AOME_SET_ARNR_STRENGTH +AOM_CTRL_USE_TYPE_DEPRECATED(AOME_SET_ARNR_TYPE, unsigned int) +#define AOM_CTRL_AOME_SET_ARNR_TYPE +AOM_CTRL_USE_TYPE(AOME_SET_TUNING, int) /* aom_tune_metric */ +#define AOM_CTRL_AOME_SET_TUNING +AOM_CTRL_USE_TYPE(AOME_SET_CQ_LEVEL, unsigned int) +#define AOM_CTRL_AOME_SET_CQ_LEVEL -VPX_CTRL_USE_TYPE(VP9E_SET_TILE_COLUMNS, int) -#define VPX_CTRL_VP9E_SET_TILE_COLUMNS -VPX_CTRL_USE_TYPE(VP9E_SET_TILE_ROWS, int) -#define VPX_CTRL_VP9E_SET_TILE_ROWS +AOM_CTRL_USE_TYPE(AV1E_SET_TILE_COLUMNS, int) +#define AOM_CTRL_AV1E_SET_TILE_COLUMNS +AOM_CTRL_USE_TYPE(AV1E_SET_TILE_ROWS, int) +#define AOM_CTRL_AV1E_SET_TILE_ROWS -VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER, int *) -#define VPX_CTRL_VP8E_GET_LAST_QUANTIZER -VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER_64, int *) -#define VPX_CTRL_VP8E_GET_LAST_QUANTIZER_64 +AOM_CTRL_USE_TYPE(AOME_GET_LAST_QUANTIZER, int *) +#define AOM_CTRL_AOME_GET_LAST_QUANTIZER +AOM_CTRL_USE_TYPE(AOME_GET_LAST_QUANTIZER_64, int *) +#define AOM_CTRL_AOME_GET_LAST_QUANTIZER_64 -VPX_CTRL_USE_TYPE(VP8E_SET_MAX_INTRA_BITRATE_PCT, unsigned int) -#define VPX_CTRL_VP8E_SET_MAX_INTRA_BITRATE_PCT -VPX_CTRL_USE_TYPE(VP8E_SET_MAX_INTER_BITRATE_PCT, unsigned int) -#define VPX_CTRL_VP8E_SET_MAX_INTER_BITRATE_PCT +AOM_CTRL_USE_TYPE(AOME_SET_MAX_INTRA_BITRATE_PCT, unsigned int) +#define AOM_CTRL_AOME_SET_MAX_INTRA_BITRATE_PCT +AOM_CTRL_USE_TYPE(AOME_SET_MAX_INTER_BITRATE_PCT, unsigned int) +#define AOM_CTRL_AOME_SET_MAX_INTER_BITRATE_PCT -VPX_CTRL_USE_TYPE(VP8E_SET_SCREEN_CONTENT_MODE, unsigned int) -#define VPX_CTRL_VP8E_SET_SCREEN_CONTENT_MODE +AOM_CTRL_USE_TYPE(AOME_SET_SCREEN_CONTENT_MODE, unsigned int) +#define AOM_CTRL_AOME_SET_SCREEN_CONTENT_MODE -VPX_CTRL_USE_TYPE(VP9E_SET_GF_CBR_BOOST_PCT, unsigned int) -#define VPX_CTRL_VP9E_SET_GF_CBR_BOOST_PCT +AOM_CTRL_USE_TYPE(AV1E_SET_GF_CBR_BOOST_PCT, unsigned int) +#define AOM_CTRL_AV1E_SET_GF_CBR_BOOST_PCT -VPX_CTRL_USE_TYPE(VP9E_SET_LOSSLESS, unsigned int) -#define VPX_CTRL_VP9E_SET_LOSSLESS +AOM_CTRL_USE_TYPE(AV1E_SET_LOSSLESS, unsigned int) +#define AOM_CTRL_AV1E_SET_LOSSLESS #if CONFIG_AOM_QM -VPX_CTRL_USE_TYPE(VP9E_SET_ENABLE_QM, unsigned int) -#define VPX_CTRL_VP9E_SET_ENABLE_QM +AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_QM, unsigned int) +#define AOM_CTRL_AV1E_SET_ENABLE_QM -VPX_CTRL_USE_TYPE(VP9E_SET_QM_MIN, unsigned int) -#define VPX_CTRL_VP9E_SET_QM_MIN +AOM_CTRL_USE_TYPE(AV1E_SET_QM_MIN, unsigned int) +#define AOM_CTRL_AV1E_SET_QM_MIN -VPX_CTRL_USE_TYPE(VP9E_SET_QM_MAX, unsigned int) -#define VPX_CTRL_VP9E_SET_QM_MAX +AOM_CTRL_USE_TYPE(AV1E_SET_QM_MAX, unsigned int) +#define AOM_CTRL_AV1E_SET_QM_MAX #endif -VPX_CTRL_USE_TYPE(VP9E_SET_FRAME_PARALLEL_DECODING, unsigned int) -#define VPX_CTRL_VP9E_SET_FRAME_PARALLEL_DECODING +AOM_CTRL_USE_TYPE(AV1E_SET_FRAME_PARALLEL_DECODING, unsigned int) +#define AOM_CTRL_AV1E_SET_FRAME_PARALLEL_DECODING -VPX_CTRL_USE_TYPE(VP9E_SET_AQ_MODE, unsigned int) -#define VPX_CTRL_VP9E_SET_AQ_MODE +AOM_CTRL_USE_TYPE(AV1E_SET_AQ_MODE, unsigned int) +#define AOM_CTRL_AV1E_SET_AQ_MODE -VPX_CTRL_USE_TYPE(VP9E_SET_FRAME_PERIODIC_BOOST, unsigned int) -#define VPX_CTRL_VP9E_SET_FRAME_PERIODIC_BOOST +AOM_CTRL_USE_TYPE(AV1E_SET_FRAME_PERIODIC_BOOST, unsigned int) +#define AOM_CTRL_AV1E_SET_FRAME_PERIODIC_BOOST -VPX_CTRL_USE_TYPE(VP9E_SET_NOISE_SENSITIVITY, unsigned int) -#define VPX_CTRL_VP9E_SET_NOISE_SENSITIVITY +AOM_CTRL_USE_TYPE(AV1E_SET_NOISE_SENSITIVITY, unsigned int) +#define AOM_CTRL_AV1E_SET_NOISE_SENSITIVITY -VPX_CTRL_USE_TYPE(VP9E_SET_TUNE_CONTENT, int) /* vpx_tune_content */ -#define VPX_CTRL_VP9E_SET_TUNE_CONTENT +AOM_CTRL_USE_TYPE(AV1E_SET_TUNE_CONTENT, int) /* aom_tune_content */ +#define AOM_CTRL_AV1E_SET_TUNE_CONTENT -VPX_CTRL_USE_TYPE(VP9E_SET_COLOR_SPACE, int) -#define VPX_CTRL_VP9E_SET_COLOR_SPACE +AOM_CTRL_USE_TYPE(AV1E_SET_COLOR_SPACE, int) +#define AOM_CTRL_AV1E_SET_COLOR_SPACE -VPX_CTRL_USE_TYPE(VP9E_SET_MIN_GF_INTERVAL, unsigned int) -#define VPX_CTRL_VP9E_SET_MIN_GF_INTERVAL +AOM_CTRL_USE_TYPE(AV1E_SET_MIN_GF_INTERVAL, unsigned int) +#define AOM_CTRL_AV1E_SET_MIN_GF_INTERVAL -VPX_CTRL_USE_TYPE(VP9E_SET_MAX_GF_INTERVAL, unsigned int) -#define VPX_CTRL_VP9E_SET_MAX_GF_INTERVAL +AOM_CTRL_USE_TYPE(AV1E_SET_MAX_GF_INTERVAL, unsigned int) +#define AOM_CTRL_AV1E_SET_MAX_GF_INTERVAL -VPX_CTRL_USE_TYPE(VP9E_GET_ACTIVEMAP, vpx_active_map_t *) -#define VPX_CTRL_VP9E_GET_ACTIVEMAP +AOM_CTRL_USE_TYPE(AV1E_GET_ACTIVEMAP, aom_active_map_t *) +#define AOM_CTRL_AV1E_GET_ACTIVEMAP -VPX_CTRL_USE_TYPE(VP9E_SET_COLOR_RANGE, int) -#define VPX_CTRL_VP9E_SET_COLOR_RANGE +AOM_CTRL_USE_TYPE(AV1E_SET_COLOR_RANGE, int) +#define AOM_CTRL_AV1E_SET_COLOR_RANGE /*!\brief * * TODO(rbultje) : add support of the control in ffmpeg */ -#define VPX_CTRL_VP9E_SET_RENDER_SIZE -VPX_CTRL_USE_TYPE(VP9E_SET_RENDER_SIZE, int *) +#define AOM_CTRL_AV1E_SET_RENDER_SIZE +AOM_CTRL_USE_TYPE(AV1E_SET_RENDER_SIZE, int *) -VPX_CTRL_USE_TYPE(VP10E_SET_SUPERBLOCK_SIZE, unsigned int) -#define VPX_CTRL_VP10E_SET_SUPERBLOCK_SIZE +AOM_CTRL_USE_TYPE(AV1E_SET_SUPERBLOCK_SIZE, unsigned int) +#define AOM_CTRL_AV1E_SET_SUPERBLOCK_SIZE -VPX_CTRL_USE_TYPE(VP9E_SET_TARGET_LEVEL, unsigned int) -#define VPX_CTRL_VP9E_SET_TARGET_LEVEL +AOM_CTRL_USE_TYPE(AV1E_SET_TARGET_LEVEL, unsigned int) +#define AOM_CTRL_AV1E_SET_TARGET_LEVEL -VPX_CTRL_USE_TYPE(VP9E_GET_LEVEL, int *) -#define VPX_CTRL_VP9E_GET_LEVEL +AOM_CTRL_USE_TYPE(AV1E_GET_LEVEL, int *) +#define AOM_CTRL_AV1E_GET_LEVEL /*!\endcond */ /*! @} - end defgroup vp8_encoder */ #ifdef __cplusplus } // extern "C" #endif -#endif // VPX_VP8CX_H_ +#endif // AOM_AOMCX_H_
diff --git a/aom/aomdx.h b/aom/aomdx.h new file mode 100644 index 0000000..3c397e4 --- /dev/null +++ b/aom/aomdx.h
@@ -0,0 +1,176 @@ +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/*!\defgroup aom_decoder AOMedia AOM/AV1 Decoder + * \ingroup aom + * + * @{ + */ +/*!\file + * \brief Provides definitions for using AOM or AV1 within the aom Decoder + * interface. + */ +#ifndef AOM_AOMDX_H_ +#define AOM_AOMDX_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Include controls common to both the encoder and decoder */ +#include "./aom.h" + +/*!\name Algorithm interface for AV1 + * + * This interface provides the capability to decode AV1 streams. + * @{ + */ +extern aom_codec_iface_t aom_codec_av1_dx_algo; +extern aom_codec_iface_t *aom_codec_av1_dx(void); +/*!@} - end algorithm interface member group*/ + +/*!\enum aom_dec_control_id + * \brief AOM decoder control functions + * + * This set of macros define the control functions available for the AOM + * decoder interface. + * + * \sa #aom_codec_control + */ +enum aom_dec_control_id { + /** control function to get info on which reference frames were updated + * by the last decode + */ + AOMD_GET_LAST_REF_UPDATES = AOM_DECODER_CTRL_ID_START, + + /** check if the indicated frame is corrupted */ + AOMD_GET_FRAME_CORRUPTED, + + /** control function to get info on which reference frames were used + * by the last decode + */ + AOMD_GET_LAST_REF_USED, + + /** decryption function to decrypt encoded buffer data immediately + * before decoding. Takes a aom_decrypt_init, which contains + * a callback function and opaque context pointer. + */ + AOMD_SET_DECRYPTOR, + // AOMD_SET_DECRYPTOR = AOMD_SET_DECRYPTOR, + + /** control function to get the dimensions that the current frame is decoded + * at. This may be different to the intended display size for the frame as + * specified in the wrapper or frame header (see AV1D_GET_DISPLAY_SIZE). */ + AV1D_GET_FRAME_SIZE, + + /** control function to get the current frame's intended display dimensions + * (as specified in the wrapper or frame header). This may be different to + * the decoded dimensions of this frame (see AV1D_GET_FRAME_SIZE). */ + AV1D_GET_DISPLAY_SIZE, + + /** control function to get the bit depth of the stream. */ + AV1D_GET_BIT_DEPTH, + + /** control function to set the byte alignment of the planes in the reference + * buffers. Valid values are power of 2, from 32 to 1024. A value of 0 sets + * legacy alignment. I.e. Y plane is aligned to 32 bytes, U plane directly + * follows Y plane, and V plane directly follows U plane. Default value is 0. + */ + AV1_SET_BYTE_ALIGNMENT, + + /** control function to invert the decoding order to from right to left. The + * function is used in a test to confirm the decoding independence of tile + * columns. The function may be used in application where this order + * of decoding is desired. + * + * TODO(yaowu): Rework the unit test that uses this control, and in a future + * release, this test-only control shall be removed. + */ + AV1_INVERT_TILE_DECODE_ORDER, + + /** control function to set the skip loop filter flag. Valid values are + * integers. The decoder will skip the loop filter when its value is set to + * nonzero. If the loop filter is skipped the decoder may accumulate decode + * artifacts. The default value is 0. + */ + AV1_SET_SKIP_LOOP_FILTER, + + AOM_DECODER_CTRL_ID_MAX, + + /** control function to set the range of tile decoding. A value that is + * greater and equal to zero indicates only the specific row/column is + * decoded. A value that is -1 indicates the whole row/column is decoded. + * A special case is both values are -1 that means the whole frame is + * decoded. + */ + AV1_SET_DECODE_TILE_ROW, + AV1_SET_DECODE_TILE_COL +}; + +/** Decrypt n bytes of data from input -> output, using the decrypt_state + * passed in AOMD_SET_DECRYPTOR. + */ +typedef void (*aom_decrypt_cb)(void *decrypt_state, const unsigned char *input, + unsigned char *output, int count); + +/*!\brief Structure to hold decryption state + * + * Defines a structure to hold the decryption state and access function. + */ +typedef struct aom_decrypt_init { + /*! Decrypt callback. */ + aom_decrypt_cb decrypt_cb; + + /*! Decryption state. */ + void *decrypt_state; +} aom_decrypt_init; + +/*!\brief A deprecated alias for aom_decrypt_init. + */ +typedef aom_decrypt_init aom_decrypt_init; + +/*!\cond */ +/*!\brief AOM decoder control function parameter type + * + * Defines the data types that AOMD control functions take. Note that + * additional common controls are defined in aom.h + * + */ + +AOM_CTRL_USE_TYPE(AOMD_GET_LAST_REF_UPDATES, int *) +#define AOM_CTRL_AOMD_GET_LAST_REF_UPDATES +AOM_CTRL_USE_TYPE(AOMD_GET_FRAME_CORRUPTED, int *) +#define AOM_CTRL_AOMD_GET_FRAME_CORRUPTED +AOM_CTRL_USE_TYPE(AOMD_GET_LAST_REF_USED, int *) +#define AOM_CTRL_AOMD_GET_LAST_REF_USED +AOM_CTRL_USE_TYPE(AOMD_SET_DECRYPTOR, aom_decrypt_init *) +#define AOM_CTRL_AOMD_SET_DECRYPTOR +// AOM_CTRL_USE_TYPE(AOMD_SET_DECRYPTOR, aom_decrypt_init *) +//#define AOM_CTRL_AOMD_SET_DECRYPTOR +AOM_CTRL_USE_TYPE(AV1D_GET_DISPLAY_SIZE, int *) +#define AOM_CTRL_AV1D_GET_DISPLAY_SIZE +AOM_CTRL_USE_TYPE(AV1D_GET_BIT_DEPTH, unsigned int *) +#define AOM_CTRL_AV1D_GET_BIT_DEPTH +AOM_CTRL_USE_TYPE(AV1D_GET_FRAME_SIZE, int *) +#define AOM_CTRL_AV1D_GET_FRAME_SIZE +AOM_CTRL_USE_TYPE(AV1_INVERT_TILE_DECODE_ORDER, int) +#define AOM_CTRL_AV1_INVERT_TILE_DECODE_ORDER +AOM_CTRL_USE_TYPE(AV1_SET_DECODE_TILE_ROW, int) +#define AOM_CTRL_AV1_SET_DECODE_TILE_ROW +AOM_CTRL_USE_TYPE(AV1_SET_DECODE_TILE_COL, int) +#define AOM_CTRL_AV1_SET_DECODE_TILE_COL +/*!\endcond */ +/*! @} - end defgroup vp8_decoder */ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AOM_AOMDX_H_
diff --git a/aom/exports_com b/aom/exports_com index 2ab0509..0c79fa1 100644 --- a/aom/exports_com +++ b/aom/exports_com
@@ -1,16 +1,16 @@ -text vpx_codec_build_config -text vpx_codec_control_ -text vpx_codec_destroy -text vpx_codec_err_to_string -text vpx_codec_error -text vpx_codec_error_detail -text vpx_codec_get_caps -text vpx_codec_iface_name -text vpx_codec_version -text vpx_codec_version_extra_str -text vpx_codec_version_str -text vpx_img_alloc -text vpx_img_flip -text vpx_img_free -text vpx_img_set_rect -text vpx_img_wrap +text aom_codec_build_config +text aom_codec_control_ +text aom_codec_destroy +text aom_codec_err_to_string +text aom_codec_error +text aom_codec_error_detail +text aom_codec_get_caps +text aom_codec_iface_name +text aom_codec_version +text aom_codec_version_extra_str +text aom_codec_version_str +text aom_img_alloc +text aom_img_flip +text aom_img_free +text aom_img_set_rect +text aom_img_wrap
diff --git a/aom/exports_dec b/aom/exports_dec index c694eba..de8fe44 100644 --- a/aom/exports_dec +++ b/aom/exports_dec
@@ -1,8 +1,8 @@ -text vpx_codec_dec_init_ver -text vpx_codec_decode -text vpx_codec_get_frame -text vpx_codec_get_stream_info -text vpx_codec_peek_stream_info -text vpx_codec_register_put_frame_cb -text vpx_codec_register_put_slice_cb -text vpx_codec_set_frame_buffer_functions +text aom_codec_dec_init_ver +text aom_codec_decode +text aom_codec_get_frame +text aom_codec_get_stream_info +text aom_codec_peek_stream_info +text aom_codec_register_put_frame_cb +text aom_codec_register_put_slice_cb +text aom_codec_set_frame_buffer_functions
diff --git a/aom/exports_enc b/aom/exports_enc index 914e36c..0dcca7d 100644 --- a/aom/exports_enc +++ b/aom/exports_enc
@@ -1,9 +1,9 @@ -text vpx_codec_enc_config_default -text vpx_codec_enc_config_set -text vpx_codec_enc_init_multi_ver -text vpx_codec_enc_init_ver -text vpx_codec_encode -text vpx_codec_get_cx_data -text vpx_codec_get_global_headers -text vpx_codec_get_preview_frame -text vpx_codec_set_cx_data_buf +text aom_codec_enc_config_default +text aom_codec_enc_config_set +text aom_codec_enc_init_multi_ver +text aom_codec_enc_init_ver +text aom_codec_encode +text aom_codec_get_cx_data +text aom_codec_get_global_headers +text aom_codec_get_preview_frame +text aom_codec_set_cx_data_buf
diff --git a/aom/internal/vpx_codec_internal.h b/aom/internal/aom_codec_internal.h similarity index 62% rename from aom/internal/vpx_codec_internal.h rename to aom/internal/aom_codec_internal.h index 4ac77b7..ee346e2 100644 --- a/aom/internal/vpx_codec_internal.h +++ b/aom/internal/aom_codec_internal.h
@@ -19,31 +19,31 @@ * into the global namespace: * <pre> * my_codec.c: - * vpx_codec_iface_t my_codec = { + * aom_codec_iface_t my_codec = { * "My Codec v1.0", - * VPX_CODEC_ALG_ABI_VERSION, + * AOM_CODEC_ALG_ABI_VERSION, * ... * }; * </pre> * * An application instantiates a specific decoder instance by using - * vpx_codec_init() and a pointer to the algorithm's interface structure: + * aom_codec_init() and a pointer to the algorithm's interface structure: * <pre> * my_app.c: - * extern vpx_codec_iface_t my_codec; + * extern aom_codec_iface_t my_codec; * { - * vpx_codec_ctx_t algo; - * res = vpx_codec_init(&algo, &my_codec); + * aom_codec_ctx_t algo; + * res = aom_codec_init(&algo, &my_codec); * } * </pre> * * Once initialized, the instance is manged using other functions from - * the vpx_codec_* family. + * the aom_codec_* family. */ -#ifndef VPX_INTERNAL_VPX_CODEC_INTERNAL_H_ -#define VPX_INTERNAL_VPX_CODEC_INTERNAL_H_ -#include "../vpx_decoder.h" -#include "../vpx_encoder.h" +#ifndef AOM_INTERNAL_AOM_CODEC_INTERNAL_H_ +#define AOM_INTERNAL_AOM_CODEC_INTERNAL_H_ +#include "../aom_decoder.h" +#include "../aom_encoder.h" #include <stdarg.h> #ifdef __cplusplus @@ -58,46 +58,46 @@ * types, removing or reassigning enums, adding/removing/rearranging * fields to structures */ -#define VPX_CODEC_INTERNAL_ABI_VERSION (5) /**<\hideinitializer*/ +#define AOM_CODEC_INTERNAL_ABI_VERSION (5) /**<\hideinitializer*/ -typedef struct vpx_codec_alg_priv vpx_codec_alg_priv_t; -typedef struct vpx_codec_priv_enc_mr_cfg vpx_codec_priv_enc_mr_cfg_t; +typedef struct aom_codec_alg_priv aom_codec_alg_priv_t; +typedef struct aom_codec_priv_enc_mr_cfg aom_codec_priv_enc_mr_cfg_t; /*!\brief init function pointer prototype * * Performs algorithm-specific initialization of the decoder context. This - * function is called by the generic vpx_codec_init() wrapper function, so + * function is called by the generic aom_codec_init() wrapper function, so * plugins implementing this interface may trust the input parameters to be * properly initialized. * * \param[in] ctx Pointer to this instance's context - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The input stream was recognized and decoder initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory operation failed. */ -typedef vpx_codec_err_t (*vpx_codec_init_fn_t)( - vpx_codec_ctx_t *ctx, vpx_codec_priv_enc_mr_cfg_t *data); +typedef aom_codec_err_t (*aom_codec_init_fn_t)( + aom_codec_ctx_t *ctx, aom_codec_priv_enc_mr_cfg_t *data); /*!\brief destroy function pointer prototype * * Performs algorithm-specific destruction of the decoder context. This - * function is called by the generic vpx_codec_destroy() wrapper function, + * function is called by the generic aom_codec_destroy() wrapper function, * so plugins implementing this interface may trust the input parameters * to be properly initialized. * * \param[in] ctx Pointer to this instance's context - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The input stream was recognized and decoder initialized. - * \retval #VPX_CODEC_MEM_ERROR + * \retval #AOM_CODEC_MEM_ERROR * Memory operation failed. */ -typedef vpx_codec_err_t (*vpx_codec_destroy_fn_t)(vpx_codec_alg_priv_t *ctx); +typedef aom_codec_err_t (*aom_codec_destroy_fn_t)(aom_codec_alg_priv_t *ctx); /*!\brief parse stream info function pointer prototype * * Performs high level parsing of the bitstream. This function is called by the - * generic vpx_codec_peek_stream_info() wrapper function, so plugins + * generic aom_codec_peek_stream_info() wrapper function, so plugins * implementing this interface may trust the input parameters to be properly * initialized. * @@ -108,12 +108,12 @@ * clobbered by the algorithm. This parameter \ref MAY * be NULL. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Bitstream is parsable and stream information updated */ -typedef vpx_codec_err_t (*vpx_codec_peek_si_fn_t)(const uint8_t *data, +typedef aom_codec_err_t (*aom_codec_peek_si_fn_t)(const uint8_t *data, unsigned int data_sz, - vpx_codec_stream_info_t *si); + aom_codec_stream_info_t *si); /*!\brief Return information about the current stream. * @@ -125,11 +125,11 @@ * clobbered by the algorithm. This parameter \ref MAY * be NULL. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * Bitstream is parsable and stream information updated */ -typedef vpx_codec_err_t (*vpx_codec_get_si_fn_t)(vpx_codec_alg_priv_t *ctx, - vpx_codec_stream_info_t *si); +typedef aom_codec_err_t (*aom_codec_get_si_fn_t)(aom_codec_alg_priv_t *ctx, + aom_codec_stream_info_t *si); /*!\brief control function pointer prototype * @@ -137,7 +137,7 @@ * instance. This can be used to implement features specific to a particular * algorithm. * - * This function is called by the generic vpx_codec_control() wrapper + * This function is called by the generic aom_codec_control() wrapper * function, so plugins implementing this interface may trust the input * parameters to be properly initialized. However, this interface does not * provide type safety for the exchanged data or assign meanings to the @@ -150,49 +150,49 @@ * \param[in] ctrl_id Algorithm specific control identifier * \param[in,out] data Data to exchange with algorithm instance. * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * The internal state data was deserialized. */ -typedef vpx_codec_err_t (*vpx_codec_control_fn_t)(vpx_codec_alg_priv_t *ctx, +typedef aom_codec_err_t (*aom_codec_control_fn_t)(aom_codec_alg_priv_t *ctx, va_list ap); /*!\brief control function pointer mapping * * This structure stores the mapping between control identifiers and * implementing functions. Each algorithm provides a list of these - * mappings. This list is searched by the vpx_codec_control() wrapper + * mappings. This list is searched by the aom_codec_control() wrapper * function to determine which function to invoke. The special * value {0, NULL} is used to indicate end-of-list, and must be * present. The special value {0, <non-null>} can be used as a catch-all * mapping. This implies that ctrl_id values chosen by the algorithm * \ref MUST be non-zero. */ -typedef const struct vpx_codec_ctrl_fn_map { +typedef const struct aom_codec_ctrl_fn_map { int ctrl_id; - vpx_codec_control_fn_t fn; -} vpx_codec_ctrl_fn_map_t; + aom_codec_control_fn_t fn; +} aom_codec_ctrl_fn_map_t; /*!\brief decode data function pointer prototype * * Processes a buffer of coded data. If the processing results in a new - * decoded frame becoming available, #VPX_CODEC_CB_PUT_SLICE and - * #VPX_CODEC_CB_PUT_FRAME events are generated as appropriate. This - * function is called by the generic vpx_codec_decode() wrapper function, + * decoded frame becoming available, #AOM_CODEC_CB_PUT_SLICE and + * #AOM_CODEC_CB_PUT_FRAME events are generated as appropriate. This + * function is called by the generic aom_codec_decode() wrapper function, * so plugins implementing this interface may trust the input parameters * to be properly initialized. * * \param[in] ctx Pointer to this instance's context * \param[in] data Pointer to this block of new coded data. If - * NULL, a #VPX_CODEC_CB_PUT_FRAME event is posted + * NULL, a #AOM_CODEC_CB_PUT_FRAME event is posted * for the previously decoded frame. * \param[in] data_sz Size of the coded data, in bytes. * - * \return Returns #VPX_CODEC_OK if the coded data was processed completely + * \return Returns #AOM_CODEC_OK if the coded data was processed completely * and future pictures can be decoded without error. Otherwise, - * see the descriptions of the other error codes in ::vpx_codec_err_t + * see the descriptions of the other error codes in ::aom_codec_err_t * for recoverability capabilities. */ -typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(vpx_codec_alg_priv_t *ctx, +typedef aom_codec_err_t (*aom_codec_decode_fn_t)(aom_codec_alg_priv_t *ctx, const uint8_t *data, unsigned int data_sz, void *user_priv, @@ -205,8 +205,8 @@ * complete when this function returns NULL. * * The list of available frames becomes valid upon completion of the - * vpx_codec_decode call, and remains valid until the next call to - * vpx_codec_decode. + * aom_codec_decode call, and remains valid until the next call to + * aom_codec_decode. * * \param[in] ctx Pointer to this instance's context * \param[in out] iter Iterator storage, initialized to NULL @@ -214,8 +214,8 @@ * \return Returns a pointer to an image, if one is ready for display. Frames * produced will always be in PTS (presentation time stamp) order. */ -typedef vpx_image_t *(*vpx_codec_get_frame_fn_t)(vpx_codec_alg_priv_t *ctx, - vpx_codec_iter_t *iter); +typedef aom_image_t *(*aom_codec_get_frame_fn_t)(aom_codec_alg_priv_t *ctx, + aom_codec_iter_t *iter); /*!\brief Pass in external frame buffers for the decoder to use. * @@ -230,103 +230,103 @@ * \param[in] cb_release Pointer to the release callback function * \param[in] cb_priv Callback's private data * - * \retval #VPX_CODEC_OK + * \retval #AOM_CODEC_OK * External frame buffers will be used by libaom. - * \retval #VPX_CODEC_INVALID_PARAM + * \retval #AOM_CODEC_INVALID_PARAM * One or more of the callbacks were NULL. - * \retval #VPX_CODEC_ERROR + * \retval #AOM_CODEC_ERROR * Decoder context not initialized, or algorithm not capable of * using external frame buffers. * * \note - * When decoding VP9, the application may be required to pass in at least - * #VPX_MAXIMUM_WORK_BUFFERS external frame + * When decoding AV1, the application may be required to pass in at least + * #AOM_MAXIMUM_WORK_BUFFERS external frame * buffers. */ -typedef vpx_codec_err_t (*vpx_codec_set_fb_fn_t)( - vpx_codec_alg_priv_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get, - vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv); +typedef aom_codec_err_t (*aom_codec_set_fb_fn_t)( + aom_codec_alg_priv_t *ctx, aom_get_frame_buffer_cb_fn_t cb_get, + aom_release_frame_buffer_cb_fn_t cb_release, void *cb_priv); -typedef vpx_codec_err_t (*vpx_codec_encode_fn_t)(vpx_codec_alg_priv_t *ctx, - const vpx_image_t *img, - vpx_codec_pts_t pts, +typedef aom_codec_err_t (*aom_codec_encode_fn_t)(aom_codec_alg_priv_t *ctx, + const aom_image_t *img, + aom_codec_pts_t pts, unsigned long duration, - vpx_enc_frame_flags_t flags, + aom_enc_frame_flags_t flags, unsigned long deadline); -typedef const vpx_codec_cx_pkt_t *(*vpx_codec_get_cx_data_fn_t)( - vpx_codec_alg_priv_t *ctx, vpx_codec_iter_t *iter); +typedef const aom_codec_cx_pkt_t *(*aom_codec_get_cx_data_fn_t)( + aom_codec_alg_priv_t *ctx, aom_codec_iter_t *iter); -typedef vpx_codec_err_t (*vpx_codec_enc_config_set_fn_t)( - vpx_codec_alg_priv_t *ctx, const vpx_codec_enc_cfg_t *cfg); -typedef vpx_fixed_buf_t *(*vpx_codec_get_global_headers_fn_t)( - vpx_codec_alg_priv_t *ctx); +typedef aom_codec_err_t (*aom_codec_enc_config_set_fn_t)( + aom_codec_alg_priv_t *ctx, const aom_codec_enc_cfg_t *cfg); +typedef aom_fixed_buf_t *(*aom_codec_get_global_headers_fn_t)( + aom_codec_alg_priv_t *ctx); -typedef vpx_image_t *(*vpx_codec_get_preview_frame_fn_t)( - vpx_codec_alg_priv_t *ctx); +typedef aom_image_t *(*aom_codec_get_preview_frame_fn_t)( + aom_codec_alg_priv_t *ctx); -typedef vpx_codec_err_t (*vpx_codec_enc_mr_get_mem_loc_fn_t)( - const vpx_codec_enc_cfg_t *cfg, void **mem_loc); +typedef aom_codec_err_t (*aom_codec_enc_mr_get_mem_loc_fn_t)( + const aom_codec_enc_cfg_t *cfg, void **mem_loc); /*!\brief usage configuration mapping * * This structure stores the mapping between usage identifiers and * configuration structures. Each algorithm provides a list of these - * mappings. This list is searched by the vpx_codec_enc_config_default() + * mappings. This list is searched by the aom_codec_enc_config_default() * wrapper function to determine which config to return. The special value * {-1, {0}} is used to indicate end-of-list, and must be present. At least * one mapping must be present, in addition to the end-of-list. * */ -typedef const struct vpx_codec_enc_cfg_map { +typedef const struct aom_codec_enc_cfg_map { int usage; - vpx_codec_enc_cfg_t cfg; -} vpx_codec_enc_cfg_map_t; + aom_codec_enc_cfg_t cfg; +} aom_codec_enc_cfg_map_t; /*!\brief Decoder algorithm interface interface * * All decoders \ref MUST expose a variable of this type. */ -struct vpx_codec_iface { +struct aom_codec_iface { const char *name; /**< Identification String */ int abi_version; /**< Implemented ABI version */ - vpx_codec_caps_t caps; /**< Decoder capabilities */ - vpx_codec_init_fn_t init; /**< \copydoc ::vpx_codec_init_fn_t */ - vpx_codec_destroy_fn_t destroy; /**< \copydoc ::vpx_codec_destroy_fn_t */ - vpx_codec_ctrl_fn_map_t *ctrl_maps; /**< \copydoc ::vpx_codec_ctrl_fn_map_t */ - struct vpx_codec_dec_iface { - vpx_codec_peek_si_fn_t peek_si; /**< \copydoc ::vpx_codec_peek_si_fn_t */ - vpx_codec_get_si_fn_t get_si; /**< \copydoc ::vpx_codec_get_si_fn_t */ - vpx_codec_decode_fn_t decode; /**< \copydoc ::vpx_codec_decode_fn_t */ - vpx_codec_get_frame_fn_t - get_frame; /**< \copydoc ::vpx_codec_get_frame_fn_t */ - vpx_codec_set_fb_fn_t set_fb_fn; /**< \copydoc ::vpx_codec_set_fb_fn_t */ + aom_codec_caps_t caps; /**< Decoder capabilities */ + aom_codec_init_fn_t init; /**< \copydoc ::aom_codec_init_fn_t */ + aom_codec_destroy_fn_t destroy; /**< \copydoc ::aom_codec_destroy_fn_t */ + aom_codec_ctrl_fn_map_t *ctrl_maps; /**< \copydoc ::aom_codec_ctrl_fn_map_t */ + struct aom_codec_dec_iface { + aom_codec_peek_si_fn_t peek_si; /**< \copydoc ::aom_codec_peek_si_fn_t */ + aom_codec_get_si_fn_t get_si; /**< \copydoc ::aom_codec_get_si_fn_t */ + aom_codec_decode_fn_t decode; /**< \copydoc ::aom_codec_decode_fn_t */ + aom_codec_get_frame_fn_t + get_frame; /**< \copydoc ::aom_codec_get_frame_fn_t */ + aom_codec_set_fb_fn_t set_fb_fn; /**< \copydoc ::aom_codec_set_fb_fn_t */ } dec; - struct vpx_codec_enc_iface { + struct aom_codec_enc_iface { int cfg_map_count; - vpx_codec_enc_cfg_map_t - *cfg_maps; /**< \copydoc ::vpx_codec_enc_cfg_map_t */ - vpx_codec_encode_fn_t encode; /**< \copydoc ::vpx_codec_encode_fn_t */ - vpx_codec_get_cx_data_fn_t - get_cx_data; /**< \copydoc ::vpx_codec_get_cx_data_fn_t */ - vpx_codec_enc_config_set_fn_t - cfg_set; /**< \copydoc ::vpx_codec_enc_config_set_fn_t */ - vpx_codec_get_global_headers_fn_t - get_glob_hdrs; /**< \copydoc ::vpx_codec_get_global_headers_fn_t */ - vpx_codec_get_preview_frame_fn_t - get_preview; /**< \copydoc ::vpx_codec_get_preview_frame_fn_t */ - vpx_codec_enc_mr_get_mem_loc_fn_t - mr_get_mem_loc; /**< \copydoc ::vpx_codec_enc_mr_get_mem_loc_fn_t */ + aom_codec_enc_cfg_map_t + *cfg_maps; /**< \copydoc ::aom_codec_enc_cfg_map_t */ + aom_codec_encode_fn_t encode; /**< \copydoc ::aom_codec_encode_fn_t */ + aom_codec_get_cx_data_fn_t + get_cx_data; /**< \copydoc ::aom_codec_get_cx_data_fn_t */ + aom_codec_enc_config_set_fn_t + cfg_set; /**< \copydoc ::aom_codec_enc_config_set_fn_t */ + aom_codec_get_global_headers_fn_t + get_glob_hdrs; /**< \copydoc ::aom_codec_get_global_headers_fn_t */ + aom_codec_get_preview_frame_fn_t + get_preview; /**< \copydoc ::aom_codec_get_preview_frame_fn_t */ + aom_codec_enc_mr_get_mem_loc_fn_t + mr_get_mem_loc; /**< \copydoc ::aom_codec_enc_mr_get_mem_loc_fn_t */ } enc; }; /*!\brief Callback function pointer / user data pair storage */ -typedef struct vpx_codec_priv_cb_pair { +typedef struct aom_codec_priv_cb_pair { union { - vpx_codec_put_frame_cb_fn_t put_frame; - vpx_codec_put_slice_cb_fn_t put_slice; + aom_codec_put_frame_cb_fn_t put_frame; + aom_codec_put_slice_cb_fn_t put_slice; } u; void *user_priv; -} vpx_codec_priv_cb_pair_t; +} aom_codec_priv_cb_pair_t; /*!\brief Instance private storage * @@ -336,18 +336,18 @@ * structure can be made the first member of the algorithm specific structure, * and the pointer cast to the proper type. */ -struct vpx_codec_priv { +struct aom_codec_priv { const char *err_detail; - vpx_codec_flags_t init_flags; + aom_codec_flags_t init_flags; struct { - vpx_codec_priv_cb_pair_t put_frame_cb; - vpx_codec_priv_cb_pair_t put_slice_cb; + aom_codec_priv_cb_pair_t put_frame_cb; + aom_codec_priv_cb_pair_t put_slice_cb; } dec; struct { - vpx_fixed_buf_t cx_data_dst_buf; + aom_fixed_buf_t cx_data_dst_buf; unsigned int cx_data_pad_before; unsigned int cx_data_pad_after; - vpx_codec_cx_pkt_t cx_data_pkt; + aom_codec_cx_pkt_t cx_data_pkt; unsigned int total_encoders; } enc; }; @@ -355,20 +355,20 @@ /* * Multi-resolution encoding internal configuration */ -struct vpx_codec_priv_enc_mr_cfg { +struct aom_codec_priv_enc_mr_cfg { unsigned int mr_total_resolutions; unsigned int mr_encoder_id; - struct vpx_rational mr_down_sampling_factor; + struct aom_rational mr_down_sampling_factor; void *mr_low_res_mode_info; }; -#undef VPX_CTRL_USE_TYPE -#define VPX_CTRL_USE_TYPE(id, typ) \ - static VPX_INLINE typ id##__value(va_list args) { return va_arg(args, typ); } +#undef AOM_CTRL_USE_TYPE +#define AOM_CTRL_USE_TYPE(id, typ) \ + static AOM_INLINE typ id##__value(va_list args) { return va_arg(args, typ); } -#undef VPX_CTRL_USE_TYPE_DEPRECATED -#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) \ - static VPX_INLINE typ id##__value(va_list args) { return va_arg(args, typ); } +#undef AOM_CTRL_USE_TYPE_DEPRECATED +#define AOM_CTRL_USE_TYPE_DEPRECATED(id, typ) \ + static AOM_INLINE typ id##__value(va_list args) { return va_arg(args, typ); } #define CAST(id, arg) id##__value(arg) @@ -382,44 +382,44 @@ * macro is provided to define this getter function automatically. */ #define CODEC_INTERFACE(id) \ - vpx_codec_iface_t *id(void) { return &id##_algo; } \ - vpx_codec_iface_t id##_algo + aom_codec_iface_t *id(void) { return &id##_algo; } \ + aom_codec_iface_t id##_algo /* Internal Utility Functions * * The following functions are intended to be used inside algorithms as - * utilities for manipulating vpx_codec_* data structures. + * utilities for manipulating aom_codec_* data structures. */ -struct vpx_codec_pkt_list { +struct aom_codec_pkt_list { unsigned int cnt; unsigned int max; - struct vpx_codec_cx_pkt pkts[1]; + struct aom_codec_cx_pkt pkts[1]; }; -#define vpx_codec_pkt_list_decl(n) \ +#define aom_codec_pkt_list_decl(n) \ union { \ - struct vpx_codec_pkt_list head; \ + struct aom_codec_pkt_list head; \ struct { \ - struct vpx_codec_pkt_list head; \ - struct vpx_codec_cx_pkt pkts[n]; \ + struct aom_codec_pkt_list head; \ + struct aom_codec_cx_pkt pkts[n]; \ } alloc; \ } -#define vpx_codec_pkt_list_init(m) \ +#define aom_codec_pkt_list_init(m) \ (m)->alloc.head.cnt = 0, \ (m)->alloc.head.max = sizeof((m)->alloc.pkts) / sizeof((m)->alloc.pkts[0]) -int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *, - const struct vpx_codec_cx_pkt *); +int aom_codec_pkt_list_add(struct aom_codec_pkt_list *, + const struct aom_codec_cx_pkt *); -const vpx_codec_cx_pkt_t *vpx_codec_pkt_list_get( - struct vpx_codec_pkt_list *list, vpx_codec_iter_t *iter); +const aom_codec_cx_pkt_t *aom_codec_pkt_list_get( + struct aom_codec_pkt_list *list, aom_codec_iter_t *iter); #include <stdio.h> #include <setjmp.h> -struct vpx_internal_error_info { - vpx_codec_err_t error_code; +struct aom_internal_error_info { + aom_codec_err_t error_code; int has_detail; char detail[80]; int setjmp; @@ -434,12 +434,12 @@ #endif #endif -void vpx_internal_error(struct vpx_internal_error_info *info, - vpx_codec_err_t error, const char *fmt, +void aom_internal_error(struct aom_internal_error_info *info, + aom_codec_err_t error, const char *fmt, ...) CLANG_ANALYZER_NORETURN; #ifdef __cplusplus } // extern "C" #endif -#endif // VPX_INTERNAL_VPX_CODEC_INTERNAL_H_ +#endif // AOM_INTERNAL_AOM_CODEC_INTERNAL_H_
diff --git a/aom/src/aom_codec.c b/aom/src/aom_codec.c new file mode 100644 index 0000000..f7c9ea5 --- /dev/null +++ b/aom/src/aom_codec.c
@@ -0,0 +1,133 @@ +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/*!\file + * \brief Provides the high level interface to wrap decoder algorithms. + * + */ +#include <stdarg.h> +#include <stdlib.h> +#include "aom/aom_integer.h" +#include "aom/internal/aom_codec_internal.h" +#include "aom_version.h" + +#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var) + +int aom_codec_version(void) { return VERSION_PACKED; } + +const char *aom_codec_version_str(void) { return VERSION_STRING_NOSP; } + +const char *aom_codec_version_extra_str(void) { return VERSION_EXTRA; } + +const char *aom_codec_iface_name(aom_codec_iface_t *iface) { + return iface ? iface->name : "<invalid interface>"; +} + +const char *aom_codec_err_to_string(aom_codec_err_t err) { + switch (err) { + case AOM_CODEC_OK: return "Success"; + case AOM_CODEC_ERROR: return "Unspecified internal error"; + case AOM_CODEC_MEM_ERROR: return "Memory allocation error"; + case AOM_CODEC_ABI_MISMATCH: return "ABI version mismatch"; + case AOM_CODEC_INCAPABLE: + return "Codec does not implement requested capability"; + case AOM_CODEC_UNSUP_BITSTREAM: + return "Bitstream not supported by this decoder"; + case AOM_CODEC_UNSUP_FEATURE: + return "Bitstream required feature not supported by this decoder"; + case AOM_CODEC_CORRUPT_FRAME: return "Corrupt frame detected"; + case AOM_CODEC_INVALID_PARAM: return "Invalid parameter"; + case AOM_CODEC_LIST_END: return "End of iterated list"; + } + + return "Unrecognized error code"; +} + +const char *aom_codec_error(aom_codec_ctx_t *ctx) { + return (ctx) ? aom_codec_err_to_string(ctx->err) + : aom_codec_err_to_string(AOM_CODEC_INVALID_PARAM); +} + +const char *aom_codec_error_detail(aom_codec_ctx_t *ctx) { + if (ctx && ctx->err) + return ctx->priv ? ctx->priv->err_detail : ctx->err_detail; + + return NULL; +} + +aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx) { + aom_codec_err_t res; + + if (!ctx) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv) + res = AOM_CODEC_ERROR; + else { + ctx->iface->destroy((aom_codec_alg_priv_t *)ctx->priv); + + ctx->iface = NULL; + ctx->name = NULL; + ctx->priv = NULL; + res = AOM_CODEC_OK; + } + + return SAVE_STATUS(ctx, res); +} + +aom_codec_caps_t aom_codec_get_caps(aom_codec_iface_t *iface) { + return (iface) ? iface->caps : 0; +} + +aom_codec_err_t aom_codec_control_(aom_codec_ctx_t *ctx, int ctrl_id, ...) { + aom_codec_err_t res; + + if (!ctx || !ctrl_id) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv || !ctx->iface->ctrl_maps) + res = AOM_CODEC_ERROR; + else { + aom_codec_ctrl_fn_map_t *entry; + + res = AOM_CODEC_ERROR; + + for (entry = ctx->iface->ctrl_maps; entry && entry->fn; entry++) { + if (!entry->ctrl_id || entry->ctrl_id == ctrl_id) { + va_list ap; + + va_start(ap, ctrl_id); + res = entry->fn((aom_codec_alg_priv_t *)ctx->priv, ap); + va_end(ap); + break; + } + } + } + + return SAVE_STATUS(ctx, res); +} + +void aom_internal_error(struct aom_internal_error_info *info, + aom_codec_err_t error, const char *fmt, ...) { + va_list ap; + + info->error_code = error; + info->has_detail = 0; + + if (fmt) { + size_t sz = sizeof(info->detail); + + info->has_detail = 1; + va_start(ap, fmt); + vsnprintf(info->detail, sz - 1, fmt, ap); + va_end(ap); + info->detail[sz - 1] = '\0'; + } + + if (info->setjmp) longjmp(info->jmp, info->error_code); +}
diff --git a/aom/src/aom_decoder.c b/aom/src/aom_decoder.c new file mode 100644 index 0000000..1fa1dbe --- /dev/null +++ b/aom/src/aom_decoder.c
@@ -0,0 +1,188 @@ +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/*!\file + * \brief Provides the high level interface to wrap decoder algorithms. + * + */ +#include <string.h> +#include "aom/internal/aom_codec_internal.h" + +#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var) + +static aom_codec_alg_priv_t *get_alg_priv(aom_codec_ctx_t *ctx) { + return (aom_codec_alg_priv_t *)ctx->priv; +} + +aom_codec_err_t aom_codec_dec_init_ver(aom_codec_ctx_t *ctx, + aom_codec_iface_t *iface, + const aom_codec_dec_cfg_t *cfg, + aom_codec_flags_t flags, int ver) { + aom_codec_err_t res; + + if (ver != AOM_DECODER_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; + else if (!ctx || !iface) + res = AOM_CODEC_INVALID_PARAM; + else if (iface->abi_version != AOM_CODEC_INTERNAL_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; + else if ((flags & AOM_CODEC_USE_POSTPROC) && + !(iface->caps & AOM_CODEC_CAP_POSTPROC)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_ERROR_CONCEALMENT) && + !(iface->caps & AOM_CODEC_CAP_ERROR_CONCEALMENT)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_INPUT_FRAGMENTS) && + !(iface->caps & AOM_CODEC_CAP_INPUT_FRAGMENTS)) + res = AOM_CODEC_INCAPABLE; + else if (!(iface->caps & AOM_CODEC_CAP_DECODER)) + res = AOM_CODEC_INCAPABLE; + else { + memset(ctx, 0, sizeof(*ctx)); + ctx->iface = iface; + ctx->name = iface->name; + ctx->priv = NULL; + ctx->init_flags = flags; + ctx->config.dec = cfg; + + res = ctx->iface->init(ctx, NULL); + if (res) { + ctx->err_detail = ctx->priv ? ctx->priv->err_detail : NULL; + aom_codec_destroy(ctx); + } + } + + return SAVE_STATUS(ctx, res); +} + +aom_codec_err_t aom_codec_peek_stream_info(aom_codec_iface_t *iface, + const uint8_t *data, + unsigned int data_sz, + aom_codec_stream_info_t *si) { + aom_codec_err_t res; + + if (!iface || !data || !data_sz || !si || + si->sz < sizeof(aom_codec_stream_info_t)) + res = AOM_CODEC_INVALID_PARAM; + else { + /* Set default/unknown values */ + si->w = 0; + si->h = 0; + + res = iface->dec.peek_si(data, data_sz, si); + } + + return res; +} + +aom_codec_err_t aom_codec_get_stream_info(aom_codec_ctx_t *ctx, + aom_codec_stream_info_t *si) { + aom_codec_err_t res; + + if (!ctx || !si || si->sz < sizeof(aom_codec_stream_info_t)) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv) + res = AOM_CODEC_ERROR; + else { + /* Set default/unknown values */ + si->w = 0; + si->h = 0; + + res = ctx->iface->dec.get_si(get_alg_priv(ctx), si); + } + + return SAVE_STATUS(ctx, res); +} + +aom_codec_err_t aom_codec_decode(aom_codec_ctx_t *ctx, const uint8_t *data, + unsigned int data_sz, void *user_priv, + long deadline) { + aom_codec_err_t res; + + /* Sanity checks */ + /* NULL data ptr allowed if data_sz is 0 too */ + if (!ctx || (!data && data_sz) || (data && !data_sz)) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv) + res = AOM_CODEC_ERROR; + else { + res = ctx->iface->dec.decode(get_alg_priv(ctx), data, data_sz, user_priv, + deadline); + } + + return SAVE_STATUS(ctx, res); +} + +aom_image_t *aom_codec_get_frame(aom_codec_ctx_t *ctx, aom_codec_iter_t *iter) { + aom_image_t *img; + + if (!ctx || !iter || !ctx->iface || !ctx->priv) + img = NULL; + else + img = ctx->iface->dec.get_frame(get_alg_priv(ctx), iter); + + return img; +} + +aom_codec_err_t aom_codec_register_put_frame_cb(aom_codec_ctx_t *ctx, + aom_codec_put_frame_cb_fn_t cb, + void *user_priv) { + aom_codec_err_t res; + + if (!ctx || !cb) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv || + !(ctx->iface->caps & AOM_CODEC_CAP_PUT_FRAME)) + res = AOM_CODEC_ERROR; + else { + ctx->priv->dec.put_frame_cb.u.put_frame = cb; + ctx->priv->dec.put_frame_cb.user_priv = user_priv; + res = AOM_CODEC_OK; + } + + return SAVE_STATUS(ctx, res); +} + +aom_codec_err_t aom_codec_register_put_slice_cb(aom_codec_ctx_t *ctx, + aom_codec_put_slice_cb_fn_t cb, + void *user_priv) { + aom_codec_err_t res; + + if (!ctx || !cb) + res = AOM_CODEC_INVALID_PARAM; + else if (!ctx->iface || !ctx->priv || + !(ctx->iface->caps & AOM_CODEC_CAP_PUT_SLICE)) + res = AOM_CODEC_ERROR; + else { + ctx->priv->dec.put_slice_cb.u.put_slice = cb; + ctx->priv->dec.put_slice_cb.user_priv = user_priv; + res = AOM_CODEC_OK; + } + + return SAVE_STATUS(ctx, res); +} + +aom_codec_err_t aom_codec_set_frame_buffer_functions( + aom_codec_ctx_t *ctx, aom_get_frame_buffer_cb_fn_t cb_get, + aom_release_frame_buffer_cb_fn_t cb_release, void *cb_priv) { + aom_codec_err_t res; + + if (!ctx || !cb_get || !cb_release) { + res = AOM_CODEC_INVALID_PARAM; + } else if (!ctx->iface || !ctx->priv || + !(ctx->iface->caps & AOM_CODEC_CAP_EXTERNAL_FRAME_BUFFER)) { + res = AOM_CODEC_ERROR; + } else { + res = ctx->iface->dec.set_fb_fn(get_alg_priv(ctx), cb_get, cb_release, + cb_priv); + } + + return SAVE_STATUS(ctx, res); +}
diff --git a/aom/src/vpx_encoder.c b/aom/src/aom_encoder.c similarity index 61% rename from aom/src/vpx_encoder.c rename to aom/src/aom_encoder.c index f3689e3..0c6fa3d 100644 --- a/aom/src/vpx_encoder.c +++ b/aom/src/aom_encoder.c
@@ -14,34 +14,34 @@ */ #include <limits.h> #include <string.h> -#include "vpx_config.h" -#include "aom/internal/vpx_codec_internal.h" +#include "aom_config.h" +#include "aom/internal/aom_codec_internal.h" #define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var) -static vpx_codec_alg_priv_t *get_alg_priv(vpx_codec_ctx_t *ctx) { - return (vpx_codec_alg_priv_t *)ctx->priv; +static aom_codec_alg_priv_t *get_alg_priv(aom_codec_ctx_t *ctx) { + return (aom_codec_alg_priv_t *)ctx->priv; } -vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t *ctx, - vpx_codec_iface_t *iface, - const vpx_codec_enc_cfg_t *cfg, - vpx_codec_flags_t flags, int ver) { - vpx_codec_err_t res; +aom_codec_err_t aom_codec_enc_init_ver(aom_codec_ctx_t *ctx, + aom_codec_iface_t *iface, + const aom_codec_enc_cfg_t *cfg, + aom_codec_flags_t flags, int ver) { + aom_codec_err_t res; - if (ver != VPX_ENCODER_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; + if (ver != AOM_ENCODER_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; else if (!ctx || !iface || !cfg) - res = VPX_CODEC_INVALID_PARAM; - else if (iface->abi_version != VPX_CODEC_INTERNAL_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; - else if (!(iface->caps & VPX_CODEC_CAP_ENCODER)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_PSNR) && !(iface->caps & VPX_CODEC_CAP_PSNR)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION) && - !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION)) - res = VPX_CODEC_INCAPABLE; + res = AOM_CODEC_INVALID_PARAM; + else if (iface->abi_version != AOM_CODEC_INTERNAL_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; + else if (!(iface->caps & AOM_CODEC_CAP_ENCODER)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_PSNR) && !(iface->caps & AOM_CODEC_CAP_PSNR)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_OUTPUT_PARTITION) && + !(iface->caps & AOM_CODEC_CAP_OUTPUT_PARTITION)) + res = AOM_CODEC_INCAPABLE; else { ctx->iface = iface; ctx->name = iface->name; @@ -52,43 +52,43 @@ if (res) { ctx->err_detail = ctx->priv ? ctx->priv->err_detail : NULL; - vpx_codec_destroy(ctx); + aom_codec_destroy(ctx); } } return SAVE_STATUS(ctx, res); } -vpx_codec_err_t vpx_codec_enc_init_multi_ver( - vpx_codec_ctx_t *ctx, vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg, - int num_enc, vpx_codec_flags_t flags, vpx_rational_t *dsf, int ver) { - vpx_codec_err_t res = VPX_CODEC_OK; +aom_codec_err_t aom_codec_enc_init_multi_ver( + aom_codec_ctx_t *ctx, aom_codec_iface_t *iface, aom_codec_enc_cfg_t *cfg, + int num_enc, aom_codec_flags_t flags, aom_rational_t *dsf, int ver) { + aom_codec_err_t res = AOM_CODEC_OK; - if (ver != VPX_ENCODER_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; + if (ver != AOM_ENCODER_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; else if (!ctx || !iface || !cfg || (num_enc > 16 || num_enc < 1)) - res = VPX_CODEC_INVALID_PARAM; - else if (iface->abi_version != VPX_CODEC_INTERNAL_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; - else if (!(iface->caps & VPX_CODEC_CAP_ENCODER)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_PSNR) && !(iface->caps & VPX_CODEC_CAP_PSNR)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION) && - !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION)) - res = VPX_CODEC_INCAPABLE; + res = AOM_CODEC_INVALID_PARAM; + else if (iface->abi_version != AOM_CODEC_INTERNAL_ABI_VERSION) + res = AOM_CODEC_ABI_MISMATCH; + else if (!(iface->caps & AOM_CODEC_CAP_ENCODER)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_PSNR) && !(iface->caps & AOM_CODEC_CAP_PSNR)) + res = AOM_CODEC_INCAPABLE; + else if ((flags & AOM_CODEC_USE_OUTPUT_PARTITION) && + !(iface->caps & AOM_CODEC_CAP_OUTPUT_PARTITION)) + res = AOM_CODEC_INCAPABLE; else { int i; void *mem_loc = NULL; if (!(res = iface->enc.mr_get_mem_loc(cfg, &mem_loc))) { for (i = 0; i < num_enc; i++) { - vpx_codec_priv_enc_mr_cfg_t mr_cfg; + aom_codec_priv_enc_mr_cfg_t mr_cfg; /* Validate down-sampling factor. */ if (dsf->num < 1 || dsf->num > 4096 || dsf->den < 1 || dsf->den > dsf->num) { - res = VPX_CODEC_INVALID_PARAM; + res = AOM_CODEC_INVALID_PARAM; break; } @@ -102,7 +102,7 @@ * resolution always use the same frame_type chosen by the * lowest-resolution encoder. */ - if (mr_cfg.mr_encoder_id) cfg->kf_mode = VPX_KF_DISABLED; + if (mr_cfg.mr_encoder_id) cfg->kf_mode = AOM_KF_DISABLED; ctx->iface = iface; ctx->name = iface->name; @@ -115,13 +115,13 @@ const char *error_detail = ctx->priv ? ctx->priv->err_detail : NULL; /* Destroy current ctx */ ctx->err_detail = error_detail; - vpx_codec_destroy(ctx); + aom_codec_destroy(ctx); /* Destroy already allocated high-level ctx */ while (i) { ctx--; ctx->err_detail = error_detail; - vpx_codec_destroy(ctx); + aom_codec_destroy(ctx); i--; } } @@ -139,26 +139,26 @@ return SAVE_STATUS(ctx, res); } -vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface, - vpx_codec_enc_cfg_t *cfg, +aom_codec_err_t aom_codec_enc_config_default(aom_codec_iface_t *iface, + aom_codec_enc_cfg_t *cfg, unsigned int usage) { - vpx_codec_err_t res; - vpx_codec_enc_cfg_map_t *map; + aom_codec_err_t res; + aom_codec_enc_cfg_map_t *map; int i; if (!iface || !cfg || usage > INT_MAX) - res = VPX_CODEC_INVALID_PARAM; - else if (!(iface->caps & VPX_CODEC_CAP_ENCODER)) - res = VPX_CODEC_INCAPABLE; + res = AOM_CODEC_INVALID_PARAM; + else if (!(iface->caps & AOM_CODEC_CAP_ENCODER)) + res = AOM_CODEC_INCAPABLE; else { - res = VPX_CODEC_INVALID_PARAM; + res = AOM_CODEC_INVALID_PARAM; for (i = 0; i < iface->enc.cfg_map_count; ++i) { map = iface->enc.cfg_maps + i; if (map->usage == (int)usage) { *cfg = map->cfg; cfg->g_usage = usage; - res = VPX_CODEC_OK; + res = AOM_CODEC_OK; break; } } @@ -185,18 +185,18 @@ static void FLOATING_POINT_RESTORE() {} #endif -vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img, - vpx_codec_pts_t pts, unsigned long duration, - vpx_enc_frame_flags_t flags, +aom_codec_err_t aom_codec_encode(aom_codec_ctx_t *ctx, const aom_image_t *img, + aom_codec_pts_t pts, unsigned long duration, + aom_enc_frame_flags_t flags, unsigned long deadline) { - vpx_codec_err_t res = VPX_CODEC_OK; + aom_codec_err_t res = AOM_CODEC_OK; if (!ctx || (img && !duration)) - res = VPX_CODEC_INVALID_PARAM; + res = AOM_CODEC_INVALID_PARAM; else if (!ctx->iface || !ctx->priv) - res = VPX_CODEC_ERROR; - else if (!(ctx->iface->caps & VPX_CODEC_CAP_ENCODER)) - res = VPX_CODEC_INCAPABLE; + res = AOM_CODEC_ERROR; + else if (!(ctx->iface->caps & AOM_CODEC_CAP_ENCODER)) + res = AOM_CODEC_INCAPABLE; else { unsigned int num_enc = ctx->priv->enc.total_encoders; @@ -236,33 +236,33 @@ return SAVE_STATUS(ctx, res); } -const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx, - vpx_codec_iter_t *iter) { - const vpx_codec_cx_pkt_t *pkt = NULL; +const aom_codec_cx_pkt_t *aom_codec_get_cx_data(aom_codec_ctx_t *ctx, + aom_codec_iter_t *iter) { + const aom_codec_cx_pkt_t *pkt = NULL; if (ctx) { if (!iter) - ctx->err = VPX_CODEC_INVALID_PARAM; + ctx->err = AOM_CODEC_INVALID_PARAM; else if (!ctx->iface || !ctx->priv) - ctx->err = VPX_CODEC_ERROR; - else if (!(ctx->iface->caps & VPX_CODEC_CAP_ENCODER)) - ctx->err = VPX_CODEC_INCAPABLE; + ctx->err = AOM_CODEC_ERROR; + else if (!(ctx->iface->caps & AOM_CODEC_CAP_ENCODER)) + ctx->err = AOM_CODEC_INCAPABLE; else pkt = ctx->iface->enc.get_cx_data(get_alg_priv(ctx), iter); } - if (pkt && pkt->kind == VPX_CODEC_CX_FRAME_PKT) { + if (pkt && pkt->kind == AOM_CODEC_CX_FRAME_PKT) { // If the application has specified a destination area for the // compressed data, and the codec has not placed the data there, // and it fits, copy it. - vpx_codec_priv_t *const priv = ctx->priv; + aom_codec_priv_t *const priv = ctx->priv; char *const dst_buf = (char *)priv->enc.cx_data_dst_buf.buf; if (dst_buf && pkt->data.raw.buf != dst_buf && pkt->data.raw.sz + priv->enc.cx_data_pad_before + priv->enc.cx_data_pad_after <= priv->enc.cx_data_dst_buf.sz) { - vpx_codec_cx_pkt_t *modified_pkt = &priv->enc.cx_data_pkt; + aom_codec_cx_pkt_t *modified_pkt = &priv->enc.cx_data_pkt; memcpy(dst_buf + priv->enc.cx_data_pad_before, pkt->data.raw.buf, pkt->data.raw.sz); @@ -282,11 +282,11 @@ return pkt; } -vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t *ctx, - const vpx_fixed_buf_t *buf, +aom_codec_err_t aom_codec_set_cx_data_buf(aom_codec_ctx_t *ctx, + const aom_fixed_buf_t *buf, unsigned int pad_before, unsigned int pad_after) { - if (!ctx || !ctx->priv) return VPX_CODEC_INVALID_PARAM; + if (!ctx || !ctx->priv) return AOM_CODEC_INVALID_PARAM; if (buf) { ctx->priv->enc.cx_data_dst_buf = *buf; @@ -299,19 +299,19 @@ ctx->priv->enc.cx_data_pad_after = 0; } - return VPX_CODEC_OK; + return AOM_CODEC_OK; } -const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t *ctx) { - vpx_image_t *img = NULL; +const aom_image_t *aom_codec_get_preview_frame(aom_codec_ctx_t *ctx) { + aom_image_t *img = NULL; if (ctx) { if (!ctx->iface || !ctx->priv) - ctx->err = VPX_CODEC_ERROR; - else if (!(ctx->iface->caps & VPX_CODEC_CAP_ENCODER)) - ctx->err = VPX_CODEC_INCAPABLE; + ctx->err = AOM_CODEC_ERROR; + else if (!(ctx->iface->caps & AOM_CODEC_CAP_ENCODER)) + ctx->err = AOM_CODEC_INCAPABLE; else if (!ctx->iface->enc.get_preview) - ctx->err = VPX_CODEC_INCAPABLE; + ctx->err = AOM_CODEC_INCAPABLE; else img = ctx->iface->enc.get_preview(get_alg_priv(ctx)); } @@ -319,16 +319,16 @@ return img; } -vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t *ctx) { - vpx_fixed_buf_t *buf = NULL; +aom_fixed_buf_t *aom_codec_get_global_headers(aom_codec_ctx_t *ctx) { + aom_fixed_buf_t *buf = NULL; if (ctx) { if (!ctx->iface || !ctx->priv) - ctx->err = VPX_CODEC_ERROR; - else if (!(ctx->iface->caps & VPX_CODEC_CAP_ENCODER)) - ctx->err = VPX_CODEC_INCAPABLE; + ctx->err = AOM_CODEC_ERROR; + else if (!(ctx->iface->caps & AOM_CODEC_CAP_ENCODER)) + ctx->err = AOM_CODEC_INCAPABLE; else if (!ctx->iface->enc.get_glob_hdrs) - ctx->err = VPX_CODEC_INCAPABLE; + ctx->err = AOM_CODEC_INCAPABLE; else buf = ctx->iface->enc.get_glob_hdrs(get_alg_priv(ctx)); } @@ -336,22 +336,22 @@ return buf; } -vpx_codec_err_t vpx_codec_enc_config_set(vpx_codec_ctx_t *ctx, - const vpx_codec_enc_cfg_t *cfg) { - vpx_codec_err_t res; +aom_codec_err_t aom_codec_enc_config_set(aom_codec_ctx_t *ctx, + const aom_codec_enc_cfg_t *cfg) { + aom_codec_err_t res; if (!ctx || !ctx->iface || !ctx->priv || !cfg) - res = VPX_CODEC_INVALID_PARAM; - else if (!(ctx->iface->caps & VPX_CODEC_CAP_ENCODER)) - res = VPX_CODEC_INCAPABLE; + res = AOM_CODEC_INVALID_PARAM; + else if (!(ctx->iface->caps & AOM_CODEC_CAP_ENCODER)) + res = AOM_CODEC_INCAPABLE; else res = ctx->iface->enc.cfg_set(get_alg_priv(ctx), cfg); return SAVE_STATUS(ctx, res); } -int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *list, - const struct vpx_codec_cx_pkt *pkt) { +int aom_codec_pkt_list_add(struct aom_codec_pkt_list *list, + const struct aom_codec_cx_pkt *pkt) { if (list->cnt < list->max) { list->pkts[list->cnt++] = *pkt; return 0; @@ -360,15 +360,15 @@ return 1; } -const vpx_codec_cx_pkt_t *vpx_codec_pkt_list_get( - struct vpx_codec_pkt_list *list, vpx_codec_iter_t *iter) { - const vpx_codec_cx_pkt_t *pkt; +const aom_codec_cx_pkt_t *aom_codec_pkt_list_get( + struct aom_codec_pkt_list *list, aom_codec_iter_t *iter) { + const aom_codec_cx_pkt_t *pkt; if (!(*iter)) { *iter = list->pkts; } - pkt = (const vpx_codec_cx_pkt_t *)*iter; + pkt = (const aom_codec_cx_pkt_t *)*iter; if ((size_t)(pkt - list->pkts) < list->cnt) *iter = pkt + 1;
diff --git a/aom/src/aom_image.c b/aom/src/aom_image.c new file mode 100644 index 0000000..6572409 --- /dev/null +++ b/aom/src/aom_image.c
@@ -0,0 +1,239 @@ +/* + * Copyright (c) 2010 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include <stdlib.h> +#include <string.h> + +#include "aom/aom_image.h" +#include "aom/aom_integer.h" +#include "aom_mem/aom_mem.h" + +static aom_image_t *img_alloc_helper(aom_image_t *img, aom_img_fmt_t fmt, + unsigned int d_w, unsigned int d_h, + unsigned int buf_align, + unsigned int stride_align, + unsigned char *img_data) { + unsigned int h, w, s, xcs, ycs, bps; + unsigned int stride_in_bytes; + int align; + + /* Treat align==0 like align==1 */ + if (!buf_align) buf_align = 1; + + /* Validate alignment (must be power of 2) */ + if (buf_align & (buf_align - 1)) goto fail; + + /* Treat align==0 like align==1 */ + if (!stride_align) stride_align = 1; + + /* Validate alignment (must be power of 2) */ + if (stride_align & (stride_align - 1)) goto fail; + + /* Get sample size for this format */ + switch (fmt) { + case AOM_IMG_FMT_RGB32: + case AOM_IMG_FMT_RGB32_LE: + case AOM_IMG_FMT_ARGB: + case AOM_IMG_FMT_ARGB_LE: bps = 32; break; + case AOM_IMG_FMT_RGB24: + case AOM_IMG_FMT_BGR24: bps = 24; break; + case AOM_IMG_FMT_RGB565: + case AOM_IMG_FMT_RGB565_LE: + case AOM_IMG_FMT_RGB555: + case AOM_IMG_FMT_RGB555_LE: + case AOM_IMG_FMT_UYVY: + case AOM_IMG_FMT_YUY2: + case AOM_IMG_FMT_YVYU: bps = 16; break; + case AOM_IMG_FMT_I420: + case AOM_IMG_FMT_YV12: + case AOM_IMG_FMT_AOMI420: + case AOM_IMG_FMT_AOMYV12: bps = 12; break; + case AOM_IMG_FMT_I422: + case AOM_IMG_FMT_I440: bps = 16; break; + case AOM_IMG_FMT_I444: bps = 24; break; + case AOM_IMG_FMT_I42016: bps = 24; break; + case AOM_IMG_FMT_I42216: + case AOM_IMG_FMT_I44016: bps = 32; break; + case AOM_IMG_FMT_I44416: bps = 48; break; + default: bps = 16; break; + } + + /* Get chroma shift values for this format */ + switch (fmt) { + case AOM_IMG_FMT_I420: + case AOM_IMG_FMT_YV12: + case AOM_IMG_FMT_AOMI420: + case AOM_IMG_FMT_AOMYV12: + case AOM_IMG_FMT_I422: + case AOM_IMG_FMT_I42016: + case AOM_IMG_FMT_I42216: xcs = 1; break; + default: xcs = 0; break; + } + + switch (fmt) { + case AOM_IMG_FMT_I420: + case AOM_IMG_FMT_I440: + case AOM_IMG_FMT_YV12: + case AOM_IMG_FMT_AOMI420: + case AOM_IMG_FMT_AOMYV12: + case AOM_IMG_FMT_I42016: + case AOM_IMG_FMT_I44016: ycs = 1; break; + default: ycs = 0; break; + } + + /* Calculate storage sizes given the chroma subsampling */ + align = (1 << xcs) - 1; + w = (d_w + align) & ~align; + align = (1 << ycs) - 1; + h = (d_h + align) & ~align; + s = (fmt & AOM_IMG_FMT_PLANAR) ? w : bps * w / 8; + s = (s + stride_align - 1) & ~(stride_align - 1); + stride_in_bytes = (fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? s * 2 : s; + + /* Allocate the new image */ + if (!img) { + img = (aom_image_t *)calloc(1, sizeof(aom_image_t)); + + if (!img) goto fail; + + img->self_allocd = 1; + } else { + memset(img, 0, sizeof(aom_image_t)); + } + + img->img_data = img_data; + + if (!img_data) { + const uint64_t alloc_size = (fmt & AOM_IMG_FMT_PLANAR) + ? (uint64_t)h * s * bps / 8 + : (uint64_t)h * s; + + if (alloc_size != (size_t)alloc_size) goto fail; + + img->img_data = (uint8_t *)aom_memalign(buf_align, (size_t)alloc_size); + img->img_data_owner = 1; + } + + if (!img->img_data) goto fail; + + img->fmt = fmt; + img->bit_depth = (fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 16 : 8; + img->w = w; + img->h = h; + img->x_chroma_shift = xcs; + img->y_chroma_shift = ycs; + img->bps = bps; + + /* Calculate strides */ + img->stride[AOM_PLANE_Y] = img->stride[AOM_PLANE_ALPHA] = stride_in_bytes; + img->stride[AOM_PLANE_U] = img->stride[AOM_PLANE_V] = stride_in_bytes >> xcs; + + /* Default viewport to entire image */ + if (!aom_img_set_rect(img, 0, 0, d_w, d_h)) return img; + +fail: + aom_img_free(img); + return NULL; +} + +aom_image_t *aom_img_alloc(aom_image_t *img, aom_img_fmt_t fmt, + unsigned int d_w, unsigned int d_h, + unsigned int align) { + return img_alloc_helper(img, fmt, d_w, d_h, align, align, NULL); +} + +aom_image_t *aom_img_wrap(aom_image_t *img, aom_img_fmt_t fmt, unsigned int d_w, + unsigned int d_h, unsigned int stride_align, + unsigned char *img_data) { + /* By setting buf_align = 1, we don't change buffer alignment in this + * function. */ + return img_alloc_helper(img, fmt, d_w, d_h, 1, stride_align, img_data); +} + +int aom_img_set_rect(aom_image_t *img, unsigned int x, unsigned int y, + unsigned int w, unsigned int h) { + unsigned char *data; + + if (x + w <= img->w && y + h <= img->h) { + img->d_w = w; + img->d_h = h; + + /* Calculate plane pointers */ + if (!(img->fmt & AOM_IMG_FMT_PLANAR)) { + img->planes[AOM_PLANE_PACKED] = + img->img_data + x * img->bps / 8 + y * img->stride[AOM_PLANE_PACKED]; + } else { + const int bytes_per_sample = + (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; + data = img->img_data; + + if (img->fmt & AOM_IMG_FMT_HAS_ALPHA) { + img->planes[AOM_PLANE_ALPHA] = + data + x * bytes_per_sample + y * img->stride[AOM_PLANE_ALPHA]; + data += img->h * img->stride[AOM_PLANE_ALPHA]; + } + + img->planes[AOM_PLANE_Y] = + data + x * bytes_per_sample + y * img->stride[AOM_PLANE_Y]; + data += img->h * img->stride[AOM_PLANE_Y]; + + if (!(img->fmt & AOM_IMG_FMT_UV_FLIP)) { + img->planes[AOM_PLANE_U] = + data + (x >> img->x_chroma_shift) * bytes_per_sample + + (y >> img->y_chroma_shift) * img->stride[AOM_PLANE_U]; + data += (img->h >> img->y_chroma_shift) * img->stride[AOM_PLANE_U]; + img->planes[AOM_PLANE_V] = + data + (x >> img->x_chroma_shift) * bytes_per_sample + + (y >> img->y_chroma_shift) * img->stride[AOM_PLANE_V]; + } else { + img->planes[AOM_PLANE_V] = + data + (x >> img->x_chroma_shift) * bytes_per_sample + + (y >> img->y_chroma_shift) * img->stride[AOM_PLANE_V]; + data += (img->h >> img->y_chroma_shift) * img->stride[AOM_PLANE_V]; + img->planes[AOM_PLANE_U] = + data + (x >> img->x_chroma_shift) * bytes_per_sample + + (y >> img->y_chroma_shift) * img->stride[AOM_PLANE_U]; + } + } + return 0; + } + return -1; +} + +void aom_img_flip(aom_image_t *img) { + /* Note: In the calculation pointer adjustment calculation, we want the + * rhs to be promoted to a signed type. Section 6.3.1.8 of the ISO C99 + * standard indicates that if the adjustment parameter is unsigned, the + * stride parameter will be promoted to unsigned, causing errors when + * the lhs is a larger type than the rhs. + */ + img->planes[AOM_PLANE_Y] += (signed)(img->d_h - 1) * img->stride[AOM_PLANE_Y]; + img->stride[AOM_PLANE_Y] = -img->stride[AOM_PLANE_Y]; + + img->planes[AOM_PLANE_U] += (signed)((img->d_h >> img->y_chroma_shift) - 1) * + img->stride[AOM_PLANE_U]; + img->stride[AOM_PLANE_U] = -img->stride[AOM_PLANE_U]; + + img->planes[AOM_PLANE_V] += (signed)((img->d_h >> img->y_chroma_shift) - 1) * + img->stride[AOM_PLANE_V]; + img->stride[AOM_PLANE_V] = -img->stride[AOM_PLANE_V]; + + img->planes[AOM_PLANE_ALPHA] += + (signed)(img->d_h - 1) * img->stride[AOM_PLANE_ALPHA]; + img->stride[AOM_PLANE_ALPHA] = -img->stride[AOM_PLANE_ALPHA]; +} + +void aom_img_free(aom_image_t *img) { + if (img) { + if (img->img_data && img->img_data_owner) aom_free(img->img_data); + + if (img->self_allocd) free(img); + } +}
diff --git a/aom/src/vpx_codec.c b/aom/src/vpx_codec.c deleted file mode 100644 index 7bdc870..0000000 --- a/aom/src/vpx_codec.c +++ /dev/null
@@ -1,133 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -/*!\file - * \brief Provides the high level interface to wrap decoder algorithms. - * - */ -#include <stdarg.h> -#include <stdlib.h> -#include "aom/vpx_integer.h" -#include "aom/internal/vpx_codec_internal.h" -#include "vpx_version.h" - -#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var) - -int vpx_codec_version(void) { return VERSION_PACKED; } - -const char *vpx_codec_version_str(void) { return VERSION_STRING_NOSP; } - -const char *vpx_codec_version_extra_str(void) { return VERSION_EXTRA; } - -const char *vpx_codec_iface_name(vpx_codec_iface_t *iface) { - return iface ? iface->name : "<invalid interface>"; -} - -const char *vpx_codec_err_to_string(vpx_codec_err_t err) { - switch (err) { - case VPX_CODEC_OK: return "Success"; - case VPX_CODEC_ERROR: return "Unspecified internal error"; - case VPX_CODEC_MEM_ERROR: return "Memory allocation error"; - case VPX_CODEC_ABI_MISMATCH: return "ABI version mismatch"; - case VPX_CODEC_INCAPABLE: - return "Codec does not implement requested capability"; - case VPX_CODEC_UNSUP_BITSTREAM: - return "Bitstream not supported by this decoder"; - case VPX_CODEC_UNSUP_FEATURE: - return "Bitstream required feature not supported by this decoder"; - case VPX_CODEC_CORRUPT_FRAME: return "Corrupt frame detected"; - case VPX_CODEC_INVALID_PARAM: return "Invalid parameter"; - case VPX_CODEC_LIST_END: return "End of iterated list"; - } - - return "Unrecognized error code"; -} - -const char *vpx_codec_error(vpx_codec_ctx_t *ctx) { - return (ctx) ? vpx_codec_err_to_string(ctx->err) - : vpx_codec_err_to_string(VPX_CODEC_INVALID_PARAM); -} - -const char *vpx_codec_error_detail(vpx_codec_ctx_t *ctx) { - if (ctx && ctx->err) - return ctx->priv ? ctx->priv->err_detail : ctx->err_detail; - - return NULL; -} - -vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx) { - vpx_codec_err_t res; - - if (!ctx) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv) - res = VPX_CODEC_ERROR; - else { - ctx->iface->destroy((vpx_codec_alg_priv_t *)ctx->priv); - - ctx->iface = NULL; - ctx->name = NULL; - ctx->priv = NULL; - res = VPX_CODEC_OK; - } - - return SAVE_STATUS(ctx, res); -} - -vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface) { - return (iface) ? iface->caps : 0; -} - -vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id, ...) { - vpx_codec_err_t res; - - if (!ctx || !ctrl_id) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv || !ctx->iface->ctrl_maps) - res = VPX_CODEC_ERROR; - else { - vpx_codec_ctrl_fn_map_t *entry; - - res = VPX_CODEC_ERROR; - - for (entry = ctx->iface->ctrl_maps; entry && entry->fn; entry++) { - if (!entry->ctrl_id || entry->ctrl_id == ctrl_id) { - va_list ap; - - va_start(ap, ctrl_id); - res = entry->fn((vpx_codec_alg_priv_t *)ctx->priv, ap); - va_end(ap); - break; - } - } - } - - return SAVE_STATUS(ctx, res); -} - -void vpx_internal_error(struct vpx_internal_error_info *info, - vpx_codec_err_t error, const char *fmt, ...) { - va_list ap; - - info->error_code = error; - info->has_detail = 0; - - if (fmt) { - size_t sz = sizeof(info->detail); - - info->has_detail = 1; - va_start(ap, fmt); - vsnprintf(info->detail, sz - 1, fmt, ap); - va_end(ap); - info->detail[sz - 1] = '\0'; - } - - if (info->setjmp) longjmp(info->jmp, info->error_code); -}
diff --git a/aom/src/vpx_decoder.c b/aom/src/vpx_decoder.c deleted file mode 100644 index 97709d1..0000000 --- a/aom/src/vpx_decoder.c +++ /dev/null
@@ -1,188 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -/*!\file - * \brief Provides the high level interface to wrap decoder algorithms. - * - */ -#include <string.h> -#include "aom/internal/vpx_codec_internal.h" - -#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var) - -static vpx_codec_alg_priv_t *get_alg_priv(vpx_codec_ctx_t *ctx) { - return (vpx_codec_alg_priv_t *)ctx->priv; -} - -vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t *ctx, - vpx_codec_iface_t *iface, - const vpx_codec_dec_cfg_t *cfg, - vpx_codec_flags_t flags, int ver) { - vpx_codec_err_t res; - - if (ver != VPX_DECODER_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; - else if (!ctx || !iface) - res = VPX_CODEC_INVALID_PARAM; - else if (iface->abi_version != VPX_CODEC_INTERNAL_ABI_VERSION) - res = VPX_CODEC_ABI_MISMATCH; - else if ((flags & VPX_CODEC_USE_POSTPROC) && - !(iface->caps & VPX_CODEC_CAP_POSTPROC)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_ERROR_CONCEALMENT) && - !(iface->caps & VPX_CODEC_CAP_ERROR_CONCEALMENT)) - res = VPX_CODEC_INCAPABLE; - else if ((flags & VPX_CODEC_USE_INPUT_FRAGMENTS) && - !(iface->caps & VPX_CODEC_CAP_INPUT_FRAGMENTS)) - res = VPX_CODEC_INCAPABLE; - else if (!(iface->caps & VPX_CODEC_CAP_DECODER)) - res = VPX_CODEC_INCAPABLE; - else { - memset(ctx, 0, sizeof(*ctx)); - ctx->iface = iface; - ctx->name = iface->name; - ctx->priv = NULL; - ctx->init_flags = flags; - ctx->config.dec = cfg; - - res = ctx->iface->init(ctx, NULL); - if (res) { - ctx->err_detail = ctx->priv ? ctx->priv->err_detail : NULL; - vpx_codec_destroy(ctx); - } - } - - return SAVE_STATUS(ctx, res); -} - -vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t *iface, - const uint8_t *data, - unsigned int data_sz, - vpx_codec_stream_info_t *si) { - vpx_codec_err_t res; - - if (!iface || !data || !data_sz || !si || - si->sz < sizeof(vpx_codec_stream_info_t)) - res = VPX_CODEC_INVALID_PARAM; - else { - /* Set default/unknown values */ - si->w = 0; - si->h = 0; - - res = iface->dec.peek_si(data, data_sz, si); - } - - return res; -} - -vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t *ctx, - vpx_codec_stream_info_t *si) { - vpx_codec_err_t res; - - if (!ctx || !si || si->sz < sizeof(vpx_codec_stream_info_t)) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv) - res = VPX_CODEC_ERROR; - else { - /* Set default/unknown values */ - si->w = 0; - si->h = 0; - - res = ctx->iface->dec.get_si(get_alg_priv(ctx), si); - } - - return SAVE_STATUS(ctx, res); -} - -vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data, - unsigned int data_sz, void *user_priv, - long deadline) { - vpx_codec_err_t res; - - /* Sanity checks */ - /* NULL data ptr allowed if data_sz is 0 too */ - if (!ctx || (!data && data_sz) || (data && !data_sz)) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv) - res = VPX_CODEC_ERROR; - else { - res = ctx->iface->dec.decode(get_alg_priv(ctx), data, data_sz, user_priv, - deadline); - } - - return SAVE_STATUS(ctx, res); -} - -vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter) { - vpx_image_t *img; - - if (!ctx || !iter || !ctx->iface || !ctx->priv) - img = NULL; - else - img = ctx->iface->dec.get_frame(get_alg_priv(ctx), iter); - - return img; -} - -vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t *ctx, - vpx_codec_put_frame_cb_fn_t cb, - void *user_priv) { - vpx_codec_err_t res; - - if (!ctx || !cb) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv || - !(ctx->iface->caps & VPX_CODEC_CAP_PUT_FRAME)) - res = VPX_CODEC_ERROR; - else { - ctx->priv->dec.put_frame_cb.u.put_frame = cb; - ctx->priv->dec.put_frame_cb.user_priv = user_priv; - res = VPX_CODEC_OK; - } - - return SAVE_STATUS(ctx, res); -} - -vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t *ctx, - vpx_codec_put_slice_cb_fn_t cb, - void *user_priv) { - vpx_codec_err_t res; - - if (!ctx || !cb) - res = VPX_CODEC_INVALID_PARAM; - else if (!ctx->iface || !ctx->priv || - !(ctx->iface->caps & VPX_CODEC_CAP_PUT_SLICE)) - res = VPX_CODEC_ERROR; - else { - ctx->priv->dec.put_slice_cb.u.put_slice = cb; - ctx->priv->dec.put_slice_cb.user_priv = user_priv; - res = VPX_CODEC_OK; - } - - return SAVE_STATUS(ctx, res); -} - -vpx_codec_err_t vpx_codec_set_frame_buffer_functions( - vpx_codec_ctx_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get, - vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv) { - vpx_codec_err_t res; - - if (!ctx || !cb_get || !cb_release) { - res = VPX_CODEC_INVALID_PARAM; - } else if (!ctx->iface || !ctx->priv || - !(ctx->iface->caps & VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER)) { - res = VPX_CODEC_ERROR; - } else { - res = ctx->iface->dec.set_fb_fn(get_alg_priv(ctx), cb_get, cb_release, - cb_priv); - } - - return SAVE_STATUS(ctx, res); -}
diff --git a/aom/src/vpx_image.c b/aom/src/vpx_image.c deleted file mode 100644 index 0970b06..0000000 --- a/aom/src/vpx_image.c +++ /dev/null
@@ -1,239 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include <stdlib.h> -#include <string.h> - -#include "aom/vpx_image.h" -#include "aom/vpx_integer.h" -#include "aom_mem/vpx_mem.h" - -static vpx_image_t *img_alloc_helper(vpx_image_t *img, vpx_img_fmt_t fmt, - unsigned int d_w, unsigned int d_h, - unsigned int buf_align, - unsigned int stride_align, - unsigned char *img_data) { - unsigned int h, w, s, xcs, ycs, bps; - unsigned int stride_in_bytes; - int align; - - /* Treat align==0 like align==1 */ - if (!buf_align) buf_align = 1; - - /* Validate alignment (must be power of 2) */ - if (buf_align & (buf_align - 1)) goto fail; - - /* Treat align==0 like align==1 */ - if (!stride_align) stride_align = 1; - - /* Validate alignment (must be power of 2) */ - if (stride_align & (stride_align - 1)) goto fail; - - /* Get sample size for this format */ - switch (fmt) { - case VPX_IMG_FMT_RGB32: - case VPX_IMG_FMT_RGB32_LE: - case VPX_IMG_FMT_ARGB: - case VPX_IMG_FMT_ARGB_LE: bps = 32; break; - case VPX_IMG_FMT_RGB24: - case VPX_IMG_FMT_BGR24: bps = 24; break; - case VPX_IMG_FMT_RGB565: - case VPX_IMG_FMT_RGB565_LE: - case VPX_IMG_FMT_RGB555: - case VPX_IMG_FMT_RGB555_LE: - case VPX_IMG_FMT_UYVY: - case VPX_IMG_FMT_YUY2: - case VPX_IMG_FMT_YVYU: bps = 16; break; - case VPX_IMG_FMT_I420: - case VPX_IMG_FMT_YV12: - case VPX_IMG_FMT_VPXI420: - case VPX_IMG_FMT_VPXYV12: bps = 12; break; - case VPX_IMG_FMT_I422: - case VPX_IMG_FMT_I440: bps = 16; break; - case VPX_IMG_FMT_I444: bps = 24; break; - case VPX_IMG_FMT_I42016: bps = 24; break; - case VPX_IMG_FMT_I42216: - case VPX_IMG_FMT_I44016: bps = 32; break; - case VPX_IMG_FMT_I44416: bps = 48; break; - default: bps = 16; break; - } - - /* Get chroma shift values for this format */ - switch (fmt) { - case VPX_IMG_FMT_I420: - case VPX_IMG_FMT_YV12: - case VPX_IMG_FMT_VPXI420: - case VPX_IMG_FMT_VPXYV12: - case VPX_IMG_FMT_I422: - case VPX_IMG_FMT_I42016: - case VPX_IMG_FMT_I42216: xcs = 1; break; - default: xcs = 0; break; - } - - switch (fmt) { - case VPX_IMG_FMT_I420: - case VPX_IMG_FMT_I440: - case VPX_IMG_FMT_YV12: - case VPX_IMG_FMT_VPXI420: - case VPX_IMG_FMT_VPXYV12: - case VPX_IMG_FMT_I42016: - case VPX_IMG_FMT_I44016: ycs = 1; break; - default: ycs = 0; break; - } - - /* Calculate storage sizes given the chroma subsampling */ - align = (1 << xcs) - 1; - w = (d_w + align) & ~align; - align = (1 << ycs) - 1; - h = (d_h + align) & ~align; - s = (fmt & VPX_IMG_FMT_PLANAR) ? w : bps * w / 8; - s = (s + stride_align - 1) & ~(stride_align - 1); - stride_in_bytes = (fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? s * 2 : s; - - /* Allocate the new image */ - if (!img) { - img = (vpx_image_t *)calloc(1, sizeof(vpx_image_t)); - - if (!img) goto fail; - - img->self_allocd = 1; - } else { - memset(img, 0, sizeof(vpx_image_t)); - } - - img->img_data = img_data; - - if (!img_data) { - const uint64_t alloc_size = (fmt & VPX_IMG_FMT_PLANAR) - ? (uint64_t)h * s * bps / 8 - : (uint64_t)h * s; - - if (alloc_size != (size_t)alloc_size) goto fail; - - img->img_data = (uint8_t *)vpx_memalign(buf_align, (size_t)alloc_size); - img->img_data_owner = 1; - } - - if (!img->img_data) goto fail; - - img->fmt = fmt; - img->bit_depth = (fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 16 : 8; - img->w = w; - img->h = h; - img->x_chroma_shift = xcs; - img->y_chroma_shift = ycs; - img->bps = bps; - - /* Calculate strides */ - img->stride[VPX_PLANE_Y] = img->stride[VPX_PLANE_ALPHA] = stride_in_bytes; - img->stride[VPX_PLANE_U] = img->stride[VPX_PLANE_V] = stride_in_bytes >> xcs; - - /* Default viewport to entire image */ - if (!vpx_img_set_rect(img, 0, 0, d_w, d_h)) return img; - -fail: - vpx_img_free(img); - return NULL; -} - -vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt, - unsigned int d_w, unsigned int d_h, - unsigned int align) { - return img_alloc_helper(img, fmt, d_w, d_h, align, align, NULL); -} - -vpx_image_t *vpx_img_wrap(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, - unsigned int d_h, unsigned int stride_align, - unsigned char *img_data) { - /* By setting buf_align = 1, we don't change buffer alignment in this - * function. */ - return img_alloc_helper(img, fmt, d_w, d_h, 1, stride_align, img_data); -} - -int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y, - unsigned int w, unsigned int h) { - unsigned char *data; - - if (x + w <= img->w && y + h <= img->h) { - img->d_w = w; - img->d_h = h; - - /* Calculate plane pointers */ - if (!(img->fmt & VPX_IMG_FMT_PLANAR)) { - img->planes[VPX_PLANE_PACKED] = - img->img_data + x * img->bps / 8 + y * img->stride[VPX_PLANE_PACKED]; - } else { - const int bytes_per_sample = - (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; - data = img->img_data; - - if (img->fmt & VPX_IMG_FMT_HAS_ALPHA) { - img->planes[VPX_PLANE_ALPHA] = - data + x * bytes_per_sample + y * img->stride[VPX_PLANE_ALPHA]; - data += img->h * img->stride[VPX_PLANE_ALPHA]; - } - - img->planes[VPX_PLANE_Y] = - data + x * bytes_per_sample + y * img->stride[VPX_PLANE_Y]; - data += img->h * img->stride[VPX_PLANE_Y]; - - if (!(img->fmt & VPX_IMG_FMT_UV_FLIP)) { - img->planes[VPX_PLANE_U] = - data + (x >> img->x_chroma_shift) * bytes_per_sample + - (y >> img->y_chroma_shift) * img->stride[VPX_PLANE_U]; - data += (img->h >> img->y_chroma_shift) * img->stride[VPX_PLANE_U]; - img->planes[VPX_PLANE_V] = - data + (x >> img->x_chroma_shift) * bytes_per_sample + - (y >> img->y_chroma_shift) * img->stride[VPX_PLANE_V]; - } else { - img->planes[VPX_PLANE_V] = - data + (x >> img->x_chroma_shift) * bytes_per_sample + - (y >> img->y_chroma_shift) * img->stride[VPX_PLANE_V]; - data += (img->h >> img->y_chroma_shift) * img->stride[VPX_PLANE_V]; - img->planes[VPX_PLANE_U] = - data + (x >> img->x_chroma_shift) * bytes_per_sample + - (y >> img->y_chroma_shift) * img->stride[VPX_PLANE_U]; - } - } - return 0; - } - return -1; -} - -void vpx_img_flip(vpx_image_t *img) { - /* Note: In the calculation pointer adjustment calculation, we want the - * rhs to be promoted to a signed type. Section 6.3.1.8 of the ISO C99 - * standard indicates that if the adjustment parameter is unsigned, the - * stride parameter will be promoted to unsigned, causing errors when - * the lhs is a larger type than the rhs. - */ - img->planes[VPX_PLANE_Y] += (signed)(img->d_h - 1) * img->stride[VPX_PLANE_Y]; - img->stride[VPX_PLANE_Y] = -img->stride[VPX_PLANE_Y]; - - img->planes[VPX_PLANE_U] += (signed)((img->d_h >> img->y_chroma_shift) - 1) * - img->stride[VPX_PLANE_U]; - img->stride[VPX_PLANE_U] = -img->stride[VPX_PLANE_U]; - - img->planes[VPX_PLANE_V] += (signed)((img->d_h >> img->y_chroma_shift) - 1) * - img->stride[VPX_PLANE_V]; - img->stride[VPX_PLANE_V] = -img->stride[VPX_PLANE_V]; - - img->planes[VPX_PLANE_ALPHA] += - (signed)(img->d_h - 1) * img->stride[VPX_PLANE_ALPHA]; - img->stride[VPX_PLANE_ALPHA] = -img->stride[VPX_PLANE_ALPHA]; -} - -void vpx_img_free(vpx_image_t *img) { - if (img) { - if (img->img_data && img->img_data_owner) vpx_free(img->img_data); - - if (img->self_allocd) free(img); - } -}
diff --git a/aom/vp8.h b/aom/vp8.h deleted file mode 100644 index e27b705..0000000 --- a/aom/vp8.h +++ /dev/null
@@ -1,159 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -/*!\defgroup vp8 VP8 - * \ingroup codecs - * VP8 is vpx's newest video compression algorithm that uses motion - * compensated prediction, Discrete Cosine Transform (DCT) coding of the - * prediction error signal and context dependent entropy coding techniques - * based on arithmetic principles. It features: - * - YUV 4:2:0 image format - * - Macro-block based coding (16x16 luma plus two 8x8 chroma) - * - 1/4 (1/8) pixel accuracy motion compensated prediction - * - 4x4 DCT transform - * - 128 level linear quantizer - * - In loop deblocking filter - * - Context-based entropy coding - * - * @{ - */ -/*!\file - * \brief Provides controls common to both the VP8 encoder and decoder. - */ -#ifndef VPX_VP8_H_ -#define VPX_VP8_H_ - -#include "./vpx_codec.h" -#include "./vpx_image.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/*!\brief Control functions - * - * The set of macros define the control functions of VP8 interface - */ -enum vp8_com_control_id { - /*!\brief pass in an external frame into decoder to be used as reference frame - */ - VP8_SET_REFERENCE = 1, - VP8_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */ - VP8_SET_POSTPROC = 3, /**< set the decoder's post processing settings */ - VP8_SET_DBG_COLOR_REF_FRAME = - 4, /**< set the reference frames to color for each macroblock */ - VP8_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */ - VP8_SET_DBG_COLOR_B_MODES = 6, /**< set which blocks modes to color */ - VP8_SET_DBG_DISPLAY_MV = 7, /**< set which motion vector modes to draw */ - - /* TODO(jkoleszar): The encoder incorrectly reuses some of these values (5+) - * for its control ids. These should be migrated to something like the - * VP8_DECODER_CTRL_ID_START range next time we're ready to break the ABI. - */ - VP9_GET_REFERENCE = 128, /**< get a pointer to a reference frame */ - VP8_COMMON_CTRL_ID_MAX, - - VP10_GET_NEW_FRAME_IMAGE = 192, /**< get a pointer to the new frame */ - - VP8_DECODER_CTRL_ID_START = 256 -}; - -/*!\brief post process flags - * - * The set of macros define VP8 decoder post processing flags - */ -enum vp8_postproc_level { - VP8_NOFILTERING = 0, - VP8_DEBLOCK = 1 << 0, - VP8_DEMACROBLOCK = 1 << 1, - VP8_ADDNOISE = 1 << 2, - VP8_DEBUG_TXT_FRAME_INFO = 1 << 3, /**< print frame information */ - VP8_DEBUG_TXT_MBLK_MODES = - 1 << 4, /**< print macro block modes over each macro block */ - VP8_DEBUG_TXT_DC_DIFF = 1 << 5, /**< print dc diff for each macro block */ - VP8_DEBUG_TXT_RATE_INFO = 1 << 6, /**< print video rate info (encoder only) */ - VP8_MFQE = 1 << 10 -}; - -/*!\brief post process flags - * - * This define a structure that describe the post processing settings. For - * the best objective measure (using the PSNR metric) set post_proc_flag - * to VP8_DEBLOCK and deblocking_level to 1. - */ - -typedef struct vp8_postproc_cfg { - /*!\brief the types of post processing to be done, should be combination of - * "vp8_postproc_level" */ - int post_proc_flag; - int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */ - int noise_level; /**< the strength of additive noise, valid range [0, 16] */ -} vp8_postproc_cfg_t; - -/*!\brief reference frame type - * - * The set of macros define the type of VP8 reference frames - */ -typedef enum vpx_ref_frame_type { - VP8_LAST_FRAME = 1, - VP8_GOLD_FRAME = 2, - VP8_ALTR_FRAME = 4 -} vpx_ref_frame_type_t; - -/*!\brief reference frame data struct - * - * Define the data struct to access vp8 reference frames. - */ -typedef struct vpx_ref_frame { - vpx_ref_frame_type_t frame_type; /**< which reference frame */ - vpx_image_t img; /**< reference frame data in image format */ -} vpx_ref_frame_t; - -/*!\brief VP9 specific reference frame data struct - * - * Define the data struct to access vp9 reference frames. - */ -typedef struct vp9_ref_frame { - int idx; /**< frame index to get (input) */ - vpx_image_t img; /**< img structure to populate (output) */ -} vp9_ref_frame_t; - -/*!\cond */ -/*!\brief vp8 decoder control function parameter type - * - * defines the data type for each of VP8 decoder control function requires - */ -VPX_CTRL_USE_TYPE(VP8_SET_REFERENCE, vpx_ref_frame_t *) -#define VPX_CTRL_VP8_SET_REFERENCE -VPX_CTRL_USE_TYPE(VP8_COPY_REFERENCE, vpx_ref_frame_t *) -#define VPX_CTRL_VP8_COPY_REFERENCE -VPX_CTRL_USE_TYPE(VP8_SET_POSTPROC, vp8_postproc_cfg_t *) -#define VPX_CTRL_VP8_SET_POSTPROC -VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_REF_FRAME, int) -#define VPX_CTRL_VP8_SET_DBG_COLOR_REF_FRAME -VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_MB_MODES, int) -#define VPX_CTRL_VP8_SET_DBG_COLOR_MB_MODES -VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_B_MODES, int) -#define VPX_CTRL_VP8_SET_DBG_COLOR_B_MODES -VPX_CTRL_USE_TYPE(VP8_SET_DBG_DISPLAY_MV, int) -#define VPX_CTRL_VP8_SET_DBG_DISPLAY_MV -VPX_CTRL_USE_TYPE(VP9_GET_REFERENCE, vp9_ref_frame_t *) -#define VPX_CTRL_VP9_GET_REFERENCE -VPX_CTRL_USE_TYPE(VP10_GET_NEW_FRAME_IMAGE, vpx_image_t *) -#define VPX_CTRL_VP10_GET_NEW_FRAME_IMAGE - -/*!\endcond */ -/*! @} - end defgroup vp8 */ - -#ifdef __cplusplus -} // extern "C" -#endif - -#endif // VPX_VP8_H_
diff --git a/aom/vp8dx.h b/aom/vp8dx.h deleted file mode 100644 index 2239b86..0000000 --- a/aom/vp8dx.h +++ /dev/null
@@ -1,176 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -/*!\defgroup vp8_decoder WebM VP8/VP9 Decoder - * \ingroup vp8 - * - * @{ - */ -/*!\file - * \brief Provides definitions for using VP8 or VP9 within the vpx Decoder - * interface. - */ -#ifndef VPX_VP8DX_H_ -#define VPX_VP8DX_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -/* Include controls common to both the encoder and decoder */ -#include "./vp8.h" - -/*!\name Algorithm interface for VP10 - * - * This interface provides the capability to decode VP10 streams. - * @{ - */ -extern vpx_codec_iface_t vpx_codec_vp10_dx_algo; -extern vpx_codec_iface_t *vpx_codec_vp10_dx(void); -/*!@} - end algorithm interface member group*/ - -/*!\enum vp8_dec_control_id - * \brief VP8 decoder control functions - * - * This set of macros define the control functions available for the VP8 - * decoder interface. - * - * \sa #vpx_codec_control - */ -enum vp8_dec_control_id { - /** control function to get info on which reference frames were updated - * by the last decode - */ - VP8D_GET_LAST_REF_UPDATES = VP8_DECODER_CTRL_ID_START, - - /** check if the indicated frame is corrupted */ - VP8D_GET_FRAME_CORRUPTED, - - /** control function to get info on which reference frames were used - * by the last decode - */ - VP8D_GET_LAST_REF_USED, - - /** decryption function to decrypt encoded buffer data immediately - * before decoding. Takes a vpx_decrypt_init, which contains - * a callback function and opaque context pointer. - */ - VPXD_SET_DECRYPTOR, - VP8D_SET_DECRYPTOR = VPXD_SET_DECRYPTOR, - - /** control function to get the dimensions that the current frame is decoded - * at. This may be different to the intended display size for the frame as - * specified in the wrapper or frame header (see VP9D_GET_DISPLAY_SIZE). */ - VP9D_GET_FRAME_SIZE, - - /** control function to get the current frame's intended display dimensions - * (as specified in the wrapper or frame header). This may be different to - * the decoded dimensions of this frame (see VP9D_GET_FRAME_SIZE). */ - VP9D_GET_DISPLAY_SIZE, - - /** control function to get the bit depth of the stream. */ - VP9D_GET_BIT_DEPTH, - - /** control function to set the byte alignment of the planes in the reference - * buffers. Valid values are power of 2, from 32 to 1024. A value of 0 sets - * legacy alignment. I.e. Y plane is aligned to 32 bytes, U plane directly - * follows Y plane, and V plane directly follows U plane. Default value is 0. - */ - VP9_SET_BYTE_ALIGNMENT, - - /** control function to invert the decoding order to from right to left. The - * function is used in a test to confirm the decoding independence of tile - * columns. The function may be used in application where this order - * of decoding is desired. - * - * TODO(yaowu): Rework the unit test that uses this control, and in a future - * release, this test-only control shall be removed. - */ - VP9_INVERT_TILE_DECODE_ORDER, - - /** control function to set the skip loop filter flag. Valid values are - * integers. The decoder will skip the loop filter when its value is set to - * nonzero. If the loop filter is skipped the decoder may accumulate decode - * artifacts. The default value is 0. - */ - VP9_SET_SKIP_LOOP_FILTER, - - VP8_DECODER_CTRL_ID_MAX, - - /** control function to set the range of tile decoding. A value that is - * greater and equal to zero indicates only the specific row/column is - * decoded. A value that is -1 indicates the whole row/column is decoded. - * A special case is both values are -1 that means the whole frame is - * decoded. - */ - VP10_SET_DECODE_TILE_ROW, - VP10_SET_DECODE_TILE_COL -}; - -/** Decrypt n bytes of data from input -> output, using the decrypt_state - * passed in VPXD_SET_DECRYPTOR. - */ -typedef void (*vpx_decrypt_cb)(void *decrypt_state, const unsigned char *input, - unsigned char *output, int count); - -/*!\brief Structure to hold decryption state - * - * Defines a structure to hold the decryption state and access function. - */ -typedef struct vpx_decrypt_init { - /*! Decrypt callback. */ - vpx_decrypt_cb decrypt_cb; - - /*! Decryption state. */ - void *decrypt_state; -} vpx_decrypt_init; - -/*!\brief A deprecated alias for vpx_decrypt_init. - */ -typedef vpx_decrypt_init vp8_decrypt_init; - -/*!\cond */ -/*!\brief VP8 decoder control function parameter type - * - * Defines the data types that VP8D control functions take. Note that - * additional common controls are defined in vp8.h - * - */ - -VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_UPDATES, int *) -#define VPX_CTRL_VP8D_GET_LAST_REF_UPDATES -VPX_CTRL_USE_TYPE(VP8D_GET_FRAME_CORRUPTED, int *) -#define VPX_CTRL_VP8D_GET_FRAME_CORRUPTED -VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_USED, int *) -#define VPX_CTRL_VP8D_GET_LAST_REF_USED -VPX_CTRL_USE_TYPE(VPXD_SET_DECRYPTOR, vpx_decrypt_init *) -#define VPX_CTRL_VPXD_SET_DECRYPTOR -VPX_CTRL_USE_TYPE(VP8D_SET_DECRYPTOR, vpx_decrypt_init *) -#define VPX_CTRL_VP8D_SET_DECRYPTOR -VPX_CTRL_USE_TYPE(VP9D_GET_DISPLAY_SIZE, int *) -#define VPX_CTRL_VP9D_GET_DISPLAY_SIZE -VPX_CTRL_USE_TYPE(VP9D_GET_BIT_DEPTH, unsigned int *) -#define VPX_CTRL_VP9D_GET_BIT_DEPTH -VPX_CTRL_USE_TYPE(VP9D_GET_FRAME_SIZE, int *) -#define VPX_CTRL_VP9D_GET_FRAME_SIZE -VPX_CTRL_USE_TYPE(VP9_INVERT_TILE_DECODE_ORDER, int) -#define VPX_CTRL_VP9_INVERT_TILE_DECODE_ORDER -VPX_CTRL_USE_TYPE(VP10_SET_DECODE_TILE_ROW, int) -#define VPX_CTRL_VP10_SET_DECODE_TILE_ROW -VPX_CTRL_USE_TYPE(VP10_SET_DECODE_TILE_COL, int) -#define VPX_CTRL_VP10_SET_DECODE_TILE_COL -/*!\endcond */ -/*! @} - end defgroup vp8_decoder */ - -#ifdef __cplusplus -} // extern "C" -#endif - -#endif // VPX_VP8DX_H_
diff --git a/aom/vpx_codec.mk b/aom/vpx_codec.mk deleted file mode 100644 index a5ad13e..0000000 --- a/aom/vpx_codec.mk +++ /dev/null
@@ -1,41 +0,0 @@ -## -## Copyright (c) 2010 The WebM project authors. All Rights Reserved. -## -## Use of this source code is governed by a BSD-style license -## that can be found in the LICENSE file in the root of the source -## tree. An additional intellectual property rights grant can be found -## in the file PATENTS. All contributing project authors may -## be found in the AUTHORS file in the root of the source tree. -## - - -API_EXPORTS += exports - -API_SRCS-$(CONFIG_VP10_ENCODER) += vp8.h -API_SRCS-$(CONFIG_VP10_ENCODER) += vp8cx.h -API_DOC_SRCS-$(CONFIG_VP10_ENCODER) += vp8.h -API_DOC_SRCS-$(CONFIG_VP10_ENCODER) += vp8cx.h - -API_SRCS-$(CONFIG_VP10_DECODER) += vp8.h -API_SRCS-$(CONFIG_VP10_DECODER) += vp8dx.h -API_DOC_SRCS-$(CONFIG_VP10_DECODER) += vp8.h -API_DOC_SRCS-$(CONFIG_VP10_DECODER) += vp8dx.h - -API_DOC_SRCS-yes += vpx_codec.h -API_DOC_SRCS-yes += vpx_decoder.h -API_DOC_SRCS-yes += vpx_encoder.h -API_DOC_SRCS-yes += vpx_frame_buffer.h -API_DOC_SRCS-yes += vpx_image.h - -API_SRCS-yes += src/vpx_decoder.c -API_SRCS-yes += vpx_decoder.h -API_SRCS-yes += src/vpx_encoder.c -API_SRCS-yes += vpx_encoder.h -API_SRCS-yes += internal/vpx_codec_internal.h -API_SRCS-yes += src/vpx_codec.c -API_SRCS-yes += src/vpx_image.c -API_SRCS-yes += vpx_codec.h -API_SRCS-yes += vpx_codec.mk -API_SRCS-yes += vpx_frame_buffer.h -API_SRCS-yes += vpx_image.h -API_SRCS-yes += vpx_integer.h