/* * Copyright (c) 2016, Alliance for Open Media. All rights reserved. * * This source code is subject to the terms of the BSD 2 Clause License and * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License * was not distributed with this source code in the LICENSE file, you can * obtain it at www.aomedia.org/license/software. If the Alliance for Open * Media Patent License 1.0 was not distributed with this source code in the * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ #ifndef AOM_AOM_AOM_ENCODER_H_ #define AOM_AOM_AOM_ENCODER_H_ /*!\defgroup encoder Encoder Algorithm Interface * \ingroup codec * This abstraction allows applications using this encoder to easily support * multiple video formats with minimal code duplication. This section describes * the interface common to all encoders. * @{ */ /*!\file * \brief Describes the encoder algorithm interface to applications. * * This file describes the interface between an application and a * video encoder algorithm. * */ #ifdef __cplusplus extern "C" { #endif #include "aom/aom_codec.h" // IWYU pragma: export #include "aom/aom_external_partition.h" /*!\brief Current ABI version number * * \hideinitializer * \internal * If this file is altered in any way that changes the ABI, this value * must be bumped. Examples include, but are not limited to, changing * types, removing or reassigning enums, adding/removing/rearranging * fields to structures * * Note: In the definition of AOM_ENCODER_ABI_VERSION, 3 is the value of * AOM_EXT_PART_ABI_VERSION in libaom v3.2.0. The old value of * AOM_EXT_PART_ABI_VERSION is used so as to not break the ABI version check in * aom_codec_enc_init_ver() when an application compiled against libaom v3.2.0 * passes the old value of AOM_ENCODER_ABI_VERSION to aom_codec_enc_init_ver(). * The external partition API is still experimental. When it is declared stable, * we will replace 3 with AOM_EXT_PART_ABI_VERSION in the definition of * AOM_ENCODER_ABI_VERSION. */ #define AOM_ENCODER_ABI_VERSION … /*! \brief Encoder capabilities bitfield * * Each encoder advertises the capabilities it supports as part of its * ::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 AOM_CODEC_CAP_* defines. */ #define AOM_CODEC_CAP_PSNR … /*! Can support input images at greater than 8 bitdepth. */ #define AOM_CODEC_CAP_HIGHBITDEPTH … /*! \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 AOM_CODEC_USE_* defines. */ #define AOM_CODEC_USE_PSNR … #define AOM_CODEC_USE_HIGHBITDEPTH … /*!\brief Generic fixed size buffer structure * * This structure is able to hold a reference to any fixed size buffer. */ aom_fixed_buf_t; /**< alias for struct aom_fixed_buf */ /*!\brief Error Resilient flags * * These flags define which error resilient features to enable in the * encoder. The flags are specified through the * aom_codec_enc_cfg::g_error_resilient variable. */ aom_codec_er_flags_t; /*!\brief Improve resiliency against losses of whole frames */ #define AOM_ERROR_RESILIENT_DEFAULT … /*!\brief Encoder output packet variants * * This enumeration lists the different kinds of data packets that can be * returned by calls to aom_codec_get_cx_data(). Algorithms \ref MAY * extend this list to provide additional functionality. */ enum aom_codec_cx_pkt_kind { … }; /*!\brief Encoder output packet * * This structure contains the different kinds of output data the encoder * may produce while compressing a frame. */ aom_codec_cx_pkt_t; /**< alias for struct aom_codec_cx_pkt */ /*!\brief Rational Number * * This structure holds a fractional value. */ aom_rational_t; /**< alias for struct aom_rational */ /*!\brief Multi-pass Encoding Pass * * AOM_RC_LAST_PASS is kept for backward compatibility. * If passes is not given and pass==2, the codec will assume passes=2. * For new code, it is recommended to use AOM_RC_SECOND_PASS and set * the "passes" member to 2 via the key & val API for two-pass encoding. */ enum aom_enc_pass { … }; /*!\brief Rate control mode */ enum aom_rc_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 AOM_KF_FIXED meant keyframes were disabled. * This name is confusing for this behavior, so the new symbols to be used * are AOM_KF_AUTO and AOM_KF_DISABLED. */ enum aom_kf_mode { … }; /*!\brief Frame super-resolution mode. */ aom_superres_mode; /*!\brief Encoder Config Options * * This type allows to enumerate and control flags defined for encoder control * via config file at runtime. */ cfg_options_t; /*!\brief Encoded Frame Flags * * 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 AOM_EFLAG_*, and bits specific to an algorithm will be named * /algo/_eflag_*. The lower order 16 bits are reserved for common use. */ aom_enc_frame_flags_t; /*!\brief Force this frame to be a keyframe */ #define AOM_EFLAG_FORCE_KF … /*!\brief Encoder configuration structure * * This structure contains the encoder settings that have common representations * across all codecs. This doesn't imply that all codecs support all features, * however. */ aom_codec_enc_cfg_t; /**< alias for struct aom_codec_enc_cfg */ /*!\brief Initialize an encoder instance * * Initializes an encoder context using the given interface. Applications * 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. * * If the library was configured with -DCONFIG_MULTITHREAD=0, this call * is not thread safe and should be guarded with a lock if being used * in a multithreaded context. * * If aom_codec_enc_init_ver() fails, it is not necessary to call * aom_codec_destroy() on the encoder context. * * \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. * \param[in] flags Bitfield of AOM_CODEC_USE_* flags * \param[in] ver ABI version number. Must be set to * AOM_ENCODER_ABI_VERSION * \retval #AOM_CODEC_OK * The encoder algorithm has been initialized. * \retval #AOM_CODEC_MEM_ERROR * Memory allocation failed. */ 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 aom_codec_enc_init_ver() * * Ensures the ABI version parameter is properly set. */ #define aom_codec_enc_init(ctx, iface, cfg, flags) … /*!\brief Get the default configuration for a usage. * * Initializes an encoder configuration structure with default values. Supports * the notion of "usages" so that an algorithm may offer different default * settings depending on the user's intended goal. This function \ref SHOULD * be called by all applications to initialize the configuration structure * before specializing the configuration with application specific values. * * \param[in] iface Pointer to the algorithm interface to use. * \param[out] cfg Configuration buffer to populate. * \param[in] usage Algorithm specific usage value. For AV1, must be * set to AOM_USAGE_GOOD_QUALITY (0), * AOM_USAGE_REALTIME (1), or AOM_USAGE_ALL_INTRA (2). * * \retval #AOM_CODEC_OK * The configuration was populated. * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, or the usage value was not recognized. */ aom_codec_err_t aom_codec_enc_config_default(aom_codec_iface_t *iface, aom_codec_enc_cfg_t *cfg, unsigned int usage); /*!\brief Set or change configuration * * Reconfigures an encoder instance according to the given configuration. * * \param[in] ctx Pointer to this instance's context * \param[in] cfg Configuration buffer to use * * \retval #AOM_CODEC_OK * The configuration was populated. * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, or the usage value was not recognized. */ 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 * * Retrieves a stream level global header packet, if supported by the codec. * Calls to this function should be deferred until all configuration information * has been passed to libaom. Otherwise the global header data may be * invalidated by additional configuration changes. * * The AV1 implementation of this function returns an OBU. The OBU returned is * in Low Overhead Bitstream Format. Specifically, the obu_has_size_field bit is * set, and the buffer contains the obu_size field for the returned OBU. * * \param[in] ctx Pointer to this instance's context * * \retval NULL * Encoder does not support global header, or an error occurred while * generating the global header. * * \retval Non-NULL * Pointer to buffer containing global header packet. The caller owns the * memory associated with this buffer, and must free the 'buf' member of the * aom_fixed_buf_t as well as the aom_fixed_buf_t pointer. Memory returned * must be freed via call to free(). */ aom_fixed_buf_t *aom_codec_get_global_headers(aom_codec_ctx_t *ctx); /*!\brief usage parameter analogous to AV1 GOOD QUALITY mode. */ #define AOM_USAGE_GOOD_QUALITY … /*!\brief usage parameter analogous to AV1 REALTIME mode. */ #define AOM_USAGE_REALTIME … /*!\brief usage parameter analogous to AV1 all intra mode. */ #define AOM_USAGE_ALL_INTRA … /*!\brief Encode a frame * * Encodes a video frame at the given "presentation time." The presentation * time stamp (PTS) \ref MUST be strictly increasing. * * When the last frame has been passed to the encoder, this function should * continue to be called in a loop, 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 aom_codec_encode() is * called with img set to NULL 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. * Encoding sample values outside the range * [0..(1<<img->bit_depth)-1] is undefined behavior. * Note: Although img is declared as a const pointer, * if AV1E_SET_DENOISE_NOISE_LEVEL is set to a nonzero * value aom_codec_encode() modifies (denoises) the * samples in img->planes[i] . * \param[in] pts Presentation time stamp, in timebase units. If img * is NULL, pts is ignored. * \param[in] duration Duration to show frame, in timebase units. If img * is not NULL, duration must be nonzero. If img is * NULL, duration is ignored. * \param[in] flags Flags to use for encoding this frame. * * \retval #AOM_CODEC_OK * The configuration was populated. * \retval #AOM_CODEC_INCAPABLE * Interface is not an encoder interface. * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, the image format is unsupported, etc. * * \note * `duration` is of the unsigned long type, which can be 32 or 64 bits. * `duration` must be less than or equal to UINT32_MAX so that its range is * independent of the size of unsigned long. */ 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); /*!\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 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 * the pointer to the buffer's head. * * `pad_before` bytes will be skipped before writing the compressed * data, and `pad_after` bytes will be appended to the packet. The size * of the packet will be the sum of the size of the actual compressed * data, pad_before, and pad_after. The padding bytes will be preserved * (not overwritten). * * Note that calling this function does not guarantee that the returned * compressed data will be placed into the specified buffer. In the * event that the encoded data will not fit into the buffer provided, * the returned packet \ref MAY point to an internal buffer, as it would * if this call were never used. In this event, the output packet will * NOT have any padding, and the application must free space and copy it * to the proper place. This is of particular note in configurations * that may output multiple packets for a single encoded frame (e.g., lagged * encoding) or if the application does not reset the buffer periodically. * * Applications may restore the default behavior of the codec providing * the compressed data buffer by calling this function with a NULL * buffer. * * Applications \ref MUSTNOT call this function during iteration of * 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 #AOM_CODEC_OK * The buffer was set successfully. * \retval #AOM_CODEC_INVALID_PARAM * A parameter was NULL, the image format is unsupported, etc. */ 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); /*!\brief Encoded data iterator * * 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 * #aom_codec_cx_pkt_kind. * * #AOM_CODEC_CX_FRAME_PKT packets should be passed to the application's * muxer. Multiple compressed frames may be in the list. * #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 aom_codec_* function. * * \param[in] ctx Pointer to this instance's context * \param[in,out] iter Iterator storage, initialized to NULL * * \return Returns a pointer to an output data packet (compressed frame data, * two-pass statistics, etc.) or NULL to signal end-of-list. * */ 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 * * Returns an image that can be used as a preview. Shows the image as it would * exist at the decompressor. The application \ref MUST NOT write into this * image buffer. * * \param[in] ctx Pointer to this instance's context * * \return Returns a pointer to a preview image, or NULL if no image is * available. * */ const aom_image_t *aom_codec_get_preview_frame(aom_codec_ctx_t *ctx); /*!@} - end defgroup encoder*/ #ifdef __cplusplus } #endif #endif // AOM_AOM_AOM_ENCODER_H_