[置顶] FFmpeg总结（四）AV系列结构体之AVBuffer、AVBufferRef、AVBufferPool
位置：libavutil/buffer.h
AVBuffer采用引用计数的数据Buffer的API。
有两个核心对象这个API——AVBuffer和AVBufferRef。
AVBuffer代表数据缓冲区本身，它是私有的，不能直接被调用者调用。我们可以通过AVBufferRef，调用者须要检查两个AVBuffer指针是否指向两个不同的引用在同一数据buffer中。AVBufferRef 代表一个单个引用指向AVBuffer，调用者可以直接调它。
有两个功能函数提供创建一个AVBuffer对象在一个单引用中，av_buffer_alloc()分配置一个新buffer空间。av_buffer_create()负责包装已存在数组的AVBuffer对象。从一个已存在引用，其他的引用将创建通过av_buffer_ref()方法。
使用av_buffer_unref()，交释放这个引用（包含数据引用及计数引用）。
在已经存在的AVBuffer引用中，FFmpeg认为AVBuffer是可写入相关数据的。（不会被标识只读），av_buffer_is_writable() 函数提供是否可write的功能，如果不能将自动创建一个新的可写的buffer。
typedef struct AVBuffer AVBuffer;
/** * A reference to a data buffer. * * The size of this struct is not a part of the public ABI and it is not meant * to be allocated directly. */
typedef struct AVBufferRef {
AVBuffer *buffer;
/** * The data buffer. It is considered writable if and only if * this is the only reference to the buffer, in which case * av_buffer_is_writable() returns 1. */
uint8_t *data;
/** * Size of data in bytes. */
int size;
} AVBufferRef;
/** * Allocate an AVBuffer of the given size using av_malloc(). * * @return an AVBufferRef of given size or NULL when out of memory */
AVBufferRef *av_buffer_alloc(int size);
/** * Same as av_buffer_alloc(), except the returned buffer will be initialized * to zero. */
AVBufferRef *av_buffer_allocz(int size);
/** * Always treat the buffer as read-only, even when it has only one * reference. */
#define AV_BUFFER_FLAG_READONLY (1 << 0)
/** * Create an AVBuffer from an existing array. * * If this function is successful, data is owned by the AVBuffer. The caller may * only access data through the returned AVBufferRef and references derived from * it. * If this function fails, data is left untouched. * @param data data array * @param size size of data in bytes * @param free a callback for freeing this buffer's data * @param opaque parameter to be got for processing or passed to free * @param flags a combination of AV_BUFFER_FLAG_* * * @return an AVBufferRef referring to data on success, NULL on failure. */
AVBufferRef *av_buffer_create(uint8_t *data, int size,
void (*free)(void *opaque, uint8_t *data),
void *opaque, int flags);
/** * Default free callback, which calls av_free() on the buffer data. * This function is meant to be passed to av_buffer_create(), not called * directly. */
void av_buffer_default_free(void *opaque, uint8_t *data);
/** * Create a new reference to an AVBuffer. * * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on * failure. */
AVBufferRef *av_buffer_ref(AVBufferRef *buf);
/** * Free a given reference and automatically free the buffer if there are no more * references to it. * * @param buf the reference to be freed. The pointer is set to NULL on return. */
void av_buffer_unref(AVBufferRef **buf);
/** * @return 1 if the caller may write to the data referred to by buf (which is * true if and only if buf is the only reference to the underlying AVBuffer). * Return 0 otherwise. * A positive answer is valid until av_buffer_ref() is called on buf. */
int av_buffer_is_writable(const AVBufferRef *buf);
/** * @return the opaque parameter set by av_buffer_create. */
void *av_buffer_get_opaque(const AVBufferRef *buf);
int av_buffer_get_ref_count(const AVBufferRef *buf);
/** * Create a writable reference from a given buffer reference, avoiding data copy * if possible. * * @param buf buffer reference to make writable. On success, buf is either left * untouched, or it is unreferenced and a new writable AVBufferRef is * written in its place. On failure, buf is left untouched. * @return 0 on success, a negative AVERROR on failure. */
int av_buffer_make_writable(AVBufferRef **buf);
/** * Reallocate a given buffer. * * @param buf a buffer reference to reallocate. On success, buf will be * unreferenced and a new reference with the required size will be * written in its place. On failure buf will be left untouched. *buf * may be NULL, then a new buffer is allocated. * @param size required new buffer size. * @return 0 on success, a negative AVERROR on failure. * * @note the buffer is actually reallocated with av_realloc() only if it was * initially allocated through av_buffer_realloc(NULL) and there is only one * reference to it (i.e. the one passed to this function). In all other cases * a new buffer is allocated and the data is copied. */
int av_buffer_realloc(AVBufferRef **buf, int size);
/** * @} */
typedef struct AVBufferPool AVBufferPool;
/** * Allocate and initialize a buffer pool. * * @param size size of each buffer in this pool * @param alloc a function that will be used to allocate new buffers when the * pool is empty. May be NULL, then the default allocator will be used * (av_buffer_alloc()). * @return newly created buffer pool on success, NULL on error. */
AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
/** * Allocate and initialize a buffer pool with a more complex allocator. * * @param size size of each buffer in this pool * @param opaque arbitrary user data used by the allocator * @param alloc a function that will be used to allocate new buffers when the * pool is empty. * @param pool_free a function that will be called immediately before the pool * is freed. I.e. after av_buffer_pool_can_uninit() is called * by the pool and all the frames are returned to the pool and * freed. It is intended to uninitialize the user opaque data. * @return newly created buffer pool on success, NULL on error. */
AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
AVBufferRef* (*alloc)(void *opaque, int size),
void (*pool_free)(void *opaque));
/** * Mark the pool as being available for freeing. It will actually be freed only * once all the allocated buffers associated with the pool are released. Thus it * is safe to call this function while some of the allocated buffers are still * in use. * * @param pool pointer to the pool to be freed. It will be set to NULL. */
void av_buffer_pool_uninit(AVBufferPool **pool);
/** * Allocate a new AVBuffer, reusing an old buffer from the pool when available. * This function may be called simultaneously from multiple threads. * * @return a reference to the new buffer on success, NULL on error. */
AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
/** * @} */
#endif /* AVUTIL_BUFFER_H */AVBufferPool 是用来管理大buffer时的API
调用者必须使用av_buffer_pool_init()创建一个buffer池，无论什么时候需要，通过av_buffer_pool_get()，得到新buffer的引用，和av_buffer_alloc()非常像，当不被引用时，会重新归还给pool，而不用去像AVBuffer那样释放。当调用者不再分配新的buffer时，av_buffer_pool_uninit() 必须调用，表明这个pool将自动释放了（因为这个pool也是一个对象）。分配和释放buffer，是线程安全操作，只要保证没有其他默认alloc的callback在使用。这个结构体是私有的，不能直接被外部使用，外部可以用av_buffer_pool_init()，及av_buffer_pool_uninit()函数。