FFMPEG+SDL2函数

int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)

/**
 * Return the size in bytes of the amount of data required to store an
 * image with the given parameters.
 *
 * @param pix_fmt  the pixel format of the image
 * @param width    the width of the image in pixels
 * @param height   the height of the image in pixels
 * @param align    the assumed linesize alignment
 * @return the buffer size in bytes, a negative error code in case of failure
 */
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align);

函数作用：通过指定像素格式、图像宽、图像高来计算所需的内存大小。

参数说明：align:设定内存对齐的对齐数，即按多大的字节进行内存对齐。如设置为1，表示按1字节对齐，那么得到的结果与实际的内存大小一样。如设置为4，表示按4字节对齐。也就是内存的起始地址必须是4的整倍数。

 

int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
                                          const uint8_t *src,
                                          enum AVPixelFormat pix_fmt, int width, int height, int align);

/**
 * Setup the data pointers and linesizes based on the specified image
 * parameters and the provided array.
 *
 * The fields of the given image are filled in by using the src
 * address which points to the image data buffer. Depending on the
 * specified pixel format, one or multiple image data pointers and
 * line sizes will be set.  If a planar format is specified, several
 * pointers will be set pointing to the different picture planes and
 * the line sizes of the different planes will be stored in the
 * lines_sizes array. Call with src == NULL to get the required
 * size for the src buffer.
 *
 * To allocate the buffer and fill in the dst_data and dst_linesize in
 * one call, use av_image_alloc().
 *
 * @param dst_data      data pointers to be filled in
 * @param dst_linesize  linesizes for the image in dst_data to be filled in
 * @param src           buffer which will contain or contains the actual image data, can be NULL
 * @param pix_fmt       the pixel format of the image
 * @param width         the width of the image in pixels
 * @param height        the height of the image in pixels
 * @param align         the value used in src for linesize alignment
 * @return the size in bytes required for src, a negative error code
 * in case of failure
 */
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
                         const uint8_t *src,
                         enum AVPixelFormat pix_fmt, int width, int height, int align);

函数作用：类似于格式化已经申请的内存。

参数说明：

dst_data[4]（输出参数）：对应AVFrame的data

dst_linesize[4]（输出参数）：对应AVFrame的linesize

*src（输入参数）：av_alloc()函数申请的内存地址。

pix_fmt（输入参数）：申请 src内存时的像素格式

width（输入参数）：申请src内存时指定的宽度

height（输入参数）：申请scr内存时指定的高度

align（输入参数）：申请src内存时指定的对齐字节数。

步骤：①计算所需内存大小av_image_get_buffer_size() --> ② 按计算的内存大小申请所需内存 av_malloc()  --> ③对申请的内存进行格式化 av_image_fill_arrays();

 

struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
                                                              int dstW, int dstH, enum AVPixelFormat dstFormat,
                                                              int flags, SwsFilter *srcFilter,
                                                             SwsFilter *dstFilter, const double *param);

配合使用顺序：

①sws_getContext() 
②sws_scale() 
③sws_freeContext()

/**
 * Allocate and return an SwsContext. You need it to perform
 * scaling/conversion operations using sws_scale().
 *
 * @param srcW the width of the source image
 * @param srcH the height of the source image
 * @param srcFormat the source image format
 * @param dstW the width of the destination image
 * @param dstH the height of the destination image
 * @param dstFormat the destination image format
 * @param flags specify which algorithm and options to use for rescaling
 * @param param extra parameters to tune the used scaler
 *              For SWS_BICUBIC param[0] and [1] tune the shape of the basis
 *              function, param[0] tunes f(1) and param[1] f´(1)
 *              For SWS_GAUSS param[0] tunes the exponent and thus cutoff
 *              frequency
 *              For SWS_LANCZOS param[0] tunes the width of the window function
 * @return a pointer to an allocated context, or NULL in case of error
 * @note this function is to be removed after a saner alternative is
 *       written
 */
struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
                                  int dstW, int dstH, enum AVPixelFormat dstFormat,
                                  int flags, SwsFilter *srcFilter,
                                  SwsFilter *dstFilter, const double *param);

函数作用；函数返回SwsContext结构体，定义了基本变换信息。

参数说明：

srcW：定义输入图像的宽

srcH：定义输入图像的高

srcFormat：定义输入图像的像素格式
dstW：定义输出图像的宽

dstH：定义输出图像的高

dstFormat：定义输出图像像素格式
flags：选择缩放算法（只有当输入输出图像大小不同时有效）
*srcFilter：定义输入图像滤波器信息，如果不做前后图像滤波，输入NULL

*dstFilter：定义输出图像滤波器信息，如果不做前后图像滤波，输入NULL
*param：定义特定缩放算法需要的参数，默认为NULL

int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
              const int srcStride[], int srcSliceY, int srcSliceH,
              uint8_t *const dst[], const int dstStride[]);

/**
 * Scale the image slice in srcSlice and put the resulting scaled
 * slice in the image in dst. A slice is a sequence of consecutive
 * rows in an image.
 *
 * Slices have to be provided in sequential order, either in
 * top-bottom or bottom-top order. If slices are provided in
 * non-sequential order the behavior of the function is undefined.
 *
 * @param c         the scaling context previously created with
 *                  sws_getContext()
 * @param srcSlice  the array containing the pointers to the planes of
 *                  the source slice
 * @param srcStride the array containing the strides for each plane of
 *                  the source image
 * @param srcSliceY the position in the source image of the slice to
 *                  process, that is the number (counted starting from
 *                  zero) in the image of the first row of the slice
 * @param srcSliceH the height of the source slice, that is the number
 *                  of rows in the slice
 * @param dst       the array containing the pointers to the planes of
 *                  the destination image
 * @param dstStride the array containing the strides for each plane of
 *                  the destination image
 * @return          the height of the output slice
 */
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
              const int srcStride[], int srcSliceY, int srcSliceH,
              uint8_t *const dst[], const int dstStride[]);

函数解析参见大佬博客：
FFmpeg: FFmepg中的函数分析 - 夜行过客 - 博客园 https://www.cnblogs.com/yongdaimi/p/10715830.html

extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,

                                                                                                  const SDL_Rect * rect,

                                                                                                  const Uint8 *Yplane, int Ypitch,

                                                                                                  const Uint8 *Uplane, int Upitch,

                                                                                                  const Uint8 *Vplane, int Vpitch);

/**
 *  \brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
 *
 *  \param texture   The texture to update
 *  \param rect      A pointer to the rectangle of pixels to update, or NULL to
 *                   update the entire texture.
 *  \param Yplane    The raw pixel data for the Y plane.
 *  \param Ypitch    The number of bytes between rows of pixel data for the Y plane.
 *  \param Uplane    The raw pixel data for the U plane.
 *  \param Upitch    The number of bytes between rows of pixel data for the U plane.
 *  \param Vplane    The raw pixel data for the V plane.
 *  \param Vpitch    The number of bytes between rows of pixel data for the V plane.
 *
 *  \return 0 on success, or -1 if the texture is not valid.
 *
 *  \note You can use SDL_UpdateTexture() as long as your pixel data is
 *        a contiguous block of Y and U/V planes in the proper order, but
 *        this function is available if your pixel data is not contiguous.
 */
extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,
                                                 const SDL_Rect * rect,
                                                 const Uint8 *Yplane, int Ypitch,
                                                 const Uint8 *Uplane, int Upitch,
                                                 const Uint8 *Vplane, int Vpitch);