mirror of
https://github.com/ZDoom/zdoom-macos-deps.git
synced 2024-11-10 14:41:43 +00:00
add vpx 1.8.2
This commit is contained in:
alexey.lysiuk
parent
4350fdbfb6
commit
935e669ce1
10 changed files with 3509 additions and 0 deletions
136
vpx/include/vpx/vp8.h
Normal file
136
vpx/include/vpx/vp8.h
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
/*
|
||||
* 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 a 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_VPX_VP8_H_
|
||||
#define VPX_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 */
|
||||
|
||||
/* 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,
|
||||
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_MFQE = 1 << 3
|
||||
};
|
||||
|
||||
/*!\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(VP9_GET_REFERENCE, vp9_ref_frame_t *)
|
||||
#define VPX_CTRL_VP9_GET_REFERENCE
|
||||
|
||||
/*!\endcond */
|
||||
/*! @} - end defgroup vp8 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif // VPX_VPX_VP8_H_
|
||||
1032
vpx/include/vpx/vp8cx.h
Normal file
1032
vpx/include/vpx/vp8cx.h
Normal file
File diff suppressed because it is too large
Load diff
210
vpx/include/vpx/vp8dx.h
Normal file
210
vpx/include/vpx/vp8dx.h
Normal file
|
|
@ -0,0 +1,210 @@
|
|||
/*
|
||||
* 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_VPX_VP8DX_H_
|
||||
#define VPX_VPX_VP8DX_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Include controls common to both the encoder and decoder */
|
||||
#include "./vp8.h"
|
||||
|
||||
/*!\name Algorithm interface for VP8
|
||||
*
|
||||
* This interface provides the capability to decode VP8 streams.
|
||||
* @{
|
||||
*/
|
||||
extern vpx_codec_iface_t vpx_codec_vp8_dx_algo;
|
||||
extern vpx_codec_iface_t *vpx_codec_vp8_dx(void);
|
||||
/*!@} - end algorithm interface member group*/
|
||||
|
||||
/*!\name Algorithm interface for VP9
|
||||
*
|
||||
* This interface provides the capability to decode VP9 streams.
|
||||
* @{
|
||||
*/
|
||||
extern vpx_codec_iface_t vpx_codec_vp9_dx_algo;
|
||||
extern vpx_codec_iface_t *vpx_codec_vp9_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,
|
||||
|
||||
/** control function to decode SVC stream up to the x spatial layers,
|
||||
* where x is passed in through the control, and is 0 for base layer.
|
||||
*/
|
||||
VP9_DECODE_SVC_SPATIAL_LAYER,
|
||||
|
||||
/*!\brief Codec control function to get last decoded frame quantizer.
|
||||
*
|
||||
* Return value uses internal quantizer scale defined by the codec.
|
||||
*
|
||||
* Supported in codecs: VP8, VP9
|
||||
*/
|
||||
VPXD_GET_LAST_QUANTIZER,
|
||||
|
||||
/*!\brief Codec control function to set row level multi-threading.
|
||||
*
|
||||
* 0 : off, 1 : on
|
||||
*
|
||||
* Supported in codecs: VP9
|
||||
*/
|
||||
VP9D_SET_ROW_MT,
|
||||
|
||||
/*!\brief Codec control function to set loopfilter optimization.
|
||||
*
|
||||
* 0 : off, Loop filter is done after all tiles have been decoded
|
||||
* 1 : on, Loop filter is done immediately after decode without
|
||||
* waiting for all threads to sync.
|
||||
*
|
||||
* Supported in codecs: VP9
|
||||
*/
|
||||
VP9D_SET_LOOP_FILTER_OPT,
|
||||
|
||||
VP8_DECODER_CTRL_ID_MAX
|
||||
};
|
||||
|
||||
/** 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;
|
||||
|
||||
/*!\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_GET_LAST_QUANTIZER, int *)
|
||||
#define VPX_CTRL_VPXD_GET_LAST_QUANTIZER
|
||||
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
|
||||
#define VPX_CTRL_VP9_DECODE_SVC_SPATIAL_LAYER
|
||||
VPX_CTRL_USE_TYPE(VP9_DECODE_SVC_SPATIAL_LAYER, int)
|
||||
#define VPX_CTRL_VP9_SET_SKIP_LOOP_FILTER
|
||||
VPX_CTRL_USE_TYPE(VP9_SET_SKIP_LOOP_FILTER, int)
|
||||
#define VPX_CTRL_VP9_DECODE_SET_ROW_MT
|
||||
VPX_CTRL_USE_TYPE(VP9D_SET_ROW_MT, int)
|
||||
#define VPX_CTRL_VP9_SET_LOOP_FILTER_OPT
|
||||
VPX_CTRL_USE_TYPE(VP9D_SET_LOOP_FILTER_OPT, int)
|
||||
|
||||
/*!\endcond */
|
||||
/*! @} - end defgroup vp8_decoder */
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif // VPX_VPX_VP8DX_H_
|
||||
468
vpx/include/vpx/vpx_codec.h
Normal file
468
vpx/include/vpx/vpx_codec.h
Normal file
|
|
@ -0,0 +1,468 @@
|
|||
/*
|
||||
* 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 codec Common Algorithm Interface
|
||||
* This abstraction allows applications to easily support multiple video
|
||||
* formats with minimal code duplication. This section describes the interface
|
||||
* common to all codecs (both encoders and decoders).
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!\file
|
||||
* \brief Describes the codec algorithm interface to applications.
|
||||
*
|
||||
* This file describes the interface between an application and a
|
||||
* video codec algorithm.
|
||||
*
|
||||
* An application instantiates a specific codec instance by using
|
||||
* vpx_codec_init() and a pointer to the algorithm's interface structure:
|
||||
* <pre>
|
||||
* my_app.c:
|
||||
* extern vpx_codec_iface_t my_codec;
|
||||
* {
|
||||
* vpx_codec_ctx_t algo;
|
||||
* res = vpx_codec_init(&algo, &my_codec);
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* Once initialized, the instance is manged using other functions from
|
||||
* the vpx_codec_* family.
|
||||
*/
|
||||
#ifndef VPX_VPX_VPX_CODEC_H_
|
||||
#define VPX_VPX_VPX_CODEC_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "./vpx_image.h"
|
||||
#include "./vpx_integer.h"
|
||||
|
||||
/*!\brief Decorator indicating a function is deprecated */
|
||||
#ifndef VPX_DEPRECATED
|
||||
#if defined(__GNUC__) && __GNUC__
|
||||
#define VPX_DEPRECATED __attribute__((deprecated))
|
||||
#elif defined(_MSC_VER)
|
||||
#define VPX_DEPRECATED
|
||||
#else
|
||||
#define VPX_DEPRECATED
|
||||
#endif
|
||||
#endif /* VPX_DEPRECATED */
|
||||
|
||||
#ifndef VPX_DECLSPEC_DEPRECATED
|
||||
#if defined(__GNUC__) && __GNUC__
|
||||
#define VPX_DECLSPEC_DEPRECATED /**< \copydoc #VPX_DEPRECATED */
|
||||
#elif defined(_MSC_VER)
|
||||
/*!\brief \copydoc #VPX_DEPRECATED */
|
||||
#define VPX_DECLSPEC_DEPRECATED __declspec(deprecated)
|
||||
#else
|
||||
#define VPX_DECLSPEC_DEPRECATED /**< \copydoc #VPX_DEPRECATED */
|
||||
#endif
|
||||
#endif /* VPX_DECLSPEC_DEPRECATED */
|
||||
|
||||
/*!\brief Decorator indicating a function is potentially unused */
|
||||
#ifndef VPX_UNUSED
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define VPX_UNUSED __attribute__((unused))
|
||||
#else
|
||||
#define VPX_UNUSED
|
||||
#endif
|
||||
#endif /* VPX_UNUSED */
|
||||
|
||||
/*!\brief Current ABI version number
|
||||
*
|
||||
* \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
|
||||
*/
|
||||
#define VPX_CODEC_ABI_VERSION (4 + VPX_IMAGE_ABI_VERSION) /**<\hideinitializer*/
|
||||
|
||||
/*!\brief Algorithm return codes */
|
||||
typedef enum {
|
||||
/*!\brief Operation completed without error */
|
||||
VPX_CODEC_OK,
|
||||
|
||||
/*!\brief Unspecified error */
|
||||
VPX_CODEC_ERROR,
|
||||
|
||||
/*!\brief Memory operation failed */
|
||||
VPX_CODEC_MEM_ERROR,
|
||||
|
||||
/*!\brief ABI version mismatch */
|
||||
VPX_CODEC_ABI_MISMATCH,
|
||||
|
||||
/*!\brief Algorithm does not have required capability */
|
||||
VPX_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,
|
||||
|
||||
/*!\brief Encoded bitstream uses an unsupported feature
|
||||
*
|
||||
* The decoder does not implement a feature required by the encoder. This
|
||||
* return code should only be used for features that prevent future
|
||||
* 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,
|
||||
|
||||
/*!\brief The coded data for this stream is corrupt or incomplete
|
||||
*
|
||||
* There was a problem decoding the current frame. This return code
|
||||
* should only be used for failures that prevent future 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. If decoding
|
||||
* is continued for the current GOP, artifacts may be present.
|
||||
*/
|
||||
VPX_CODEC_CORRUPT_FRAME,
|
||||
|
||||
/*!\brief An application-supplied parameter is not valid.
|
||||
*
|
||||
*/
|
||||
VPX_CODEC_INVALID_PARAM,
|
||||
|
||||
/*!\brief An iterator reached the end of list.
|
||||
*
|
||||
*/
|
||||
VPX_CODEC_LIST_END
|
||||
|
||||
} vpx_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
|
||||
* or functionality, and are not required to be supported.
|
||||
*
|
||||
* The available flags are specified by VPX_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 */
|
||||
|
||||
/*! Can support images at greater than 8 bitdepth.
|
||||
*/
|
||||
#define VPX_CODEC_CAP_HIGHBITDEPTH 0x4
|
||||
|
||||
/*! \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.
|
||||
*/
|
||||
typedef long vpx_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;
|
||||
|
||||
/*!\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;
|
||||
|
||||
/*!\brief Iterator
|
||||
*
|
||||
* Opaque storage used for iterating over lists.
|
||||
*/
|
||||
typedef const void *vpx_codec_iter_t;
|
||||
|
||||
/*!\brief Codec context structure
|
||||
*
|
||||
* All codecs \ref MUST support this context structure fully. In general,
|
||||
* this data should be considered private to the codec algorithm, and
|
||||
* not be manipulated or examined by the calling application. Applications
|
||||
* may reference the 'name' member to get a printable description of the
|
||||
* algorithm.
|
||||
*/
|
||||
typedef struct vpx_codec_ctx {
|
||||
const char *name; /**< Printable interface name */
|
||||
vpx_codec_iface_t *iface; /**< Interface pointers */
|
||||
vpx_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 */
|
||||
union {
|
||||
/**< Decoder Configuration Pointer */
|
||||
const struct vpx_codec_dec_cfg *dec;
|
||||
/**< Encoder Configuration Pointer */
|
||||
const struct vpx_codec_enc_cfg *enc;
|
||||
const void *raw;
|
||||
} config; /**< Configuration pointer aliasing union */
|
||||
vpx_codec_priv_t *priv; /**< Algorithm private storage */
|
||||
} vpx_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;
|
||||
|
||||
/*
|
||||
* 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"
|
||||
*/
|
||||
|
||||
/*!\brief Return the version information (as an integer)
|
||||
*
|
||||
* Returns a packed encoding of the library version number. This will only
|
||||
* include
|
||||
* the major.minor.patch component of the version number. Note that this encoded
|
||||
* value should be accessed through the macros provided, as the encoding may
|
||||
* change
|
||||
* in the future.
|
||||
*
|
||||
*/
|
||||
int vpx_codec_version(void);
|
||||
#define VPX_VERSION_MAJOR(v) \
|
||||
(((v) >> 16) & 0xff) /**< extract major from packed version */
|
||||
#define VPX_VERSION_MINOR(v) \
|
||||
(((v) >> 8) & 0xff) /**< extract minor from packed version */
|
||||
#define VPX_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)
|
||||
|
||||
/*!\brief Return the version minor number */
|
||||
#define vpx_codec_version_minor() ((vpx_codec_version() >> 8) & 0xff)
|
||||
|
||||
/*!\brief Return the version patch number */
|
||||
#define vpx_codec_version_patch() ((vpx_codec_version() >> 0) & 0xff)
|
||||
|
||||
/*!\brief Return the version information (as a string)
|
||||
*
|
||||
* Returns a printable string containing the full library version number. This
|
||||
* may
|
||||
* contain additional text following the three digit version number, as to
|
||||
* indicate
|
||||
* release candidates, prerelease versions, etc.
|
||||
*
|
||||
*/
|
||||
const char *vpx_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.
|
||||
*
|
||||
*/
|
||||
const char *vpx_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.
|
||||
*
|
||||
*/
|
||||
const char *vpx_codec_build_config(void);
|
||||
|
||||
/*!\brief Return the name for a given interface
|
||||
*
|
||||
* Returns a human readable string for name of the given codec interface.
|
||||
*
|
||||
* \param[in] iface Interface pointer
|
||||
*
|
||||
*/
|
||||
const char *vpx_codec_iface_name(vpx_codec_iface_t *iface);
|
||||
|
||||
/*!\brief Convert error number to printable string
|
||||
*
|
||||
* Returns a human readable string for the last error returned by the
|
||||
* algorithm. The returned error will be one line and will not contain
|
||||
* any newline characters.
|
||||
*
|
||||
*
|
||||
* \param[in] err Error number.
|
||||
*
|
||||
*/
|
||||
const char *vpx_codec_err_to_string(vpx_codec_err_t err);
|
||||
|
||||
/*!\brief Retrieve error synopsis for codec context
|
||||
*
|
||||
* Returns a human readable string for the last error returned by the
|
||||
* algorithm. The returned error will be one line and will not contain
|
||||
* any newline characters.
|
||||
*
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context.
|
||||
*
|
||||
*/
|
||||
const char *vpx_codec_error(vpx_codec_ctx_t *ctx);
|
||||
|
||||
/*!\brief Retrieve detailed error information for codec context
|
||||
*
|
||||
* Returns a human readable string providing detailed information about
|
||||
* the last error.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context.
|
||||
*
|
||||
* \retval NULL
|
||||
* No detailed information is available.
|
||||
*/
|
||||
const char *vpx_codec_error_detail(vpx_codec_ctx_t *ctx);
|
||||
|
||||
/* REQUIRED FUNCTIONS
|
||||
*
|
||||
* The following functions are required to be implemented for all codecs.
|
||||
* They represent the base case functionality expected of all codecs.
|
||||
*/
|
||||
|
||||
/*!\brief Destroy a codec instance
|
||||
*
|
||||
* Destroys a codec context, freeing any associated memory buffers.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* The codec algorithm initialized.
|
||||
* \retval #VPX_CODEC_MEM_ERROR
|
||||
* Memory allocation failed.
|
||||
*/
|
||||
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx);
|
||||
|
||||
/*!\brief Get the capabilities of an algorithm.
|
||||
*
|
||||
* Retrieves the capabilities bitfield from the algorithm's interface.
|
||||
*
|
||||
* \param[in] iface Pointer to the algorithm interface
|
||||
*
|
||||
*/
|
||||
vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface);
|
||||
|
||||
/*!\brief Control algorithm
|
||||
*
|
||||
* This function is used to exchange algorithm specific data with the codec
|
||||
* instance. This can be used to implement features specific to a particular
|
||||
* algorithm.
|
||||
*
|
||||
* 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
|
||||
* be dispatched.
|
||||
*
|
||||
* Note that this function should not be used directly. Call the
|
||||
* #vpx_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
|
||||
* The control request was processed.
|
||||
* \retval #VPX_CODEC_ERROR
|
||||
* The control request was not processed.
|
||||
* \retval #VPX_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)
|
||||
|
||||
#else
|
||||
/*!\brief vpx_codec_control wrapper macro
|
||||
*
|
||||
* This macro allows for type safe conversions across the variadic parameter
|
||||
* to vpx_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*/
|
||||
|
||||
/*!\brief vpx_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
|
||||
* control identifier.
|
||||
*
|
||||
* \internal
|
||||
* It defines a static function with
|
||||
* 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) \
|
||||
VPX_UNUSED; \
|
||||
\
|
||||
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); \
|
||||
} /**<\hideinitializer*/
|
||||
|
||||
/*!\brief vpx_codec_control deprecated type definition macro
|
||||
*
|
||||
* Like #VPX_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.
|
||||
*
|
||||
* \internal
|
||||
* 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) \
|
||||
VPX_DECLSPEC_DEPRECATED static vpx_codec_err_t vpx_codec_control_##id( \
|
||||
vpx_codec_ctx_t *, int, typ) VPX_DEPRECATED VPX_UNUSED; \
|
||||
\
|
||||
VPX_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); \
|
||||
} /**<\hideinitializer*/
|
||||
|
||||
/*!\brief vpx_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
|
||||
* 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) \
|
||||
VPX_UNUSED; \
|
||||
\
|
||||
static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *ctx, \
|
||||
int ctrl_id) { \
|
||||
return vpx_codec_control_(ctx, ctrl_id); \
|
||||
} /**<\hideinitializer*/
|
||||
|
||||
#endif
|
||||
|
||||
/*!@} - end defgroup codec*/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif // VPX_VPX_VPX_CODEC_H_
|
||||
365
vpx/include/vpx/vpx_decoder.h
Normal file
365
vpx/include/vpx/vpx_decoder.h
Normal file
|
|
@ -0,0 +1,365 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
#ifndef VPX_VPX_VPX_DECODER_H_
|
||||
#define VPX_VPX_VPX_DECODER_H_
|
||||
|
||||
/*!\defgroup decoder Decoder Algorithm Interface
|
||||
* \ingroup codec
|
||||
* This abstraction allows applications using this decoder to easily support
|
||||
* multiple video formats with minimal code duplication. This section describes
|
||||
* the interface common to all decoders.
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!\file
|
||||
* \brief Describes the decoder algorithm interface to applications.
|
||||
*
|
||||
* This file describes the interface between an application and a
|
||||
* video decoder algorithm.
|
||||
*
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "./vpx_codec.h"
|
||||
#include "./vpx_frame_buffer.h"
|
||||
|
||||
/*!\brief Current ABI version number
|
||||
*
|
||||
* \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
|
||||
*/
|
||||
#define VPX_DECODER_ABI_VERSION \
|
||||
(3 + VPX_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
|
||||
* or functionality, and are not required to be supported by a decoder.
|
||||
*
|
||||
* The available flags are specified by VPX_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 */
|
||||
/*!\brief Can conceal errors due to packet loss */
|
||||
#define VPX_CODEC_CAP_ERROR_CONCEALMENT 0x80000
|
||||
/*!\brief Can receive encoded frames one fragment at a time */
|
||||
#define VPX_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.
|
||||
*/
|
||||
/*!\brief Can support frame-based multi-threading */
|
||||
#define VPX_CODEC_CAP_FRAME_THREADING 0x200000
|
||||
/*!brief Can support external frame buffers */
|
||||
#define VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER 0x400000
|
||||
|
||||
#define VPX_CODEC_USE_POSTPROC 0x10000 /**< Postprocess decoded frame */
|
||||
/*!\brief Conceal errors in decoded frames */
|
||||
#define VPX_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
|
||||
/*!\brief Enable frame-based multi-threading */
|
||||
#define VPX_CODEC_USE_FRAME_THREADING 0x80000
|
||||
|
||||
/*!\brief Stream properties
|
||||
*
|
||||
* This structure is used to query or set properties of the decoded
|
||||
* stream. Algorithms may extend this structure with data specific
|
||||
* to their bitstream by setting the sz member appropriately.
|
||||
*/
|
||||
typedef struct vpx_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;
|
||||
|
||||
/* REQUIRED FUNCTIONS
|
||||
*
|
||||
* The following functions are required to be implemented for all decoders.
|
||||
* They represent the base case functionality expected of all decoders.
|
||||
*/
|
||||
|
||||
/*!\brief Initialization Configurations
|
||||
*
|
||||
* This structure is used to pass init time configuration options to the
|
||||
* decoder.
|
||||
*/
|
||||
typedef struct vpx_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 */
|
||||
|
||||
/*!\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
|
||||
* function directly, to ensure that the ABI version number parameter
|
||||
* is properly initialized.
|
||||
*
|
||||
* If the library was configured with --disable-multithread, this call
|
||||
* is not thread safe and should be guarded with a lock if being used
|
||||
* in a multithreaded 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. May be NULL.
|
||||
* \param[in] flags Bitfield of VPX_CODEC_USE_* flags
|
||||
* \param[in] ver ABI version number. Must be set to
|
||||
* VPX_DECODER_ABI_VERSION
|
||||
* \retval #VPX_CODEC_OK
|
||||
* The decoder algorithm initialized.
|
||||
* \retval #VPX_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);
|
||||
|
||||
/*!\brief Convenience macro for vpx_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)
|
||||
|
||||
/*!\brief Parse stream info from a buffer
|
||||
*
|
||||
* Performs high level parsing of the bitstream. Construction of a decoder
|
||||
* context is not necessary. Can be used to determine if the bitstream is
|
||||
* of the proper format, and to extract information from the stream.
|
||||
*
|
||||
* \param[in] iface Pointer to the algorithm interface
|
||||
* \param[in] data Pointer to a block of data to parse
|
||||
* \param[in] data_sz Size of the data buffer
|
||||
* \param[in,out] si Pointer to stream info to update. The size member
|
||||
* \ref MUST be properly initialized, but \ref MAY be
|
||||
* clobbered by the algorithm. This parameter \ref MAY
|
||||
* be NULL.
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* Bitstream is parsable and stream information updated
|
||||
*/
|
||||
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);
|
||||
|
||||
/*!\brief Return information about the current stream.
|
||||
*
|
||||
* Returns information about the stream that has been parsed during decoding.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in,out] si Pointer to stream info to update. The size member
|
||||
* \ref MUST be properly initialized, but \ref MAY be
|
||||
* clobbered by the algorithm. This parameter \ref MAY
|
||||
* be NULL.
|
||||
*
|
||||
* \retval #VPX_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);
|
||||
|
||||
/*!\brief Decode data
|
||||
*
|
||||
* Processes a buffer of coded data. If the processing results in a new
|
||||
* decoded frame becoming available, PUT_SLICE and PUT_FRAME events may be
|
||||
* 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,
|
||||
* 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
|
||||
* be empty. When no more data is available, this function should be called
|
||||
* with NULL as data and 0 as data_sz. The memory passed to this function
|
||||
* must be available until the frame has been decoded.
|
||||
*
|
||||
* \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
|
||||
* 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
|
||||
* this frame.
|
||||
* \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
|
||||
* and future pictures can be decoded without error. Otherwise,
|
||||
* see the descriptions of the other error codes in ::vpx_codec_err_t
|
||||
* for recoverability capabilities.
|
||||
*/
|
||||
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);
|
||||
|
||||
/*!\brief Decoded frames iterator
|
||||
*
|
||||
* Iterates over a list of the frames available for display. The iterator
|
||||
* storage should be initialized to NULL to start the iteration. Iteration is
|
||||
* 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.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in,out] iter Iterator storage, initialized to NULL
|
||||
*
|
||||
* \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);
|
||||
|
||||
/*!\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
|
||||
* functions
|
||||
* for codecs that don't advertise this capability will result in an error
|
||||
* code being returned, usually VPX_CODEC_ERROR
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!\brief put frame callback prototype
|
||||
*
|
||||
* 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);
|
||||
|
||||
/*!\brief Register for notification of frame completion.
|
||||
*
|
||||
* Registers a given function to be called when a decoded frame is
|
||||
* available.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in] cb Pointer to the callback function
|
||||
* \param[in] user_priv User's private data
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* Callback successfully registered.
|
||||
* \retval #VPX_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,
|
||||
void *user_priv);
|
||||
|
||||
/*!@} - end defgroup cap_put_frame */
|
||||
|
||||
/*!\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
|
||||
* functions
|
||||
* for codecs that don't advertise this capability will result in an error
|
||||
* code being returned, usually VPX_CODEC_ERROR
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!\brief put slice callback prototype
|
||||
*
|
||||
* 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);
|
||||
|
||||
/*!\brief Register for notification of slice completion.
|
||||
*
|
||||
* Registers a given function to be called when a decoded slice is
|
||||
* available.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in] cb Pointer to the callback function
|
||||
* \param[in] user_priv User's private data
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* Callback successfully registered.
|
||||
* \retval #VPX_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,
|
||||
void *user_priv);
|
||||
|
||||
/*!@} - end defgroup cap_put_slice*/
|
||||
|
||||
/*!\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.
|
||||
* Calling this function for codecs that don't advertise this capability
|
||||
* will result in an error code being returned, usually VPX_CODEC_ERROR.
|
||||
*
|
||||
* \note
|
||||
* Currently this only works with VP9.
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!\brief Pass in external frame buffers for the decoder to use.
|
||||
*
|
||||
* Registers functions to be called when libvpx needs a frame buffer
|
||||
* to decode the current frame and a function to be called when libvpx does
|
||||
* not internally reference the frame buffer. This set function must
|
||||
* be called before the first call to decode or libvpx will assume the
|
||||
* default behavior of allocating frame buffers internally.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in] cb_get Pointer to the get callback function
|
||||
* \param[in] cb_release Pointer to the release callback function
|
||||
* \param[in] cb_priv Callback's private data
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* External frame buffers will be used by libvpx.
|
||||
* \retval #VPX_CODEC_INVALID_PARAM
|
||||
* One or more of the callbacks were NULL.
|
||||
* \retval #VPX_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
|
||||
* #VP9_MAXIMUM_REF_BUFFERS + #VPX_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);
|
||||
|
||||
/*!@} - end defgroup cap_external_frame_buffer */
|
||||
|
||||
/*!@} - end defgroup decoder*/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif // VPX_VPX_VPX_DECODER_H_
|
||||
968
vpx/include/vpx/vpx_encoder.h
Normal file
968
vpx/include/vpx/vpx_encoder.h
Normal file
|
|
@ -0,0 +1,968 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
#ifndef VPX_VPX_VPX_ENCODER_H_
|
||||
#define VPX_VPX_VPX_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 "./vpx_codec.h"
|
||||
|
||||
/*! Temporal Scalability: Maximum length of the sequence defining frame
|
||||
* layer membership
|
||||
*/
|
||||
#define VPX_TS_MAX_PERIODICITY 16
|
||||
|
||||
/*! Temporal Scalability: Maximum number of coding layers */
|
||||
#define VPX_TS_MAX_LAYERS 5
|
||||
|
||||
/*! Temporal+Spatial Scalability: Maximum number of coding layers */
|
||||
#define VPX_MAX_LAYERS 12 // 3 temporal + 4 spatial layers are allowed.
|
||||
|
||||
/*! Spatial Scalability: Maximum number of coding layers */
|
||||
#define VPX_SS_MAX_LAYERS 5
|
||||
|
||||
/*! Spatial Scalability: Default number of coding layers */
|
||||
#define VPX_SS_DEFAULT_LAYERS 1
|
||||
|
||||
/*!\brief Current ABI version number
|
||||
*
|
||||
* \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
|
||||
*/
|
||||
#define VPX_ENCODER_ABI_VERSION \
|
||||
(14 + VPX_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
|
||||
* interfaces or functionality, and are not required to be supported
|
||||
* by an encoder.
|
||||
*
|
||||
* The available flags are specified by VPX_CODEC_CAP_* defines.
|
||||
*/
|
||||
#define VPX_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
|
||||
* every partition but the last. In this mode all frames are always
|
||||
* returned partition by partition.
|
||||
*/
|
||||
#define VPX_CODEC_CAP_OUTPUT_PARTITION 0x20000
|
||||
|
||||
/*! \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.
|
||||
*/
|
||||
#define VPX_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 */
|
||||
|
||||
/*!\brief Generic fixed size buffer structure
|
||||
*
|
||||
* This structure is able to hold a reference to any fixed size buffer.
|
||||
*/
|
||||
typedef struct vpx_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 */
|
||||
|
||||
/*!\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;
|
||||
|
||||
/*!\brief Compressed Frame Flags
|
||||
*
|
||||
* This type represents a bitfield containing information about a compressed
|
||||
* frame that may be useful to an application. The most significant 16 bits
|
||||
* 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 */
|
||||
/*!\brief frame can be dropped without affecting the stream (no future frame
|
||||
* depends on this one) */
|
||||
#define VPX_FRAME_IS_DROPPABLE 0x2
|
||||
/*!\brief frame should be decoded but will not be shown */
|
||||
#define VPX_FRAME_IS_INVISIBLE 0x4
|
||||
/*!\brief this is a fragment of the encoded frame */
|
||||
#define VPX_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.
|
||||
*/
|
||||
typedef uint32_t vpx_codec_er_flags_t;
|
||||
/*!\brief Improve resiliency against losses of whole frames */
|
||||
#define VPX_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
|
||||
|
||||
/*!\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
|
||||
* 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 */
|
||||
};
|
||||
|
||||
/*!\brief Encoder output packet
|
||||
*
|
||||
* 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 */
|
||||
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;
|
||||
/*!\brief duration to show frame (in timebase units) */
|
||||
unsigned long duration;
|
||||
vpx_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;
|
||||
/*!\brief Width and height of frames in this packet. VP8 will only use the
|
||||
* first one.*/
|
||||
unsigned int width[VPX_SS_MAX_LAYERS]; /**< frame width */
|
||||
unsigned int height[VPX_SS_MAX_LAYERS]; /**< frame height */
|
||||
/*!\brief Flag to indicate if spatial layer frame in this packet is
|
||||
* encoded or dropped. VP8 will always be set to 1.*/
|
||||
uint8_t spatial_layer_encoded[VPX_SS_MAX_LAYERS];
|
||||
} 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 {
|
||||
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 */
|
||||
|
||||
/* 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 */
|
||||
} data; /**< packet data */
|
||||
} vpx_codec_cx_pkt_t; /**< alias for struct vpx_codec_cx_pkt */
|
||||
|
||||
/*!\brief Encoder return output buffer callback
|
||||
*
|
||||
* This callback function, when registered, returns with packets when each
|
||||
* spatial layer is encoded.
|
||||
*/
|
||||
typedef void (*vpx_codec_enc_output_cx_pkt_cb_fn_t)(vpx_codec_cx_pkt_t *pkt,
|
||||
void *user_data);
|
||||
|
||||
/*!\brief Callback function pointer / user data pair storage */
|
||||
typedef struct vpx_codec_enc_output_cx_cb_pair {
|
||||
vpx_codec_enc_output_cx_pkt_cb_fn_t output_cx_pkt; /**< Callback function */
|
||||
void *user_priv; /**< Pointer to private data */
|
||||
} vpx_codec_priv_output_cx_pkt_cb_pair_t;
|
||||
|
||||
/*!\brief Rational Number
|
||||
*
|
||||
* This structure holds a fractional value.
|
||||
*/
|
||||
typedef struct vpx_rational {
|
||||
int num; /**< fraction numerator */
|
||||
int den; /**< fraction denominator */
|
||||
} vpx_rational_t; /**< alias for struct vpx_rational */
|
||||
|
||||
/*!\brief Multi-pass Encoding Pass */
|
||||
typedef 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 */
|
||||
} vpx_enc_pass;
|
||||
|
||||
/*!\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 */
|
||||
};
|
||||
|
||||
/*!\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.
|
||||
* This name is confusing for this behavior, so the new symbols to be used
|
||||
* are VPX_KF_AUTO and VPX_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. */
|
||||
};
|
||||
|
||||
/*!\brief Encoded Frame Flags
|
||||
*
|
||||
* This type indicates a bitfield to be passed to vpx_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
|
||||
* /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 */
|
||||
|
||||
/*!\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.
|
||||
*/
|
||||
typedef struct vpx_codec_enc_cfg {
|
||||
/*
|
||||
* generic settings (g)
|
||||
*/
|
||||
|
||||
/*!\brief Deprecated: Algorithm specific "usage" value
|
||||
*
|
||||
* This value must be zero.
|
||||
*/
|
||||
unsigned int g_usage;
|
||||
|
||||
/*!\brief Maximum number of threads to use
|
||||
*
|
||||
* For multi-threaded implementations, use no more than this number of
|
||||
* threads. The codec may use fewer threads than allowed. The value
|
||||
* 0 is equivalent to the value 1.
|
||||
*/
|
||||
unsigned int g_threads;
|
||||
|
||||
/*!\brief Bitstream profile to use
|
||||
*
|
||||
* Some codecs support a notion of multiple bitstream profiles. Typically
|
||||
* this maps to a set of features that are turned on or off. Often the
|
||||
* profile to use is determined by the features of the intended decoder.
|
||||
* Consult the documentation for the codec to determine the valid values
|
||||
* for this parameter, or set to zero for a sane default.
|
||||
*/
|
||||
unsigned int g_profile; /**< profile of bitstream to use */
|
||||
|
||||
/*!\brief Width of the frame
|
||||
*
|
||||
* This value identifies the presentation resolution of the frame,
|
||||
* in pixels. Note that the frames passed as input to the encoder must
|
||||
* have this resolution. Frames will be presented by the decoder in this
|
||||
* resolution, independent of any spatial resampling the encoder may do.
|
||||
*/
|
||||
unsigned int g_w;
|
||||
|
||||
/*!\brief Height of the frame
|
||||
*
|
||||
* This value identifies the presentation resolution of the frame,
|
||||
* in pixels. Note that the frames passed as input to the encoder must
|
||||
* have this resolution. Frames will be presented by the decoder in this
|
||||
* resolution, independent of any spatial resampling the encoder may do.
|
||||
*/
|
||||
unsigned int g_h;
|
||||
|
||||
/*!\brief Bit-depth of the codec
|
||||
*
|
||||
* This value identifies the bit_depth of the codec,
|
||||
* Only certain bit-depths are supported as identified in the
|
||||
* vpx_bit_depth_t enum.
|
||||
*/
|
||||
vpx_bit_depth_t g_bit_depth;
|
||||
|
||||
/*!\brief Bit-depth of the input frames
|
||||
*
|
||||
* This value identifies the bit_depth of the input frames in bits.
|
||||
* Note that the frames passed as input to the encoder must have
|
||||
* this bit-depth.
|
||||
*/
|
||||
unsigned int g_input_bit_depth;
|
||||
|
||||
/*!\brief Stream timebase units
|
||||
*
|
||||
* Indicates the smallest interval of time, in seconds, used by the stream.
|
||||
* For fixed frame rate material, or variable frame rate material where
|
||||
* frames are timed at a multiple of a given clock (ex: video capture),
|
||||
* the \ref RECOMMENDED method is to set the timebase to the reciprocal
|
||||
* of the frame rate (ex: 1001/30000 for 29.970 Hz NTSC). This allows the
|
||||
* pts to correspond to the frame number, which can be handy. For
|
||||
* re-encoding video from containers with absolute time timestamps, the
|
||||
* \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;
|
||||
|
||||
/*!\brief Enable error resilient modes.
|
||||
*
|
||||
* The error resilient bitfield indicates to the encoder which features
|
||||
* it should enable to take measures for streaming over lossy or noisy
|
||||
* links.
|
||||
*/
|
||||
vpx_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.
|
||||
*/
|
||||
enum vpx_enc_pass g_pass;
|
||||
|
||||
/*!\brief Allow lagged encoding
|
||||
*
|
||||
* If set, this value allows the encoder to consume a number of input
|
||||
* frames before producing output frames. This allows the encoder to
|
||||
* base decisions for the current frame on future frames. This does
|
||||
* increase the latency of the encoding pipeline, so it is not appropriate
|
||||
* in all situations (ex: realtime encoding).
|
||||
*
|
||||
* Note that this is a maximum value -- the encoder may produce frames
|
||||
* sooner than the given limit. Set this value to 0 to disable this
|
||||
* feature.
|
||||
*/
|
||||
unsigned int g_lag_in_frames;
|
||||
|
||||
/*
|
||||
* rate control settings (rc)
|
||||
*/
|
||||
|
||||
/*!\brief Temporal resampling configuration, if supported by the codec.
|
||||
*
|
||||
* Temporal resampling allows the codec to "drop" frames as a strategy to
|
||||
* meet its target data rate. This can cause temporal discontinuities in
|
||||
* the encoded video, which may appear as stuttering during playback. This
|
||||
* trade-off is often acceptable, but for many applications is not. It can
|
||||
* be disabled in these cases.
|
||||
*
|
||||
* This threshold is described as a percentage of the target data buffer.
|
||||
* When the data buffer falls below this percentage of fullness, a
|
||||
* dropped frame is indicated. Set the threshold to zero (0) to disable
|
||||
* this feature.
|
||||
*/
|
||||
unsigned int rc_dropframe_thresh;
|
||||
|
||||
/*!\brief Enable/disable spatial resampling, if supported by the codec.
|
||||
*
|
||||
* Spatial resampling allows the codec to compress a lower resolution
|
||||
* version of the frame, which is then upscaled by the encoder to the
|
||||
* correct presentation resolution. This increases visual quality at
|
||||
* low data rates, at the expense of CPU time on the encoder/decoder.
|
||||
*/
|
||||
unsigned int rc_resize_allowed;
|
||||
|
||||
/*!\brief Internal coded frame width.
|
||||
*
|
||||
* If spatial resampling is enabled this specifies the width of the
|
||||
* encoded frame.
|
||||
*/
|
||||
unsigned int rc_scaled_width;
|
||||
|
||||
/*!\brief Internal coded frame height.
|
||||
*
|
||||
* If spatial resampling is enabled this specifies the height of the
|
||||
* encoded frame.
|
||||
*/
|
||||
unsigned int rc_scaled_height;
|
||||
|
||||
/*!\brief Spatial resampling up watermark.
|
||||
*
|
||||
* This threshold is described as a percentage of the target data buffer.
|
||||
* When the data buffer rises above this percentage of fullness, the
|
||||
* encoder will step up to a higher resolution version of the frame.
|
||||
*/
|
||||
unsigned int rc_resize_up_thresh;
|
||||
|
||||
/*!\brief Spatial resampling down watermark.
|
||||
*
|
||||
* This threshold is described as a percentage of the target data buffer.
|
||||
* When the data buffer falls below this percentage of fullness, the
|
||||
* encoder will step down to a lower resolution version of the frame.
|
||||
*/
|
||||
unsigned int rc_resize_down_thresh;
|
||||
|
||||
/*!\brief Rate control algorithm to use.
|
||||
*
|
||||
* Indicates whether the end usage of this stream is to be streamed over
|
||||
* a bandwidth constrained link, indicating that Constant Bit Rate (CBR)
|
||||
* mode should be used, or whether it will be played back on a high
|
||||
* bandwidth link, as from a local disk, where higher variations in
|
||||
* bitrate are acceptable.
|
||||
*/
|
||||
enum vpx_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;
|
||||
|
||||
/*!\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;
|
||||
|
||||
/*!\brief Target data rate
|
||||
*
|
||||
* Target bandwidth to use for this stream, in kilobits per second.
|
||||
*/
|
||||
unsigned int rc_target_bitrate;
|
||||
|
||||
/*
|
||||
* quantizer settings
|
||||
*/
|
||||
|
||||
/*!\brief Minimum (Best Quality) Quantizer
|
||||
*
|
||||
* The quantizer is the most direct control over the quality of the
|
||||
* 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.
|
||||
*/
|
||||
unsigned int rc_min_quantizer;
|
||||
|
||||
/*!\brief Maximum (Worst Quality) Quantizer
|
||||
*
|
||||
* The quantizer is the most direct control over the quality of the
|
||||
* 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.
|
||||
*/
|
||||
unsigned int rc_max_quantizer;
|
||||
|
||||
/*
|
||||
* bitrate tolerance
|
||||
*/
|
||||
|
||||
/*!\brief Rate control adaptation undershoot control
|
||||
*
|
||||
* VP8: Expressed as a percentage of the target bitrate,
|
||||
* controls the maximum allowed adaptation speed of the codec.
|
||||
* This factor controls the maximum amount of bits that can
|
||||
* be subtracted from the target bitrate in order to compensate
|
||||
* for prior overshoot.
|
||||
* VP9: Expressed as a percentage of the target bitrate, a threshold
|
||||
* undershoot level (current rate vs target) beyond which more aggressive
|
||||
* corrective measures are taken.
|
||||
* *
|
||||
* Valid values in the range VP8:0-1000 VP9: 0-100.
|
||||
*/
|
||||
unsigned int rc_undershoot_pct;
|
||||
|
||||
/*!\brief Rate control adaptation overshoot control
|
||||
*
|
||||
* VP8: Expressed as a percentage of the target bitrate,
|
||||
* controls the maximum allowed adaptation speed of the codec.
|
||||
* This factor controls the maximum amount of bits that can
|
||||
* be added to the target bitrate in order to compensate for
|
||||
* prior undershoot.
|
||||
* VP9: Expressed as a percentage of the target bitrate, a threshold
|
||||
* overshoot level (current rate vs target) beyond which more aggressive
|
||||
* corrective measures are taken.
|
||||
*
|
||||
* Valid values in the range VP8:0-1000 VP9: 0-100.
|
||||
*/
|
||||
unsigned int rc_overshoot_pct;
|
||||
|
||||
/*
|
||||
* decoder buffer model parameters
|
||||
*/
|
||||
|
||||
/*!\brief Decoder Buffer Size
|
||||
*
|
||||
* This value indicates the amount of data that may be buffered by the
|
||||
* decoding application. Note that this value is expressed in units of
|
||||
* time (milliseconds). For example, a value of 5000 indicates that the
|
||||
* client will buffer (at least) 5000ms worth of encoded data. Use the
|
||||
* target bitrate (#rc_target_bitrate) to convert to bits/bytes, if
|
||||
* necessary.
|
||||
*/
|
||||
unsigned int rc_buf_sz;
|
||||
|
||||
/*!\brief Decoder Buffer Initial Size
|
||||
*
|
||||
* This value indicates the amount of data that will be buffered by the
|
||||
* decoding application prior to beginning playback. This value is
|
||||
* expressed in units of time (milliseconds). Use the target bitrate
|
||||
* (#rc_target_bitrate) to convert to bits/bytes, if necessary.
|
||||
*/
|
||||
unsigned int rc_buf_initial_sz;
|
||||
|
||||
/*!\brief Decoder Buffer Optimal Size
|
||||
*
|
||||
* This value indicates the amount of data that the encoder should try
|
||||
* to maintain in the decoder's buffer. This value is expressed in units
|
||||
* of time (milliseconds). Use the target bitrate (#rc_target_bitrate)
|
||||
* to convert to bits/bytes, if necessary.
|
||||
*/
|
||||
unsigned int rc_buf_optimal_sz;
|
||||
|
||||
/*
|
||||
* 2 pass rate control parameters
|
||||
*/
|
||||
|
||||
/*!\brief Two-pass mode CBR/VBR bias
|
||||
*
|
||||
* Bias, expressed on a scale of 0 to 100, for determining target size
|
||||
* for the current frame. The value 0 indicates the optimal CBR mode
|
||||
* value should be used. The value 100 indicates the optimal VBR mode
|
||||
* value should be used. Values in between indicate which way the
|
||||
* encoder should "lean."
|
||||
*/
|
||||
unsigned int rc_2pass_vbr_bias_pct;
|
||||
|
||||
/*!\brief Two-pass mode per-GOP minimum bitrate
|
||||
*
|
||||
* This value, expressed as a percentage of the target bitrate, indicates
|
||||
* the minimum bitrate to be used for a single GOP (aka "section")
|
||||
*/
|
||||
unsigned int rc_2pass_vbr_minsection_pct;
|
||||
|
||||
/*!\brief Two-pass mode per-GOP maximum bitrate
|
||||
*
|
||||
* This value, expressed as a percentage of the target bitrate, indicates
|
||||
* the maximum bitrate to be used for a single GOP (aka "section")
|
||||
*/
|
||||
unsigned int rc_2pass_vbr_maxsection_pct;
|
||||
|
||||
/*!\brief Two-pass corpus vbr mode complexity control
|
||||
* Used only in VP9: A value representing the corpus midpoint complexity
|
||||
* for corpus vbr mode. This value defaults to 0 which disables corpus vbr
|
||||
* mode in favour of normal vbr mode.
|
||||
*/
|
||||
unsigned int rc_2pass_vbr_corpus_complexity;
|
||||
|
||||
/*
|
||||
* keyframing settings (kf)
|
||||
*/
|
||||
|
||||
/*!\brief Keyframe placement mode
|
||||
*
|
||||
* This value indicates whether the encoder should place keyframes at a
|
||||
* 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;
|
||||
|
||||
/*!\brief Keyframe minimum interval
|
||||
*
|
||||
* This value, expressed as a number of frames, prevents the encoder from
|
||||
* placing a keyframe nearer than kf_min_dist to the previous keyframe. At
|
||||
* least kf_min_dist frames non-keyframes will be coded before the next
|
||||
* keyframe. Set kf_min_dist equal to kf_max_dist for a fixed interval.
|
||||
*/
|
||||
unsigned int kf_min_dist;
|
||||
|
||||
/*!\brief Keyframe maximum interval
|
||||
*
|
||||
* This value, expressed as a number of frames, forces the encoder to code
|
||||
* a keyframe if one has not been coded in the last kf_max_dist frames.
|
||||
* A value of 0 implies all frames will be keyframes. Set kf_min_dist
|
||||
* equal to kf_max_dist for a fixed interval.
|
||||
*/
|
||||
unsigned int kf_max_dist;
|
||||
|
||||
/*
|
||||
* Spatial scalability settings (ss)
|
||||
*/
|
||||
|
||||
/*!\brief Number of spatial coding layers.
|
||||
*
|
||||
* This value specifies the number of spatial coding layers to be used.
|
||||
*/
|
||||
unsigned int ss_number_layers;
|
||||
|
||||
/*!\brief Enable auto alt reference flags for each spatial layer.
|
||||
*
|
||||
* These values specify if auto alt reference frame is enabled for each
|
||||
* spatial layer.
|
||||
*/
|
||||
int ss_enable_auto_alt_ref[VPX_SS_MAX_LAYERS];
|
||||
|
||||
/*!\brief Target bitrate for each spatial layer.
|
||||
*
|
||||
* These values specify the target coding bitrate to be used for each
|
||||
* spatial layer.
|
||||
*/
|
||||
unsigned int ss_target_bitrate[VPX_SS_MAX_LAYERS];
|
||||
|
||||
/*!\brief Number of temporal coding layers.
|
||||
*
|
||||
* This value specifies the number of temporal layers to be used.
|
||||
*/
|
||||
unsigned int ts_number_layers;
|
||||
|
||||
/*!\brief Target bitrate for each temporal layer.
|
||||
*
|
||||
* These values specify the target coding bitrate to be used for each
|
||||
* temporal layer.
|
||||
*/
|
||||
unsigned int ts_target_bitrate[VPX_TS_MAX_LAYERS];
|
||||
|
||||
/*!\brief Frame rate decimation factor for each temporal layer.
|
||||
*
|
||||
* These values specify the frame rate decimation factors to apply
|
||||
* to each temporal layer.
|
||||
*/
|
||||
unsigned int ts_rate_decimator[VPX_TS_MAX_LAYERS];
|
||||
|
||||
/*!\brief Length of the sequence defining frame temporal layer membership.
|
||||
*
|
||||
* This value specifies the length of the sequence that defines the
|
||||
* membership of frames to temporal layers. For example, if the
|
||||
* ts_periodicity = 8, then the frames are assigned to coding layers with a
|
||||
* repeated sequence of length 8.
|
||||
*/
|
||||
unsigned int ts_periodicity;
|
||||
|
||||
/*!\brief Template defining the membership of frames to temporal layers.
|
||||
*
|
||||
* This array defines the membership of frames to temporal coding layers.
|
||||
* For a 2-layer encoding that assigns even numbered frames to one temporal
|
||||
* layer (0) and odd numbered frames to a second temporal layer (1) with
|
||||
* ts_periodicity=8, then ts_layer_id = (0,1,0,1,0,1,0,1).
|
||||
*/
|
||||
unsigned int ts_layer_id[VPX_TS_MAX_PERIODICITY];
|
||||
|
||||
/*!\brief Target bitrate for each spatial/temporal layer.
|
||||
*
|
||||
* These values specify the target coding bitrate to be used for each
|
||||
* spatial/temporal layer.
|
||||
*
|
||||
*/
|
||||
unsigned int layer_target_bitrate[VPX_MAX_LAYERS];
|
||||
|
||||
/*!\brief Temporal layering mode indicating which temporal layering scheme to
|
||||
* use.
|
||||
*
|
||||
* The value (refer to VP9E_TEMPORAL_LAYERING_MODE) specifies the
|
||||
* temporal layering mode to use.
|
||||
*
|
||||
*/
|
||||
int temporal_layering_mode;
|
||||
} vpx_codec_enc_cfg_t; /**< alias for struct vpx_codec_enc_cfg */
|
||||
|
||||
/*!\brief vp9 svc extra configure parameters
|
||||
*
|
||||
* This defines max/min quantizers and scale factors for each layer
|
||||
*
|
||||
*/
|
||||
typedef struct vpx_svc_parameters {
|
||||
int max_quantizers[VPX_MAX_LAYERS]; /**< Max Q for each layer */
|
||||
int min_quantizers[VPX_MAX_LAYERS]; /**< Min Q for each layer */
|
||||
int scaling_factor_num[VPX_MAX_LAYERS]; /**< Scaling factor-numerator */
|
||||
int scaling_factor_den[VPX_MAX_LAYERS]; /**< Scaling factor-denominator */
|
||||
int speed_per_layer[VPX_MAX_LAYERS]; /**< Speed setting for each sl */
|
||||
int temporal_layering_mode; /**< Temporal layering mode */
|
||||
} vpx_svc_extra_cfg_t;
|
||||
|
||||
/*!\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
|
||||
* function directly, to ensure that the ABI version number parameter
|
||||
* is properly initialized.
|
||||
*
|
||||
* If the library was configured with --disable-multithread, this call
|
||||
* is not thread safe and should be guarded with a lock if being used
|
||||
* in a multithreaded 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. May be NULL.
|
||||
* \param[in] flags Bitfield of VPX_CODEC_USE_* flags
|
||||
* \param[in] ver ABI version number. Must be set to
|
||||
* VPX_ENCODER_ABI_VERSION
|
||||
* \retval #VPX_CODEC_OK
|
||||
* The decoder algorithm initialized.
|
||||
* \retval #VPX_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);
|
||||
|
||||
/*!\brief Convenience macro for vpx_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)
|
||||
|
||||
/*!\brief Initialize multi-encoder instance
|
||||
*
|
||||
* Initializes multi-encoder context using the given interface.
|
||||
* Applications should call the vpx_codec_enc_init_multi convenience macro
|
||||
* instead of this function directly, to ensure that the ABI version number
|
||||
* parameter is properly initialized.
|
||||
*
|
||||
* \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] num_enc Total number of encoders.
|
||||
* \param[in] flags Bitfield of VPX_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
|
||||
* The decoder algorithm initialized.
|
||||
* \retval #VPX_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);
|
||||
|
||||
/*!\brief Convenience macro for vpx_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)
|
||||
|
||||
/*!\brief Get a default configuration
|
||||
*
|
||||
* Initializes a 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 Must be set to 0.
|
||||
*
|
||||
* \retval #VPX_CODEC_OK
|
||||
* The configuration was populated.
|
||||
* \retval #VPX_CODEC_INCAPABLE
|
||||
* Interface is not an encoder interface.
|
||||
* \retval #VPX_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,
|
||||
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 #VPX_CODEC_OK
|
||||
* The configuration was populated.
|
||||
* \retval #VPX_CODEC_INCAPABLE
|
||||
* Interface is not an encoder interface.
|
||||
* \retval #VPX_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);
|
||||
|
||||
/*!\brief Get global stream headers
|
||||
*
|
||||
* Retrieves a stream level global header packet, if supported by the codec.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
*
|
||||
* \retval NULL
|
||||
* Encoder does not support global header
|
||||
* \retval Non-NULL
|
||||
* Pointer to buffer containing global header packet
|
||||
*/
|
||||
vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_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 Encode a frame
|
||||
*
|
||||
* Encodes a video frame at the given "presentation time." The presentation
|
||||
* time stamp (PTS) \ref MUST be strictly increasing.
|
||||
*
|
||||
* The encoder supports the notion of a soft real-time deadline. Given a
|
||||
* non-zero value to the deadline parameter, the encoder will make a "best
|
||||
* effort" guarantee to return before the given time slice expires. It is
|
||||
* 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
|
||||
* supersedes the VPx 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.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* \param[in] ctx Pointer to this instance's context
|
||||
* \param[in] img Image data to encode, NULL to flush.
|
||||
* \param[in] pts Presentation time stamp, in timebase units.
|
||||
* \param[in] duration Duration to show frame, in timebase units.
|
||||
* \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
|
||||
* The configuration was populated.
|
||||
* \retval #VPX_CODEC_INCAPABLE
|
||||
* Interface is not an encoder interface.
|
||||
* \retval #VPX_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,
|
||||
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
|
||||
* 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
|
||||
* vpx_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
|
||||
* The buffer was set successfully.
|
||||
* \retval #VPX_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,
|
||||
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
|
||||
* #vpx_codec_cx_pkt_kind.
|
||||
*
|
||||
* #VPX_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.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* \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 vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
|
||||
vpx_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 vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t *ctx);
|
||||
|
||||
/*!@} - end defgroup encoder*/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif // VPX_VPX_VPX_ENCODER_H_
|
||||
83
vpx/include/vpx/vpx_frame_buffer.h
Normal file
83
vpx/include/vpx/vpx_frame_buffer.h
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
/*
|
||||
* Copyright (c) 2014 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.
|
||||
*/
|
||||
|
||||
#ifndef VPX_VPX_VPX_FRAME_BUFFER_H_
|
||||
#define VPX_VPX_VPX_FRAME_BUFFER_H_
|
||||
|
||||
/*!\file
|
||||
* \brief Describes the decoder external frame buffer interface.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "./vpx_integer.h"
|
||||
|
||||
/*!\brief The maximum number of work buffers used by libvpx.
|
||||
* 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
|
||||
|
||||
/*!\brief The maximum number of reference buffers that a VP9 encoder may use.
|
||||
*/
|
||||
#define VP9_MAXIMUM_REF_BUFFERS 8
|
||||
|
||||
/*!\brief External frame buffer
|
||||
*
|
||||
* This structure holds allocated frame buffers used by the decoder.
|
||||
*/
|
||||
typedef struct vpx_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;
|
||||
|
||||
/*!\brief get frame buffer callback prototype
|
||||
*
|
||||
* This callback is invoked by the decoder to retrieve data for the frame
|
||||
* buffer in order for the decode call to complete. The callback must
|
||||
* allocate at least min_size in bytes and assign it to fb->data. The callback
|
||||
* must zero out all the data allocated. Then the callback must set fb->size
|
||||
* 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
|
||||
* some data which will be passed back in the vpx_image_t 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] min_size Size in bytes needed by the buffer
|
||||
* \param[in,out] fb Pointer to vpx_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);
|
||||
|
||||
/*!\brief release frame buffer callback prototype
|
||||
*
|
||||
* This callback is invoked by the decoder when the frame buffer is not
|
||||
* referenced by any other buffers. |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] fb Pointer to vpx_codec_frame_buffer_t
|
||||
*/
|
||||
typedef int (*vpx_release_frame_buffer_cb_fn_t)(void *priv,
|
||||
vpx_codec_frame_buffer_t *fb);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif // VPX_VPX_VPX_FRAME_BUFFER_H_
|
||||
207
vpx/include/vpx/vpx_image.h
Normal file
207
vpx/include/vpx/vpx_image.h
Normal file
|
|
@ -0,0 +1,207 @@
|
|||
/*
|
||||
* 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 Describes the vpx image descriptor and associated operations
|
||||
*
|
||||
*/
|
||||
#ifndef VPX_VPX_VPX_IMAGE_H_
|
||||
#define VPX_VPX_VPX_IMAGE_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*!\brief Current ABI version number
|
||||
*
|
||||
* \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
|
||||
*/
|
||||
#define VPX_IMAGE_ABI_VERSION (5) /**<\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. */
|
||||
|
||||
/*!\brief List of supported image formats */
|
||||
typedef enum vpx_img_fmt {
|
||||
VPX_IMG_FMT_NONE,
|
||||
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_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_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 */
|
||||
|
||||
/*!\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 */
|
||||
|
||||
/*!\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 */
|
||||
|
||||
/**\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 */
|
||||
|
||||
/* Image storage dimensions */
|
||||
unsigned int w; /**< Stored image width */
|
||||
unsigned int h; /**< Stored image height */
|
||||
unsigned int bit_depth; /**< Stored image bit-depth */
|
||||
|
||||
/* Image display dimensions */
|
||||
unsigned int d_w; /**< Displayed image width */
|
||||
unsigned int d_h; /**< Displayed image height */
|
||||
|
||||
/* Image intended rendering dimensions */
|
||||
unsigned int r_w; /**< Intended rendering image width */
|
||||
unsigned int r_h; /**< Intended rendering image height */
|
||||
|
||||
/* Chroma subsampling info */
|
||||
unsigned int x_chroma_shift; /**< subsampling order, X */
|
||||
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 */
|
||||
unsigned char *planes[4]; /**< pointer to the top left pixel for each plane */
|
||||
int stride[4]; /**< stride between rows for each plane */
|
||||
|
||||
int bps; /**< bits per sample (for packed formats) */
|
||||
|
||||
/*!\brief The following member may be set by the application to associate
|
||||
* data with this image.
|
||||
*/
|
||||
void *user_priv;
|
||||
|
||||
/* The following members should be treated as private. */
|
||||
unsigned char *img_data; /**< private */
|
||||
int img_data_owner; /**< private */
|
||||
int self_allocd; /**< private */
|
||||
|
||||
void *fb_priv; /**< Frame buffer data associated with the image. */
|
||||
} vpx_image_t; /**< alias for struct vpx_image */
|
||||
|
||||
/**\brief Representation of a rectangle on a surface */
|
||||
typedef struct vpx_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 */
|
||||
|
||||
/*!\brief Open a descriptor, allocating storage for the underlying image
|
||||
*
|
||||
* Returns a descriptor for storing an image of the given format. The
|
||||
* storage for the descriptor is allocated on the heap.
|
||||
*
|
||||
* \param[in] img Pointer to storage for descriptor. If this parameter
|
||||
* is NULL, the storage for the descriptor will be
|
||||
* allocated on the heap.
|
||||
* \param[in] fmt Format for the image
|
||||
* \param[in] d_w Width of the image
|
||||
* \param[in] d_h Height of the image
|
||||
* \param[in] align Alignment, in bytes, of the image buffer and
|
||||
* each row in the image(stride).
|
||||
*
|
||||
* \return Returns a pointer to the initialized image descriptor. If the img
|
||||
* 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,
|
||||
unsigned int d_w, unsigned int d_h,
|
||||
unsigned int align);
|
||||
|
||||
/*!\brief Open a descriptor, using existing storage for the underlying image
|
||||
*
|
||||
* Returns a descriptor for storing an image of the given format. The
|
||||
* storage for descriptor has been allocated elsewhere, and a descriptor is
|
||||
* desired to "wrap" that storage.
|
||||
*
|
||||
* \param[in] img Pointer to storage for descriptor. If this
|
||||
* parameter is NULL, the storage for the descriptor
|
||||
* will be allocated on the heap.
|
||||
* \param[in] fmt Format for the image
|
||||
* \param[in] d_w Width of the image
|
||||
* \param[in] d_h Height of the image
|
||||
* \param[in] stride_align Alignment, in bytes, of each row in the image.
|
||||
* \param[in] img_data Storage to use for the image
|
||||
*
|
||||
* \return Returns a pointer to the initialized image descriptor. If the img
|
||||
* 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,
|
||||
unsigned int d_h, unsigned int stride_align,
|
||||
unsigned char *img_data);
|
||||
|
||||
/*!\brief Set the rectangle identifying the displayed portion of the image
|
||||
*
|
||||
* Updates the displayed rectangle (aka viewport) on the image surface to
|
||||
* match the specified coordinates and size.
|
||||
*
|
||||
* \param[in] img Image descriptor
|
||||
* \param[in] x leftmost column
|
||||
* \param[in] y topmost row
|
||||
* \param[in] w width
|
||||
* \param[in] h height
|
||||
*
|
||||
* \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,
|
||||
unsigned int w, unsigned int h);
|
||||
|
||||
/*!\brief Flip the image vertically (top for bottom)
|
||||
*
|
||||
* Adjusts the image descriptor's pointers and strides to make the image
|
||||
* be referenced upside-down.
|
||||
*
|
||||
* \param[in] img Image descriptor
|
||||
*/
|
||||
void vpx_img_flip(vpx_image_t *img);
|
||||
|
||||
/*!\brief Close an image descriptor
|
||||
*
|
||||
* Frees all allocated storage associated with an image descriptor.
|
||||
*
|
||||
* \param[in] img Image descriptor
|
||||
*/
|
||||
void vpx_img_free(vpx_image_t *img);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif // VPX_VPX_VPX_IMAGE_H_
|
||||
40
vpx/include/vpx/vpx_integer.h
Normal file
40
vpx/include/vpx/vpx_integer.h
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef VPX_VPX_VPX_INTEGER_H_
|
||||
#define VPX_VPX_VPX_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
|
||||
#else
|
||||
#define VPX_FORCE_INLINE __inline__ __attribute__((always_inline))
|
||||
// TODO(jbb): Allow a way to force inline off for older compilers.
|
||||
#define VPX_INLINE inline
|
||||
#endif
|
||||
|
||||
/* Assume platforms have the C99 standard integer types. */
|
||||
|
||||
#if defined(__cplusplus)
|
||||
#if !defined(__STDC_FORMAT_MACROS)
|
||||
#define __STDC_FORMAT_MACROS
|
||||
#endif
|
||||
#if !defined(__STDC_LIMIT_MACROS)
|
||||
#define __STDC_LIMIT_MACROS
|
||||
#endif
|
||||
#endif // __cplusplus
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#endif // VPX_VPX_VPX_INTEGER_H_
|
||||
BIN
vpx/lib/libvpx.a
Normal file
BIN
vpx/lib/libvpx.a
Normal file
Binary file not shown.
Loading…
Reference in a new issue