FFmpeg学习笔记-新旧API替换

解码：

@deprecated Use avcodec_send_packet() and avcodec_receive_frame().

attribute_deprecated

int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                             int *got_picture_ptr,

                     const AVPacket *avpkt);

/**

 * Supply raw packet data as input to a decoder.

 *

 * Internally, this call will copy relevant AVCodecContext fields, which can

 * influence decoding per-packet, and apply them when the packet is actually

 * decoded. (For example AVCodecContext.skip_frame, which might direct the

 * decoder to drop the frame contained by the packet sent with this function.)

 *

 * @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE

 *          larger than the actual read bytes because some optimized bitstream

 *          readers read 32 or 64 bits at once and could read over the end.

 *

 * @warning Do not mix this API with the legacy API (like avcodec_decode_video2())

 *          on the same AVCodecContext. It will return unexpected results now

 *          or in future libavcodec versions.

 *

 * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()

 *       before packets may be fed to the decoder.

 *

 * @param avctx codec context

 * @param[in] avpkt The input AVPacket. Usually, this will be a single video

 *                  frame, or several complete audio frames.

 *                  Ownership of the packet remains with the caller, and the

 *                  decoder will not write to the packet. The decoder may create

 *                  a reference to the packet data (or copy it if the packet is

 *                  not reference-counted).

 *                  Unlike with older APIs, the packet is always fully consumed,

 *                  and if it contains multiple frames (e.g. some audio codecs),

 *                  will require you to call avcodec_receive_frame() multiple

 *                  times afterwards before you can send a new packet.

 *                  It can be NULL (or an AVPacket with data set to NULL and

 *                  size set to 0); in this case, it is considered a flush

 *                  packet, which signals the end of the stream. Sending the

 *                  first flush packet will return success. Subsequent ones are

 *                  unnecessary and will return AVERROR_EOF. If the decoder

 *                  still has frames buffered, it will return them after sending

 *                  a flush packet.

 *

 * @return 0 on success, otherwise negative error code:

 *      AVERROR(EAGAIN):   input is not accepted in the current state - user

 *                         must read output with avcodec_receive_frame() (once

 *                         all output is read, the packet should be resent, and

 *                         the call will not fail with EAGAIN).

 *      AVERROR_EOF:       the decoder has been flushed, and no new packets can

 *                         be sent to it (also returned if more than 1 flush

 *                         packet is sent)

 *      AVERROR(EINVAL):   codec not opened, it is an encoder, or requires flush

 *      AVERROR(ENOMEM):   failed to add packet to internal queue, or similar

 *      other errors: legitimate decoding errors

 */

int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);

/**

 * Return decoded output data from a decoder.

 *

 * @param avctx codec context

 * @param frame This will be set to a reference-counted video or audio

 *              frame (depending on the decoder type) allocated by the

 *              decoder. Note that the function will always call

 *              av_frame_unref(frame) before doing anything else.

 *

 * @return

 *      0:                 success, a frame was returned

 *      AVERROR(EAGAIN):   output is not available in this state - user must try

 *                         to send new input

 *      AVERROR_EOF:       the decoder has been fully flushed, and there will be

 *                         no more output frames

 *      AVERROR(EINVAL):   codec not opened, or it is an encoder

 *      other negative values: legitimate decoding errors

 */

int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);

编码：

@deprecated use avcodec_send_frame()/avcodec_receive_packet()
instead

attribute_deprecated

int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,

                          const AVFrame *frame, int *got_packet_ptr);

/**

 * Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet()

 * to retrieve buffered output packets.

 *

 * @param avctx     codec context

 * @param[in] frame AVFrame containing the raw audio or video frame to be encoded.

 *                  Ownership of the frame remains with the caller, and the

 *                  encoder will not write to the frame. The encoder may create

 *                  a reference to the frame data (or copy it if the frame is

 *                  not reference-counted).

 *                  It can be NULL, in which case it is considered a flush

 *                  packet.  This signals the end of the stream. If the encoder

 *                  still has packets buffered, it will return them after this

 *                  call. Once flushing mode has been entered, additional flush

 *                  packets are ignored, and sending frames will return

 *                  AVERROR_EOF.

 *

 *                  For audio:

 *                  If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame

 *                  can have any number of samples.

 *                  If it is not set, frame->nb_samples must be equal to

 *                  avctx->frame_size for all frames except the last.

 *                  The final frame may be smaller than avctx->frame_size.

 * @return 0 on success, otherwise negative error code:

 *      AVERROR(EAGAIN):   input is not accepted in the current state - user

 *                         must read output with avcodec_receive_packet() (once

 *                         all output is read, the packet should be resent, and

 *                         the call will not fail with EAGAIN).

 *      AVERROR_EOF:       the encoder has been flushed, and no new frames can

 *                         be sent to it

 *      AVERROR(EINVAL):   codec not opened, refcounted_frames not set, it is a

 *                         decoder, or requires flush

 *      AVERROR(ENOMEM):   failed to add packet to internal queue, or similar

 *      other errors: legitimate decoding errors

 */

int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);

/**

 * Read encoded data from the encoder.

 *

 * @param avctx codec context

 * @param avpkt This will be set to a reference-counted packet allocated by the

 *              encoder. Note that the function will always call

 *              av_frame_unref(frame) before doing anything else.

 * @return 0 on success, otherwise negative error code:

 *      AVERROR(EAGAIN):   output is not available in the current state - user

 *                         must try to send input

 *      AVERROR_EOF:       the encoder has been fully flushed, and there will be

 *                         no more output packets

 *      AVERROR(EINVAL):   codec not opened, or it is an encoder

 *      other errors: legitimate decoding errors

 */

int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);

拷贝流参数信息：

 * @deprecated The semantics of this function are ill-defined and it should not

 * be used. If you need to transfer the stream parameters from one codec context

 * to another, use an intermediate AVCodecParameters instance and the

 * avcodec_parameters_from_context() / avcodec_parameters_to_context()

 * functions.

 */

attribute_deprecated

int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);

avcodec_copy_context感觉可以用avcodec_parameters_copy代替

avcodec_parameters_copy拷贝输入流参数到输出流参数中

/**

 * Copy the contents of src to dst. Any allocated fields in dst are freed and

 * replaced with newly allocated duplicates of the corresponding fields in src.

 *

 * @return >= 0 on success, a negative AVERROR code on failure.

 */

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);

填充AVFrame的data和linesize：

/**

 * @deprecated use av_image_fill_arrays() instead.

 */

attribute_deprecated

int avpicture_fill(AVPicture *picture, const uint8_t *ptr,

                   enum AVPixelFormat pix_fmt, int width, int height);

/**

 * 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_linesizes 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);

获取填充一帧的大小（bytes）：

/**

 * @deprecated use av_image_get_buffer_size() instead.

 */

attribute_deprecated

int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);

/**

 * Return the size in bytes of the amount of data required to store an

 * image with the given parameters.

 *

 * @param[in] align the assumed linesize alignment

 */

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