FFmpeg存放压缩后的音视频数据的结构体：AVPacket简介，结构体，函数

如下图的解码流程，AVPacket中的位置

FFmpeg源码中通过AVPacket存储压缩后的音视频数据。它通常由解复用器（demuxers）输出，然后作为输入传递给解码器。

或者从编码器作为输出接收，然后传递给多路复用器（muxers）。

对于视频，它通常包含一个压缩帧；对于音频，它可能包含几个压缩帧。编码器允许输出不包含压缩音视频数据、只包含side data(边数据：例如，在编码结束时更新一些流参数)的空的数据包（ empty packets）。

AVPacket 结构体 所在的文件名 libavcodec/packet.h

/** AVPacket public API** This file is part of FFmpeg.** FFmpeg is free software; you can redistribute it and/or* modify it under the terms of the GNU Lesser General Public* License as published by the Free Software Foundation; either* version 2.1 of the License, or (at your option) any later version.** FFmpeg is distributed in the hope that it will be useful,* but WITHOUT ANY WARRANTY; without even the implied warranty of* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU* Lesser General Public License for more details.** You should have received a copy of the GNU Lesser General Public* License along with FFmpeg; if not, write to the Free Software* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA*/#ifndef AVCODEC_PACKET_H
#define AVCODEC_PACKET_H#include <stddef.h>
#include <stdint.h>#include "libavutil/attributes.h"
#include "libavutil/buffer.h"
#include "libavutil/dict.h"
#include "libavutil/rational.h"
#include "libavutil/version.h"#include "libavcodec/version_major.h"/*** @defgroup lavc_packet AVPacket** Types and functions for working with AVPacket.* @{*/
enum AVPacketSideDataType {/*** An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE* bytes worth of palette. This side data signals that a new palette is* present.*/AV_PKT_DATA_PALETTE,/*** The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format* that the extradata buffer was changed and the receiving side should* act upon it appropriately. The new extradata is embedded in the side* data buffer and should be immediately used for processing the current* frame or packet.*/AV_PKT_DATA_NEW_EXTRADATA,/*** An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:* @code* u32le param_flags* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)*     s32le channel_count* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)*     u64le channel_layout* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)*     s32le sample_rate* if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)*     s32le width*     s32le height* @endcode*/AV_PKT_DATA_PARAM_CHANGE,/*** An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of* structures with info about macroblocks relevant to splitting the* packet into smaller packets on macroblock edges (e.g. as for RFC 2190).* That is, it does not necessarily contain info about all macroblocks,* as long as the distance between macroblocks in the info is smaller* than the target payload size.* Each MB info structure is 12 bytes, and is laid out as follows:* @code* u32le bit offset from the start of the packet* u8    current quantizer at the start of the macroblock* u8    GOB number* u16le macroblock address within the GOB* u8    horizontal MV predictor* u8    vertical MV predictor* u8    horizontal MV predictor for block number 3* u8    vertical MV predictor for block number 3* @endcode*/AV_PKT_DATA_H263_MB_INFO,/*** This side data should be associated with an audio stream and contains* ReplayGain information in form of the AVReplayGain struct.*/AV_PKT_DATA_REPLAYGAIN,/*** This side data contains a 3x3 transformation matrix describing an affine* transformation that needs to be applied to the decoded video frames for* correct presentation.** See libavutil/display.h for a detailed description of the data.*/AV_PKT_DATA_DISPLAYMATRIX,/*** This side data should be associated with a video stream and contains* Stereoscopic 3D information in form of the AVStereo3D struct.*/AV_PKT_DATA_STEREO3D,/*** This side data should be associated with an audio stream and corresponds* to enum AVAudioServiceType.*/AV_PKT_DATA_AUDIO_SERVICE_TYPE,/*** This side data contains quality related information from the encoder.* @code* u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).* u8    picture type* u8    error count* u16   reserved* u64le[error count] sum of squared differences between encoder in and output* @endcode*/AV_PKT_DATA_QUALITY_STATS,/*** This side data contains an integer value representing the stream index* of a "fallback" track.  A fallback track indicates an alternate* track to use when the current track can not be decoded for some reason.* e.g. no decoder available for codec.*/AV_PKT_DATA_FALLBACK_TRACK,/*** This side data corresponds to the AVCPBProperties struct.*/AV_PKT_DATA_CPB_PROPERTIES,/*** Recommmends skipping the specified number of samples* @code* u32le number of samples to skip from start of this packet* u32le number of samples to skip from end of this packet* u8    reason for start skip* u8    reason for end   skip (0=padding silence, 1=convergence)* @endcode*/AV_PKT_DATA_SKIP_SAMPLES,/*** An AV_PKT_DATA_JP_DUALMONO side data packet indicates that* the packet may contain "dual mono" audio specific to Japanese DTV* and if it is true, recommends only the selected channel to be used.* @code* u8    selected channels (0=main/left, 1=sub/right, 2=both)* @endcode*/AV_PKT_DATA_JP_DUALMONO,/*** A list of zero terminated key/value strings. There is no end marker for* the list, so it is required to rely on the side data size to stop.*/AV_PKT_DATA_STRINGS_METADATA,/*** Subtitle event position* @code* u32le x1* u32le y1* u32le x2* u32le y2* @endcode*/AV_PKT_DATA_SUBTITLE_POSITION,/*** Data found in BlockAdditional element of matroska container. There is* no end marker for the data, so it is required to rely on the side data* size to recognize the end. 8 byte id (as found in BlockAddId) followed* by data.*/AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,/*** The optional first identifier line of a WebVTT cue.*/AV_PKT_DATA_WEBVTT_IDENTIFIER,/*** The optional settings (rendering instructions) that immediately* follow the timestamp specifier of a WebVTT cue.*/AV_PKT_DATA_WEBVTT_SETTINGS,/*** A list of zero terminated key/value strings. There is no end marker for* the list, so it is required to rely on the side data size to stop. This* side data includes updated metadata which appeared in the stream.*/AV_PKT_DATA_METADATA_UPDATE,/*** MPEGTS stream ID as uint8_t, this is required to pass the stream ID* information from the demuxer to the corresponding muxer.*/AV_PKT_DATA_MPEGTS_STREAM_ID,/*** Mastering display metadata (based on SMPTE-2086:2014). This metadata* should be associated with a video stream and contains data in the form* of the AVMasteringDisplayMetadata struct.*/AV_PKT_DATA_MASTERING_DISPLAY_METADATA,/*** This side data should be associated with a video stream and corresponds* to the AVSphericalMapping structure.*/AV_PKT_DATA_SPHERICAL,/*** Content light level (based on CTA-861.3). This metadata should be* associated with a video stream and contains data in the form of the* AVContentLightMetadata struct.*/AV_PKT_DATA_CONTENT_LIGHT_LEVEL,/*** ATSC A53 Part 4 Closed Captions. This metadata should be associated with* a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.* The number of bytes of CC data is AVPacketSideData.size.*/AV_PKT_DATA_A53_CC,/*** This side data is encryption initialization data.* The format is not part of ABI, use av_encryption_init_info_* methods to* access.*/AV_PKT_DATA_ENCRYPTION_INIT_INFO,/*** This side data contains encryption info for how to decrypt the packet.* The format is not part of ABI, use av_encryption_info_* methods to access.*/AV_PKT_DATA_ENCRYPTION_INFO,/*** Active Format Description data consisting of a single byte as specified* in ETSI TS 101 154 using AVActiveFormatDescription enum.*/AV_PKT_DATA_AFD,/*** Producer Reference Time data corresponding to the AVProducerReferenceTime struct,* usually exported by some encoders (on demand through the prft flag set in the* AVCodecContext export_side_data field).*/AV_PKT_DATA_PRFT,/*** ICC profile data consisting of an opaque octet buffer following the* format described by ISO 15076-1.*/AV_PKT_DATA_ICC_PROFILE,/*** DOVI configuration* ref:* dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2* dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3* Tags are stored in struct AVDOVIDecoderConfigurationRecord.*/AV_PKT_DATA_DOVI_CONF,/*** Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t* where the first uint32_t describes how many (1-3) of the other timecodes are used.* The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()* function in libavutil/timecode.h.*/AV_PKT_DATA_S12M_TIMECODE,/*** HDR10+ dynamic metadata associated with a video frame. The metadata is in* the form of the AVDynamicHDRPlus struct and contains* information for color volume transform - application 4 of* SMPTE 2094-40:2016 standard.*/AV_PKT_DATA_DYNAMIC_HDR10_PLUS,/*** The number of side data types.* This is not part of the public API/ABI in the sense that it may* change when new side data types are added.* This must stay the last enum value.* If its value becomes huge, some code using it* needs to be updated as it assumes it to be smaller than other limits.*/AV_PKT_DATA_NB
};#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATEDtypedef struct AVPacketSideData {uint8_t *data;size_t   size;enum AVPacketSideDataType type;
} AVPacketSideData;/*** This structure stores compressed data. It is typically exported by demuxers* and then passed as input to decoders, or received as output from encoders and* then passed to muxers.** For video, it should typically contain one compressed frame. For audio it may* contain several compressed frames. Encoders are allowed to output empty* packets, with no compressed data, containing only side data* (e.g. to update some stream parameters at the end of encoding).** The semantics of data ownership depends on the buf field.* If it is set, the packet data is dynamically allocated and is* valid indefinitely until a call to av_packet_unref() reduces the* reference count to 0.** If the buf field is not set av_packet_ref() would make a copy instead* of increasing the reference count.** The side data is always allocated with av_malloc(), copied by* av_packet_ref() and freed by av_packet_unref().** sizeof(AVPacket) being a part of the public ABI is deprecated. once* av_init_packet() is removed, new packets will only be able to be allocated* with av_packet_alloc(), and new fields may be added to the end of the struct* with a minor bump.** @see av_packet_alloc* @see av_packet_ref* @see av_packet_unref*/
typedef struct AVPacket {/*** A reference to the reference-counted buffer where the packet data is* stored.* May be NULL, then the packet data is not reference-counted.*/AVBufferRef *buf;/*** Presentation timestamp in AVStream->time_base units; the time at which* the decompressed packet will be presented to the user.* Can be AV_NOPTS_VALUE if it is not stored in the file.* pts MUST be larger or equal to dts as presentation cannot happen before* decompression, unless one wants to view hex dumps. Some formats misuse* the terms dts and pts/cts to mean something different. Such timestamps* must be converted to true pts/dts before they are stored in AVPacket.*/int64_t pts;/*** Decompression timestamp in AVStream->time_base units; the time at which* the packet is decompressed.* Can be AV_NOPTS_VALUE if it is not stored in the file.*/int64_t dts;uint8_t *data;int   size;int   stream_index;/*** A combination of AV_PKT_FLAG values*/int   flags;/*** Additional packet data that can be provided by the container.* Packet can contain several types of side information.*/AVPacketSideData *side_data;int side_data_elems;/*** Duration of this packet in AVStream->time_base units, 0 if unknown.* Equals next_pts - this_pts in presentation order.*/int64_t duration;int64_t pos;                            ///< byte position in stream, -1 if unknown/*** for some private data of the user*/void *opaque;/*** AVBufferRef for free use by the API user. FFmpeg will never check the* contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when* the packet is unreferenced. av_packet_copy_props() calls create a new* reference with av_buffer_ref() for the target packet's opaque_ref field.** This is unrelated to the opaque field, although it serves a similar* purpose.*/AVBufferRef *opaque_ref;/*** Time base of the packet's timestamps.* In the future, this field may be set on packets output by encoders or* demuxers, but its value will be by default ignored on input to decoders* or muxers.*/AVRational time_base;
} AVPacket;#if FF_API_INIT_PACKET
attribute_deprecated
typedef struct AVPacketList {AVPacket pkt;struct AVPacketList *next;
} AVPacketList;
#endif#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
/*** Flag is used to discard packets which are required to maintain valid* decoder state but are not required for output and should be dropped* after decoding.**/
#define AV_PKT_FLAG_DISCARD   0x0004
/*** The packet comes from a trusted source.** Otherwise-unsafe constructs such as arbitrary pointers to data* outside the packet may be followed.*/
#define AV_PKT_FLAG_TRUSTED   0x0008
/*** Flag is used to indicate packets that contain frames that can* be discarded by the decoder.  I.e. Non-reference frames.*/
#define AV_PKT_FLAG_DISPOSABLE 0x0010enum AVSideDataParamChangeFlags {
#if FF_API_OLD_CHANNEL_LAYOUT/*** @deprecated those are not used by any decoder*/AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
#endifAV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE    = 0x0004,AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS     = 0x0008,
};/*** Allocate an AVPacket and set its fields to default values.  The resulting* struct must be freed using av_packet_free().** @return An AVPacket filled with default values or NULL on failure.** @note this only allocates the AVPacket itself, not the data buffers. Those* must be allocated through other means such as av_new_packet.** @see av_new_packet*/
AVPacket *av_packet_alloc(void);/*** Create a new packet that references the same data as src.** This is a shortcut for av_packet_alloc()+av_packet_ref().** @return newly created AVPacket on success, NULL on error.** @see av_packet_alloc* @see av_packet_ref*/
AVPacket *av_packet_clone(const AVPacket *src);/*** Free the packet, if the packet is reference counted, it will be* unreferenced first.** @param pkt packet to be freed. The pointer will be set to NULL.* @note passing NULL is a no-op.*/
void av_packet_free(AVPacket **pkt);#if FF_API_INIT_PACKET
/*** Initialize optional fields of a packet with default values.** Note, this does not touch the data and size members, which have to be* initialized separately.** @param pkt packet** @see av_packet_alloc* @see av_packet_unref** @deprecated This function is deprecated. Once it's removed,sizeof(AVPacket) will not be a part of the ABI anymore.*/
attribute_deprecated
void av_init_packet(AVPacket *pkt);
#endif/*** Allocate the payload of a packet and initialize its fields with* default values.** @param pkt packet* @param size wanted payload size* @return 0 if OK, AVERROR_xxx otherwise*/
int av_new_packet(AVPacket *pkt, int size);/*** Reduce packet size, correctly zeroing padding** @param pkt packet* @param size new size*/
void av_shrink_packet(AVPacket *pkt, int size);/*** Increase packet size, correctly zeroing padding** @param pkt packet* @param grow_by number of bytes by which to increase the size of the packet*/
int av_grow_packet(AVPacket *pkt, int grow_by);/*** Initialize a reference-counted packet from av_malloc()ed data.** @param pkt packet to be initialized. This function will set the data, size,*        and buf fields, all others are left untouched.* @param data Data allocated by av_malloc() to be used as packet data. If this*        function returns successfully, the data is owned by the underlying AVBuffer.*        The caller may not access the data through other means.* @param size size of data in bytes, without the padding. I.e. the full buffer*        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.** @return 0 on success, a negative AVERROR on error*/
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);/*** Allocate new information of a packet.** @param pkt packet* @param type side information type* @param size side information size* @return pointer to fresh allocated data or NULL otherwise*/
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,size_t size);/*** Wrap an existing array as a packet side data.** @param pkt packet* @param type side information type* @param data the side data array. It must be allocated with the av_malloc()*             family of functions. The ownership of the data is transferred to*             pkt.* @param size side information size* @return a non-negative number on success, a negative AVERROR code on*         failure. On failure, the packet is unchanged and the data remains*         owned by the caller.*/
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,uint8_t *data, size_t size);/*** Shrink the already allocated side data buffer** @param pkt packet* @param type side information type* @param size new side information size* @return 0 on success, < 0 on failure*/
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,size_t size);/*** Get side information from packet.** @param pkt packet* @param type desired side information type* @param size If supplied, *size will be set to the size of the side data*             or to zero if the desired side data is not present.* @return pointer to data if present or NULL otherwise*/
uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,size_t *size);const char *av_packet_side_data_name(enum AVPacketSideDataType type);/*** Pack a dictionary for use in side_data.** @param dict The dictionary to pack.* @param size pointer to store the size of the returned data* @return pointer to data if successful, NULL otherwise*/
uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
/*** Unpack a dictionary from side_data.** @param data data from side_data* @param size size of the data* @param dict the metadata storage dictionary* @return 0 on success, < 0 on failure*/
int av_packet_unpack_dictionary(const uint8_t *data, size_t size,AVDictionary **dict);/*** Convenience function to free all the side data stored.* All the other fields stay untouched.** @param pkt packet*/
void av_packet_free_side_data(AVPacket *pkt);/*** Setup a new reference to the data described by a given packet** If src is reference-counted, setup dst as a new reference to the* buffer in src. Otherwise allocate a new buffer in dst and copy the* data from src into it.** All the other fields are copied from src.** @see av_packet_unref** @param dst Destination packet. Will be completely overwritten.* @param src Source packet** @return 0 on success, a negative AVERROR on error. On error, dst*         will be blank (as if returned by av_packet_alloc()).*/
int av_packet_ref(AVPacket *dst, const AVPacket *src);/*** Wipe the packet.** Unreference the buffer referenced by the packet and reset the* remaining packet fields to their default values.** @param pkt The packet to be unreferenced.*/
void av_packet_unref(AVPacket *pkt);/*** Move every field in src to dst and reset src.** @see av_packet_unref** @param src Source packet, will be reset* @param dst Destination packet*/
void av_packet_move_ref(AVPacket *dst, AVPacket *src);/*** Copy only "properties" fields from src to dst.** Properties for the purpose of this function are all the fields* beside those related to the packet data (buf, data, size)** @param dst Destination packet* @param src Source packet** @return 0 on success AVERROR on failure.*/
int av_packet_copy_props(AVPacket *dst, const AVPacket *src);/*** Ensure the data described by a given packet is reference counted.** @note This function does not ensure that the reference will be writable.*       Use av_packet_make_writable instead for that purpose.** @see av_packet_ref* @see av_packet_make_writable** @param pkt packet whose data should be made reference counted.** @return 0 on success, a negative AVERROR on error. On failure, the*         packet is unchanged.*/
int av_packet_make_refcounted(AVPacket *pkt);/*** Create a writable reference for the data described by a given packet,* avoiding data copy if possible.** @param pkt Packet whose data should be made writable.** @return 0 on success, a negative AVERROR on failure. On failure, the*         packet is unchanged.*/
int av_packet_make_writable(AVPacket *pkt);/*** Convert valid timing fields (timestamps / durations) in a packet from one* timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be* ignored.** @param pkt packet on which the conversion will be performed* @param tb_src source timebase, in which the timing fields in pkt are*               expressed* @param tb_dst destination timebase, to which the timing fields will be*               converted*/
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);/*** @}*/#endif // AVCODEC_PACKET_H

AVPacket结构体

AVPacket结构体声明在FFmpeg源码（本文演示用的FFmpeg源码版本为7.0.1）的头文件libavcodec/packet.h中：

/*** @}*//*** @defgroup lavc_packet AVPacket** Types and functions for working with AVPacket.* @{*//*** This structure stores compressed data. It is typically exported by demuxers* and then passed as input to decoders, or received as output from encoders and* then passed to muxers.** For video, it should typically contain one compressed frame. For audio it may* contain several compressed frames. Encoders are allowed to output empty* packets, with no compressed data, containing only side data* (e.g. to update some stream parameters at the end of encoding).** The semantics of data ownership depends on the buf field.* If it is set, the packet data is dynamically allocated and is* valid indefinitely until a call to av_packet_unref() reduces the* reference count to 0.** If the buf field is not set av_packet_ref() would make a copy instead* of increasing the reference count.** The side data is always allocated with av_malloc(), copied by* av_packet_ref() and freed by av_packet_unref().** sizeof(AVPacket) being a part of the public ABI is deprecated. once* av_init_packet() is removed, new packets will only be able to be allocated* with av_packet_alloc(), and new fields may be added to the end of the struct* with a minor bump.** @see av_packet_alloc* @see av_packet_ref* @see av_packet_unref*/
typedef struct AVPacket {/*** A reference to the reference-counted buffer where the packet data is* stored.* May be NULL, then the packet data is not reference-counted.*/AVBufferRef *buf;/*** Presentation timestamp in AVStream->time_base units; the time at which* the decompressed packet will be presented to the user.* Can be AV_NOPTS_VALUE if it is not stored in the file.* pts MUST be larger or equal to dts as presentation cannot happen before* decompression, unless one wants to view hex dumps. Some formats misuse* the terms dts and pts/cts to mean something different. Such timestamps* must be converted to true pts/dts before they are stored in AVPacket.*/int64_t pts;/*** Decompression timestamp in AVStream->time_base units; the time at which* the packet is decompressed.* Can be AV_NOPTS_VALUE if it is not stored in the file.*/int64_t dts;uint8_t *data;int   size;int   stream_index;/*** A combination of AV_PKT_FLAG values*/int   flags;/*** Additional packet data that can be provided by the container.* Packet can contain several types of side information.*/AVPacketSideData *side_data;int side_data_elems;/*** Duration of this packet in AVStream->time_base units, 0 if unknown.* Equals next_pts - this_pts in presentation order.*/int64_t duration;int64_t pos;                            ///< byte position in stream, -1 if unknown/*** for some private data of the user*/void *opaque;/*** AVBufferRef for free use by the API user. FFmpeg will never check the* contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when* the packet is unreferenced. av_packet_copy_props() calls create a new* reference with av_buffer_ref() for the target packet's opaque_ref field.** This is unrelated to the opaque field, although it serves a similar* purpose.*/AVBufferRef *opaque_ref;/*** Time base of the packet's timestamps.* In the future, this field may be set on packets output by encoders or* demuxers, but its value will be by default ignored on input to decoders* or muxers.*/AVRational time_base;
} AVPacket;

成员变量buf：

AVBufferRef类型指针，指向“存储packet（一个数据包的压缩后的音视频）数据的引用计数缓冲区”。如果为NULL，表示该packet数据未被引用计数。AVPacket通过AVBufferRef来管理引用计数缓冲区。通过AVBufferRef结构体里面的AVBuffer里面的成员变量refcount记录资源使用的次数，控制资源的释放。可以通过av_buffer_get_ref_count(const AVBufferRef *buf);方法得到引用计数

关于AVBufferRef类型可以参考：FFmpeg引用计数数据缓冲区相关的结构体：AVBuffer、AVBufferRef。-CSDN博客

成员变量pts：

显示时间戳（presentation time stamp）。即帧显示的时间刻度，用来告诉播放器在哪个时间点显示此帧（可以简单理解为这帧视频或音频数据的播放时间）。其单位不是秒，而是以AVStream->time_base为单位。pts必须大于或等于dts，因为一帧视频或音频数据必须在解码后才能播放，所以一帧视频或音频数据的显示/播放时间必须大于或等于解码时间。

在avpacket中，pts 并不由我们写入，这是因为 pts 的显示时间，那么最初的原始数据YUV在存储到avframe的时候，就需要写入pts，不然后面的avpacket怎么知道呢？

成员变量dts：

解码时间戳（Decompression timestamp）。即帧解码的时间刻度，用来告诉播放器在哪个时间点解码此帧。其单位不是秒，而是以AVStream->time_base为单位。

如果解码 和显示都是按照顺序的，那么dts和pts都是一样的，只有当视频中含有B帧的时候，pts 和dts 会有不同的时候，这是因为B帧会参考 前后的帧显示，因此解码的时候先要解码前面的帧，然后解码后面的帧，才能解码自己，但是显示的时候顺序还是一样的，前面一帧--->自己---》后面一帧

dts是由具体的解码器内部生成的，这也很好理解，例如你用的 H264的解码器，或者H265的解码器，那么不同的解码器算法肯定不同，怎么压缩，那一帧是关键帧，后面的哪些帧依赖于这个关键帧，是不是弄成B帧呀，都是不一样的，因此 解码的顺序也是由具体的解码器说的算的

成员变量data：

指针，指向“存放压缩后的一帧（对于视频通常包含一个压缩帧，对于音频可能包含几个压缩帧）音视频数据的缓冲区”。 

成员变量size：

成员变量data指向的缓冲区的大小，单位为字节。

成员变量stream_index：

索引，用来标识该AVPacket所属的视频/音频流的序号，表示这是第几路流。注意：它是从0而不是从1开始的。

成员变量flags：

AV_PKT_FLAG的组合。值有如下选择：

#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
/*** Flag is used to discard packets which are required to maintain valid* decoder state but are not required for output and should be dropped* after decoding.**/
#define AV_PKT_FLAG_DISCARD   0x0004
/*** The packet comes from a trusted source.** Otherwise-unsafe constructs such as arbitrary pointers to data* outside the packet may be followed.*/
#define AV_PKT_FLAG_TRUSTED   0x0008
/*** Flag is used to indicate packets that contain frames that can* be discarded by the decoder.  I.e. Non-reference frames.*/
#define AV_PKT_FLAG_DISPOSABLE 0x0010

AV_PKT_FLAG_KEY：数据包包含一个关键帧，即当前AVPacket是关键帧。可以独立显示出来的一张图片，当然一般情况下，这张图片是有做 帧内编码的（参考视频编码原理那一节），这个很重要，在seekg的时候，一定要移动到 关键帧

AV_PKT_FLAG_CORRUPT：数据包内容已损坏。

AV_PKT_FLAG_DISCARD：用于丢弃需要保持有效解码器状态但不需要输出的数据包，并且在解码后应该丢弃。带有该标志的AVPacket所携带的数据为解码器相关的信息，不会被解码出一幅图像。

AV_PKT_FLAG_TRUSTED：该数据包来自一个可信的源。

AV_PKT_FLAG_DISPOSABLE：用于指示包含可以被解码器丢弃的帧的数据包。也就是非参考帧。

成员变量side_data：

存放“容器可以提供的额外数据包数据”的数组的首地址。数据包可以包含多种类型的边信息，比如，在编码结束的时候更新一些流的参数。指针side_data指向的空间存储了用于解码、展现或处理编码流的辅助信息，它通常由解复用器和编码器导出，可以以分组为单位提供给解码器和复用器，也可以作为全局侧数据(应用于整个编码流)。

成员变量side_data_elems：

side_data的数量。

成员变量duration：

该数据包的持续时间，以AVStream->time_base为单位。值为下一个数据包的pts减去当前数据包的pts。如果值为0表示未知。

成员变量pos：

该数据包在流中的位置，单位为字节。值为-1表示未知。

成员变量opaque：

指针，指向“存放用户使用的私有数据的缓冲区”。

成员变量time_base：

AVRational类型，数据包时间戳的时间基准，即pts和dts的时间基。

例如对于视频来说，这个值可能是 1,25 也就是说，1秒钟我们显示

AVPacket 相关函数说明

av_packet_alloc函数

av_packet_alloc函数定义在源文件libavcodec/avpacket.c中：

需要通过av_packet_free() 释放

 * @note this only allocates the AVPacket itself, not the data buffers. Those
 * must be allocated through other means such as av_new_packet.

需要注意的是： 通过 av_packet_alloc的只能 allocates avpacket自己，里面有写内容给了默认值，有些给了特殊值，//调用 get_packet_defaults(AVPacket *pkt)出了特殊值 的有pts，dts，pos，time_base(time_base在 ffmpeg4.3没有，在5.0以后有)

#define AV_NOPTS_VALUE          ((int64_t)UINT64_C(0x8000000000000000))

    pkt->pts             = AV_NOPTS_VALUE; 
    pkt->dts             = AV_NOPTS_VALUE;
    pkt->pos             = -1;
    pkt->time_base       = av_make_q(0, 1);

/*** Allocate an AVPacket and set its fields to default values.  The resulting* struct must be freed using av_packet_free().** @return An AVPacket filled with default values or NULL on failure.** @note this only allocates the AVPacket itself, not the data buffers. Those* must be allocated through other means such as av_new_packet.** @see av_new_packet*/
AVPacket *av_packet_alloc(void);

实现

AVPacket *av_packet_alloc(void)
{AVPacket *pkt = av_malloc(sizeof(AVPacket));if (!pkt)return pkt;get_packet_defaults(pkt);return pkt;
}//调用 get_packet_defaults(AVPacket *pkt)出了默认值 的有pts，dts，pos，time_base
static void get_packet_defaults(AVPacket *pkt)
{// 清空值，都是0，这意味着后面学习的 av_init_packet(AVPacket * pkt)方法作用不大，因此在ffmpeg5.0之后，将av_init_packet这个方法 标志成了 过时的。memset(pkt, 0, sizeof(*pkt));pkt->pts             = AV_NOPTS_VALUE;pkt->dts             = AV_NOPTS_VALUE;pkt->pos             = -1;pkt->time_base       = av_make_q(0, 1);
}

测试，我们看到在 av_packet_alloc之后，除了avpacket自己有值外，里面的数据都是0或者特殊值。

void av_init_packet(AVPacket* pkt); 已过时

从前面我们使用 av_packet_alloc的源码可以看到，在alloc的时候 memset 了0，然后给了pts，dts，timebase，pos 特殊值，我们看到 av_inti_packet方法除了给 pos，pts，dts，timebase特殊值外，其他值也是0，

这说明：av_init_packet方法干了 av_packet_alloc的部分工作，如果user 是先调用了av_packet_alloc（）；然后再调用 av_init_packet，就会显得很 冗余，这可能也是ffmpeg在5.0上将此方法标识为过时的原因。

那么这个方法到底有没有应用场景呢？应该是有的，当我们不通过 av_packet_alloc()去 create一个AVPacket *的时候，而是直接在 栈上使用一个 AVPacket，那么这个方法就可以初始化avpacket的内容。

#if FF_API_INIT_PACKET
/*** Initialize optional fields of a packet with default values.** Note, this does not touch the data and size members, which have to be* initialized separately.** @param pkt packet** @see av_packet_alloc* @see av_packet_unref** @deprecated This function is deprecated. Once it's removed,sizeof(AVPacket) will not be a part of the ABI anymore.*/
attribute_deprecated
void av_init_packet(AVPacket *pkt);
#endif

实现

#if FF_API_INIT_PACKET
void av_init_packet(AVPacket *pkt)
{pkt->pts                  = AV_NOPTS_VALUE;pkt->dts                  = AV_NOPTS_VALUE;pkt->pos                  = -1;pkt->duration             = 0;pkt->flags                = 0;pkt->stream_index         = 0;pkt->buf                  = NULL;pkt->side_data            = NULL;pkt->side_data_elems      = 0;pkt->opaque               = NULL;pkt->opaque_ref           = NULL;pkt->time_base            = av_make_q(0, 1);
}
#endif

测试：

无作用版：

void createAVPacketandInit1() {AVPacket* avpacket = av_packet_alloc();if (avpacket == nullptr) {cout << "av_packet_alloc error" << endl;}cout << "debug point 0" << endl;av_init_packet(avpacket);cout << "debug point 1" << endl;
}

有点作用版：

void createAVPacketandInit() {AVPacket avpacket;cout << "debug point 0" << endl;av_init_packet(&avpacket);cout << "debug point 1" << endl;
}

av_packet_alloc 和 av_init_packet的区别是？

初始化的区别在于没有给size赋值。

我们再来回顾一下前面关于 这个 size是啥？

成员变量size：成员变量data指向的缓冲区的大小，单位为字节。

有啥用？ 在后面 av_packet_clone函数中就可以看到，如果这个size的值没有被赋值过，则clone的new avpacket 会失败，也就是返回nullptr。

 void av_packet_free(AVPacket **pkt);

/*** Free the packet, if the packet is reference counted, it will be* unreferenced first.** @param pkt packet to be freed. The pointer will be set to NULL.* @note passing NULL is a no-op.*/
void av_packet_free(AVPacket **pkt);

实现

从实现可以看到，这个不管是不ptk 是不是nullptr，都不会有错误

void av_packet_free(AVPacket **pkt)
{if (!pkt || !*pkt)return;av_packet_unref(*pkt);av_freep(pkt);
}

从这个方法来看，是将pkt的内部数据都释放了，并且给内部数据重新给了默认值

    av_packet_unref(*pkt);void av_packet_unref(AVPacket *pkt)
{av_packet_free_side_data(pkt);av_buffer_unref(&pkt->opaque_ref);av_buffer_unref(&pkt->buf);get_packet_defaults(pkt);
}

从 av_freep 方法来看，是 将 &pkt，的值赋值给&val，然后将&pkg赋值为null，最后再free &val。

为什么写的这么复杂呢？

直接free &pkt 不行吗？ 这个好处是啥呢？知道的童鞋可以回复一下，感谢！！！

void av_freep(void *arg)
{void *val;memcpy(&val, arg, sizeof(val));memcpy(arg, &(void *){ NULL }, sizeof(val));av_free(val);
}void av_free(void *ptr)
{
#if HAVE_ALIGNED_MALLOC_aligned_free(ptr);
#elsefree(ptr);
#endif
}

使用测试

void createAVpacketandFreeAVPacket() {AVPacket* avpacket = av_packet_alloc();if (avpacket == nullptr) {cout << "av_packet_alloc error" << endl;}cout << "debugpoint1" << endl;av_packet_free(&avpacket);cout << "debugpoint2" << endl;
}

AVPacket* av_packet_clone(const AVPacket* src);

This is a shortcut for av_packet_alloc()+av_packet_ref().

/*** Create a new packet that references the same data as src.** This is a shortcut for av_packet_alloc()+av_packet_ref().** @return newly created AVPacket on success, NULL on error.** @see av_packet_alloc* @see av_packet_ref*/
AVPacket* av_packet_clone(const AVPacket* src);

实现可以看到 ：是先 ret = av_packet_alloc,然后调用 (av_packet_ref(ret, src))，最后返回 新建的这个ret。

这里的关键是 av_packet_ref(AVPacket *dst, const AVPacket *src) 方法

AVPacket *av_packet_clone(const AVPacket *src)
{AVPacket *ret = av_packet_alloc();if (!ret)return ret;if (av_packet_ref(ret, src))av_packet_free(&ret);return ret;
}

int av_packet_ref(AVPacket *dst, const AVPacket *src)
{int ret;dst->buf = NULL;ret = av_packet_copy_props(dst, src);if (ret < 0)goto fail;if (!src->buf) {ret = packet_alloc(&dst->buf, src->size);if (ret < 0)goto fail;av_assert1(!src->size || src->data);if (src->size)memcpy(dst->buf->data, src->data, src->size);dst->data = dst->buf->data;} else {dst->buf = av_buffer_ref(src->buf);if (!dst->buf) {ret = AVERROR(ENOMEM);goto fail;}dst->data = src->data;}dst->size = src->size;return 0;
fail:av_packet_unref(dst);return ret;
}

实验测试1 ：如果在 src 是不是通过 av_packet_clone出来的，或者 没有通过 av_init_packet初始化过packet 的会有 runtime error

/***
* 
* 实验测试当 AVPacket 没有赋值的时候，使用 av_packet_clone会报error
***/
void avpacketclone() {AVPacket avpacket1 ;//实验测试当 AVPacket 没有赋值的时候，使用 av_packet_clone会报errorAVPacket* newavpacket = av_packet_clone(&avpacket1);if (newavpacket == nullptr) {cout << "newavpacket = nullptr" << endl;}cout << "debug point" << endl;
}

实验测试2：

* 实验测试当 AVPacket 在栈空间，且通过 av_init_packet初始化，
* 返回的newavpacket是nullptr
* root case 是 av_packet_ref(ret, src) ，packet_alloc(&dst->buf, src->size) ；src->size 的值是 < 0的，因此返回nullptr
 

/***
*
* 实验测试当 AVPacket 在栈空间，且通过 av_init_packet初始化，
* 返回的newavpacket是nullptr
* root case 是 av_packet_ref(ret, src) ，packet_alloc(&dst->buf, src->size) ；src->size 的值是 < 0的，因此返回nullptr
* 
***/
void avpacketclone1() {AVPacket avpacket1;//实验测试当 AVPacket 没有赋值的时候，使用 av_packet_clone会报errorav_init_packet(&avpacket1);//那么通过av_packet_alloc方法是否OK呢？AVPacket* newavpacket = av_packet_clone(&avpacket1);if (newavpacket == nullptr) {cout << "newavpacket = nullptr" << endl;}cout << "debug point" << endl;
}

实验测试3：

/// <summary>
/// 上述 通过 av_packet_clone方法 不是有 runtime exception就是 clone出来的newpacket为nullpptr
///  clone出来的newpacket 为nullptr 的root case 是 因为size 为一个默认值，很大的负数，没有被赋值为0或者其他值
/// 那我们下来手动的将这个 size这个值设置为 一个具体的数，行不行呢？
/// 如何设置这个值，我们查看 .h文件，发现有一个api说明比较像
/// int av_new_packet(AVPacket *pkt, int size);
/// 先来测试一下，我们再来研究这个 av_new_packet 函数
 

/// <summary>
/// 上述 通过 av_packet_clone方法 不是有 runtime exception就是 clone出来的newpacket为nullpptr
///  clone出来的newpacket 为nullptr 的root case 是 因为size 为一个默认值，很大的负数，没有被赋值为0或者其他值
/// 那我们下来手动的将这个 size这个值设置为 一个具体的数，行不行呢？
/// 如何设置这个值，我们查看 .h文件，发现有一个api说明比较像
/// int av_new_packet(AVPacket *pkt, int size);
/// 先来测试一下，我们再来研究这个 av_new_packet 函数
/// </summary>
void avpacketclone2() {AVPacket* avpacket = av_packet_alloc();int ret = 0;ret = av_new_packet(avpacket, 10);AVPacket* newavpacket = av_packet_clone(avpacket);if (newavpacket == nullptr) {cout << "newavpacket = nullptr" << endl;}cout << "debug point" << endl;
}

结论是：成功，且两个packet 的buf的指针是一样的。

int av_new_packet(AVPacket *pkt, int size); 

给pkt 赋初始值（这个赋初值包含size吗？包含且为0，在后面的源码中可以看到）；然后再给data 分配大小为size。

/*** Allocate the payload of a packet and initialize its fields with* default values.** @param pkt packet* @param size wanted payload size* @return 0 if OK, AVERROR_xxx otherwise*/
int av_new_packet(AVPacket *pkt, int size);

源码：

从代码中可以看到 apcket_alloc的时候，这个size就很关键了，size的大小决定了到底赋值还是不赋值
int av_new_packet(AVPacket *pkt, int size)
{AVBufferRef *buf = NULL;int ret = packet_alloc(&buf, size);if (ret < 0)return ret;get_packet_defaults(pkt);pkt->buf      = buf;pkt->data     = buf->data;pkt->size     = size;return 0;
}//即使size的值是符合预期的，分配的大小 还要加上一个 AV_INPUT_BUFFER_PADDING_SIZE（64）
//为啥要多弄出来一个64 呢？这是因为有些解码器，编码器为了算法优化，会有一些多余的buffer（这个buffer一般都是小于等于64的），因此ffmpeg在设计的时候，就多加了个64
static int packet_alloc(AVBufferRef **buf, int size)
{int ret;// 错误判断if (size < 0 || size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)return AVERROR(EINVAL);/// 真的分配空间ret = av_buffer_realloc(buf, size + AV_INPUT_BUFFER_PADDING_SIZE);if (ret < 0)return ret;
///清空空间memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);return 0;
}///这里看一下，ffmpeg中分配空间的方法
void *av_realloc(void *ptr, size_t size)
{
/// error判断void *ret;if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))return NULL;
/// HAVE_ALIGNED_MALLOC=1,因此代码会走到 _aligned_realloc这一行
#if HAVE_ALIGNED_MALLOCret = _aligned_realloc(ptr, size + !size, ALIGN);
#elseret = realloc(ptr, size + !size);
#endif
/// CONFIG_MEMORY_POISONING =0; 因此下面的代码不会走。
#if CONFIG_MEMORY_POISONINGif (ret && !ptr)memset(ret, FF_MEMORY_POISON, size);
#endifreturn ret;
}///_aligned_realloc 方法的详细说明
https://learn.microsoft.com/zh-cn/cpp/c-runtime-library/reference/aligned-realloc?view=msvc-170_aligned_realloc(ptr, size + !size, ALIGN);ALIGN是32
给ptr 分配 （size + !size）的大小 ，这个大小为啥是 （size + !size）为什么这么写呢？
在c语言中 !0 = 1, !1=0, 猜测ffmpeg的开发者 这么写是为了保证这个值最少是1，可能是为了某个bug，也可能是为了保证这个值的必须 >0.void * _aligned_realloc(void *memblock,size_t size,size_t alignment
);memblock
当前的内存块指针。size
请求的内存分配的大小。alignment
对齐值，必须是 2 的整数次幂。static void get_packet_defaults(AVPacket *pkt)
{memset(pkt, 0, sizeof(*pkt));pkt->pts             = AV_NOPTS_VALUE;pkt->dts             = AV_NOPTS_VALUE;pkt->pos             = -1;pkt->time_base       = av_make_q(0, 1);
}

在看完源码之后，能想到这个api使用的时机是什么吗？

猜测是我们知道了要传入的packet 的data 大小，可以提前设定这个大小？

void av_shrink_packet(AVPacket *pkt, int size);

成员变量data：

指针，指向“存放压缩后的一帧（对于视频通常包含一个压缩帧，对于音频可能包含几个压缩帧）音视频数据的缓冲区”。

成员变量size：

成员变量data指向的缓冲区的大小，单位为字节。

shrink 是收缩，缩小的意思，从字面意思来是，是将pkt data 的size 变成现在的值。

将当前pkt 中的 data的大小变成size，如果当前pkt->size本身就比要设置的size小，则直接return，

例如原先pkt->size的值是8，user 想要改成,16，那就不变还是8

例如原先pkt->size的值是8，user 想要改成6，那么就会变成6.

然后还会将 pkt->data + size 后的 AV_INPUT_BUFFER_PADDING_SIZE大小的空间清零

这也很好理解，size 变化了，本身就在size后面多加了AV_INPUT_BUFFER_PADDING_SIZE，要保证 AV_INPUT_BUFFER_PADDING_SIZE 这段空间是清零的。

/*** Reduce packet size, correctly zeroing padding** @param pkt packet* @param size new size*/
void av_shrink_packet(AVPacket *pkt, int size);

实现

void av_shrink_packet(AVPacket *pkt, int size)
{if (pkt->size <= size)return;pkt->size = size;memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
}

问题是：在哪里使用呢？什么时机使用呢？

int av_grow_packet(AVPacket* pkt, int grow_by);

增加数据包大小，正确归零填充

/*** Increase packet size, correctly zeroing padding** @param pkt packet* @param grow_by number of bytes by which to increase the size of the packet*/
int av_grow_packet(AVPacket *pkt, int grow_by);

实现：

从实现来看，

增加数据包（pkt->data指向的缓冲区）的大小，让该大小增至（pkt->size + grow_by）字节。让地址为（pkt->data + pkt->size + grow_by）后的数据字节归零。执行该函数后，pkt->size会增至（pkt->size + grow_by）字节。返回0表示成功，返回负数表示失败。

int av_grow_packet(AVPacket *pkt, int grow_by)
{int new_size;av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);if ((unsigned)grow_by >INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))return AVERROR(ENOMEM);new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;if (pkt->buf) {size_t data_offset;uint8_t *old_data = pkt->data;if (pkt->data == NULL) {data_offset = 0;pkt->data = pkt->buf->data;} else {data_offset = pkt->data - pkt->buf->data;if (data_offset > INT_MAX - new_size)return AVERROR(ENOMEM);}if (new_size + data_offset > pkt->buf->size ||!av_buffer_is_writable(pkt->buf)) {int ret;// allocate slightly more than requested to avoid excessive// reallocationsif (new_size + data_offset < INT_MAX - new_size/16)new_size += new_size/16;ret = av_buffer_realloc(&pkt->buf, new_size + data_offset);if (ret < 0) {pkt->data = old_data;return ret;}pkt->data = pkt->buf->data + data_offset;}} else {pkt->buf = av_buffer_alloc(new_size);if (!pkt->buf)return AVERROR(ENOMEM);if (pkt->size > 0)memcpy(pkt->buf->data, pkt->data, pkt->size);pkt->data = pkt->buf->data;}pkt->size += grow_by;memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);return 0;
}

int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)

使用已经分配好的buffer初始化一个AVPacket，会设置AVPacket的data和size成员。传入的size参数是减去了AV_INPUT_BUFFER_PADDING_SIZE的，也就是size + AV_INPUT_BUFFER_PADDING_SIZE等于buffer总的大小。

代码实现，从实现上来看，会将 pkt->data指向传进来的data，大小为size，注意的 pkt的data 赋值并没有 copy，而是直接将指针赋值给了pkt的data，也就是说，在pkt 的data没有使用的时候，不要释放data空间，释放了意味着pkt的data也就变化了 ；；如果覆盖了传递进来的data空间，也意味着pkt的data的内容变化了。

/*** Initialize a reference-counted packet from av_malloc()ed data.** @param pkt packet to be initialized. This function will set the data, size,*        and buf fields, all others are left untouched.* @param data Data allocated by av_malloc() to be used as packet data. If this*        function returns successfully, the data is owned by the underlying AVBuffer.*        The caller may not access the data through other means.* @param size size of data in bytes, without the padding. I.e. the full buffer*        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.** @return 0 on success, a negative AVERROR on error*/
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);

int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
{if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)return AVERROR(EINVAL);pkt->buf = av_buffer_create(data, size + AV_INPUT_BUFFER_PADDING_SIZE,av_buffer_default_free, NULL, 0);if (!pkt->buf)return AVERROR(ENOMEM);pkt->data = data;pkt->size = size;return 0;
}

int av_buffer_get_ref_count(const AVBufferRef *buf);

得到avpacket或者 avframe的 引用计数

int av_buffer_get_ref_count(const AVBufferRef *buf)
{return atomic_load(&buf->buffer->refcount);
}

    cout<<av_buffer_get_ref_count(avpacket->buf)<<endl;

    cout<<av_buffer_get_ref_count(avframe->buf)<<endl;

uint8_t* av_packet_new_side_data(AVPacket* pkt, enum AVPacketSideDataType type, size_t size);

返回值是要存储的 size_data的指针。

AVPacket->side_data是AVPacket携带的side数据数组，AVPacket->side_data_elems是数组的长度。av_packet_new_side_data和av_packet_add_side_data函数都提供了向AVPacket添加指定类型side data的能力，只是参数略有差异,每次都会把新side data添加到数组的尾部。 av_packet_get_side_data函数提供了从AVPacket获取指定类型side data的能力。

/*** Allocate new information of a packet.** @param pkt packet* @param type side information type* @param size side information size* @return pointer to fresh allocated data or NULL otherwise*/
uint8_t* av_packet_new_side_data(AVPacket* pkt, enum AVPacketSideDataType type,size_t size);

uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,size_t size)
{int ret;uint8_t *data;if (size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE)return NULL;data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);if (!data)return NULL;ret = av_packet_add_side_data(pkt, type, data, size);if (ret < 0) {av_freep(&data);return NULL;}return data;
}

int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size);

/*** Wrap an existing array as a packet side data.** @param pkt packet* @param type side information type* @param data the side data array. It must be allocated with the av_malloc()*             family of functions. The ownership of the data is transferred to*             pkt.* @param size side information size* @return a non-negative number on success, a negative AVERROR code on*         failure. On failure, the packet is unchanged and the data remains*         owned by the caller.*/
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,uint8_t *data, size_t size);

int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,uint8_t *data, size_t size)
{AVPacketSideData *tmp;int i, elems = pkt->side_data_elems;for (i = 0; i < elems; i++) {AVPacketSideData *sd = &pkt->side_data[i];if (sd->type == type) {av_free(sd->data);sd->data = data;sd->size = size;return 0;}}if ((unsigned)elems + 1 > AV_PKT_DATA_NB)return AVERROR(ERANGE);tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));if (!tmp)return AVERROR(ENOMEM);pkt->side_data = tmp;pkt->side_data[elems].data = data;pkt->side_data[elems].size = size;pkt->side_data[elems].type = type;pkt->side_data_elems++;return 0;
}

参考ffmpeg源码中的一些使用。

如下的例子都是ffmpeg在编码的时候用到，再回看关于 字段size_data的说明： 存放“容器可以提供的额外数据包数据”的数组的首地址。数据包可以包含多种类型的边信息，比如，在编码结束的时候更新一些流的参数。指针side_data指向的空间存储了用于解码、展现或处理编码流的辅助信息，它通常由解复用器和编码器导出，可以以分组为单位提供给解码器和复用器，也可以作为全局侧数据(应用于整个编码流)。

flac.enc中的使用

static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,const AVFrame *frame, int *got_packet_ptr)
{FlacEncodeContext *s;int frame_bytes, out_bytes, ret;s = avctx->priv_data;/* when the last block is reached, update the header in extradata */if (!frame) {s->max_framesize = s->max_encoded_framesize;av_md5_final(s->md5ctx, s->md5sum);write_streaminfo(s, avctx->extradata);if (!s->flushed) {uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,avctx->extradata_size);if (!side_data)return AVERROR(ENOMEM);memcpy(side_data, avctx->extradata, avctx->extradata_size);avpkt->pts = s->next_pts;*got_packet_ptr = 1;s->flushed = 1;}return 0;}

从img2dec.c中看到

要结合 av_packet_pack_dictionary方法使用

static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt) {AVDictionary *d = NULL;char *packed_metadata = NULL;size_t metadata_len;int ret;av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);av_dict_set(&d, "lavf.image2dec.source_basename", av_basename(filename), 0);packed_metadata = av_packet_pack_dictionary(d, &metadata_len);av_dict_free(&d);if (!packed_metadata)return AVERROR(ENOMEM);ret = av_packet_add_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA,packed_metadata, metadata_len);if (ret < 0) {av_freep(&packed_metadata);return ret;}return 0;
}

总结一下：一般这玩意在 特定的编码器的时候使用，表明我们要给avpacket中添加一些特殊的信息，信息的类型由 AVPacketSideDataType 决定，那么 AVPacketSideDataType 有哪些？这些翻译出来也不知道真正的意思是啥，应该是对于 每一种特殊的编码学习的时候，会用到这个，我们假设mp4编码器有特殊的值，那么就在这个 AVPacketSideDataType 里面找。

size_t size ： 应该是 要设置的AVPacket->side_data的大小。在实际开发中遇到后，应该多测试，看是否要减去这个 AV_INPUT_BUFFER_PADDING_SIZE

uint8_t* av_packet_get_side_data(const AVPacket* pkt, enum AVPacketSideDataType type, size_t* size);

这个看起来就在解码的时候用到，得到avpacket中存储的值

/*** Get side information from packet.** @param pkt packet* @param type desired side information type* @param size If supplied, *size will be set to the size of the side data*             or to zero if the desired side data is not present.* @return pointer to data if present or NULL otherwise*/
uint8_t* av_packet_get_side_data(const AVPacket* pkt, enum AVPacketSideDataType type,size_t* size);

源码实现

uint8_t *av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,size_t *size)
{int i;for (i = 0; i < pkt->side_data_elems; i++) {if (pkt->side_data[i].type == type) {if (size)*size = pkt->side_data[i].size;return pkt->side_data[i].data;}}if (size)*size = 0;return NULL;
}

源码中的使用

static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict,int *got_frame, AVPacket *avpkt)
{const uint8_t *buf = avpkt->data;int buf_size       = avpkt->size;H264Context *h     = avctx->priv_data;int buf_index;int ret;h->flags = avctx->flags;h->setup_finished = 0;h->nb_slice_ctx_queued = 0;ff_h264_unref_picture(h, &h->last_pic_for_ec);/* end of stream, output what is still in the buffers */if (buf_size == 0)return send_next_delayed_frame(h, pict, got_frame, 0);if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {size_t side_size;uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);ff_h264_decode_extradata(side, side_size,&h->ps, &h->is_avc, &h->nal_length_size,avctx->err_recognition, avctx);}if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {if (is_avcc_extradata(buf, buf_size))return ff_h264_decode_extradata(buf, buf_size,&h->ps, &h->is_avc, &h->nal_length_size,avctx->err_recognition, avctx);}buf_index = decode_nal_units(h, buf, buf_size);if (buf_index < 0)return AVERROR_INVALIDDATA;if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {av_assert0(buf_index <= buf_size);return send_next_delayed_frame(h, pict, got_frame, buf_index);}if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {if (avctx->skip_frame >= AVDISCARD_NONREF ||buf_size >= 4 && !memcmp("Q264", buf, 4))return buf_size;av_log(avctx, AV_LOG_ERROR, "no frame!\n");return AVERROR_INVALIDDATA;}if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||(h->mb_y >= h->mb_height && h->mb_height)) {if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)return ret;/* Wait for second field. */if (h->next_output_pic) {ret = finalize_frame(h, pict, h->next_output_pic, got_frame);if (ret < 0)return ret;}}av_assert0(pict->buf[0] || !*got_frame);ff_h264_unref_picture(h, &h->last_pic_for_ec);return get_consumed_bytes(buf_index, buf_size);
}

int av_packet_shrink_side_data(AVPacket* pkt, enum AVPacketSideDataType type, size_t size);

/*** Shrink the already allocated side data buffer** @param pkt packet* @param type side information type* @param size new side information size* @return 0 on success, < 0 on failure*/
int av_packet_shrink_side_data(AVPacket* pkt, enum AVPacketSideDataType type,size_t size);

源码

int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,size_t size)
{int i;for (i = 0; i < pkt->side_data_elems; i++) {if (pkt->side_data[i].type == type) {if (size > pkt->side_data[i].size)return AVERROR(ENOMEM);pkt->side_data[i].size = size;return 0;}}return AVERROR(ENOENT);
}

使用，看到只有在mpegvideo_enc.c中有使用，应该和上述的 av_packet_new_side_data和 av_packet_add_side_data 相关，

int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,const AVFrame *pic_arg, int *got_packet)
{MpegEncContext *s = avctx->priv_data;int i, stuffing_count, ret;int context_count = s->slice_context_count;s->vbv_ignore_qmax = 0;s->picture_in_gop_number++;if (load_input_picture(s, pic_arg) < 0)return -1;if (select_input_picture(s) < 0) {return -1;}/* output? */if (s->new_picture->data[0]) {int growing_buffer = context_count == 1 && !s->data_partitioning;size_t pkt_size = 10000 + s->mb_width * s->mb_height *(growing_buffer ? 64 : (MAX_MB_BYTES + 100));if (CONFIG_MJPEG_ENCODER && avctx->codec_id == AV_CODEC_ID_MJPEG) {ret = ff_mjpeg_add_icc_profile_size(avctx, s->new_picture, &pkt_size);if (ret < 0)return ret;}if ((ret = ff_alloc_packet(avctx, pkt, pkt_size)) < 0)return ret;pkt->size = avctx->internal->byte_buffer_size - AV_INPUT_BUFFER_PADDING_SIZE;if (s->mb_info) {s->mb_info_ptr = av_packet_new_side_data(pkt,AV_PKT_DATA_H263_MB_INFO,s->mb_width*s->mb_height*12);s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;}for (i = 0; i < context_count; i++) {int start_y = s->thread_context[i]->start_mb_y;int   end_y = s->thread_context[i]->  end_mb_y;int h       = s->mb_height;uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);init_put_bits(&s->thread_context[i]->pb, start, end - start);}s->pict_type = s->new_picture->pict_type;//emms_c();ret = frame_start(s);if (ret < 0)return ret;
vbv_retry:ret = encode_picture(s);if (growing_buffer) {av_assert0(s->pb.buf == avctx->internal->byte_buffer);pkt->data = s->pb.buf;pkt->size = avctx->internal->byte_buffer_size;}if (ret < 0)return -1;frame_end(s);if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) && s->out_format == FMT_MJPEG)ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);if (avctx->rc_buffer_size) {RateControlContext *rcc = &s->rc_context;int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;if (put_bits_count(&s->pb) > max_size &&s->lambda < s->lmax) {s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *(s->qscale + 1) / s->qscale);if (s->adaptive_quant) {int i;for (i = 0; i < s->mb_height * s->mb_stride; i++)s->lambda_table[i] =FFMAX(s->lambda_table[i] + min_step,s->lambda_table[i] * (s->qscale + 1) /s->qscale);}s->mb_skipped = 0;        // done in frame_start()// done in encode_picture() so we must undo itif (s->pict_type == AV_PICTURE_TYPE_P) {if (s->flipflop_rounding          ||s->codec_id == AV_CODEC_ID_H263P ||s->codec_id == AV_CODEC_ID_MPEG4)s->no_rounding ^= 1;}if (s->pict_type != AV_PICTURE_TYPE_B) {s->time_base       = s->last_time_base;s->last_non_b_time = s->time - s->pp_time;}for (i = 0; i < context_count; i++) {PutBitContext *pb = &s->thread_context[i]->pb;init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);}s->vbv_ignore_qmax = 1;av_log(avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");goto vbv_retry;}av_assert0(avctx->rc_max_rate);}if (avctx->flags & AV_CODEC_FLAG_PASS1)ff_write_pass1_stats(s);for (i = 0; i < 4; i++) {avctx->error[i] += s->encoding_error[i];}ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,s->encoding_error,(avctx->flags&AV_CODEC_FLAG_PSNR) ? MPEGVIDEO_MAX_PLANES : 0,s->pict_type);if (avctx->flags & AV_CODEC_FLAG_PASS1)assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +s->misc_bits + s->i_tex_bits +s->p_tex_bits);flush_put_bits(&s->pb);s->frame_bits  = put_bits_count(&s->pb);stuffing_count = ff_vbv_update(s, s->frame_bits);s->stuffing_bits = 8*stuffing_count;if (stuffing_count) {if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");return -1;}switch (s->codec_id) {case AV_CODEC_ID_MPEG1VIDEO:case AV_CODEC_ID_MPEG2VIDEO:while (stuffing_count--) {put_bits(&s->pb, 8, 0);}break;case AV_CODEC_ID_MPEG4:put_bits(&s->pb, 16, 0);put_bits(&s->pb, 16, 0x1C3);stuffing_count -= 4;while (stuffing_count--) {put_bits(&s->pb, 8, 0xFF);}break;default:av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");s->stuffing_bits = 0;}flush_put_bits(&s->pb);s->frame_bits  = put_bits_count(&s->pb);}/* update MPEG-1/2 vbv_delay for CBR */if (avctx->rc_max_rate                          &&avctx->rc_min_rate == avctx->rc_max_rate &&s->out_format == FMT_MPEG1                     &&90000LL * (avctx->rc_buffer_size - 1) <=avctx->rc_max_rate * 0xFFFFLL) {AVCPBProperties *props;size_t props_size;int vbv_delay, min_delay;double inbits  = avctx->rc_max_rate *av_q2d(avctx->time_base);int    minbits = s->frame_bits - 8 *(s->vbv_delay_pos - 1);double bits    = s->rc_context.buffer_index + minbits - inbits;uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;if (bits < 0)av_log(avctx, AV_LOG_ERROR,"Internal error, negative bits\n");av_assert1(s->repeat_first_field == 0);vbv_delay = bits * 90000 / avctx->rc_max_rate;min_delay = (minbits * 90000LL + avctx->rc_max_rate - 1) /avctx->rc_max_rate;vbv_delay = FFMAX(vbv_delay, min_delay);av_assert0(vbv_delay < 0xFFFF);vbv_delay_ptr[0] &= 0xF8;vbv_delay_ptr[0] |= vbv_delay >> 13;vbv_delay_ptr[1]  = vbv_delay >> 5;vbv_delay_ptr[2] &= 0x07;vbv_delay_ptr[2] |= vbv_delay << 3;props = av_cpb_properties_alloc(&props_size);if (!props)return AVERROR(ENOMEM);props->vbv_delay = vbv_delay * 300;ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,(uint8_t*)props, props_size);if (ret < 0) {av_freep(&props);return ret;}}s->total_bits     += s->frame_bits;pkt->pts = s->current_picture.f->pts;pkt->duration = s->current_picture.f->duration;if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {if (!s->current_picture.coded_picture_number)pkt->dts = pkt->pts - s->dts_delta;elsepkt->dts = s->reordered_pts;s->reordered_pts = pkt->pts;} elsepkt->dts = pkt->pts;// the no-delay case is handled in generic codeif (avctx->codec->capabilities & AV_CODEC_CAP_DELAY) {ret = ff_encode_reordered_opaque(avctx, pkt, s->current_picture.f);if (ret < 0)return ret;}if (s->current_picture.f->key_frame)pkt->flags |= AV_PKT_FLAG_KEY;if (s->mb_info)av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);} else {s->frame_bits = 0;}/* release non-reference frames */for (i = 0; i < MAX_PICTURE_COUNT; i++) {if (!s->picture[i].reference)ff_mpeg_unref_picture(avctx, &s->picture[i]);}av_assert1((s->frame_bits & 7) == 0);pkt->size = s->frame_bits / 8;*got_packet = !!pkt->size;return 0;
}

const char *av_packet_side_data_name(enum AVPacketSideDataType type);

const char *av_packet_side_data_name(enum AVPacketSideDataType type);

实现：

const char *av_packet_side_data_name(enum AVPacketSideDataType type)
{switch(type) {case AV_PKT_DATA_PALETTE:                    return "Palette";case AV_PKT_DATA_NEW_EXTRADATA:              return "New Extradata";case AV_PKT_DATA_PARAM_CHANGE:               return "Param Change";case AV_PKT_DATA_H263_MB_INFO:               return "H263 MB Info";case AV_PKT_DATA_REPLAYGAIN:                 return "Replay Gain";case AV_PKT_DATA_DISPLAYMATRIX:              return "Display Matrix";case AV_PKT_DATA_STEREO3D:                   return "Stereo 3D";case AV_PKT_DATA_AUDIO_SERVICE_TYPE:         return "Audio Service Type";case AV_PKT_DATA_QUALITY_STATS:              return "Quality stats";case AV_PKT_DATA_FALLBACK_TRACK:             return "Fallback track";case AV_PKT_DATA_CPB_PROPERTIES:             return "CPB properties";case AV_PKT_DATA_SKIP_SAMPLES:               return "Skip Samples";case AV_PKT_DATA_JP_DUALMONO:                return "JP Dual Mono";case AV_PKT_DATA_STRINGS_METADATA:           return "Strings Metadata";case AV_PKT_DATA_SUBTITLE_POSITION:          return "Subtitle Position";case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL:   return "Matroska BlockAdditional";case AV_PKT_DATA_WEBVTT_IDENTIFIER:          return "WebVTT ID";case AV_PKT_DATA_WEBVTT_SETTINGS:            return "WebVTT Settings";case AV_PKT_DATA_METADATA_UPDATE:            return "Metadata Update";case AV_PKT_DATA_MPEGTS_STREAM_ID:           return "MPEGTS Stream ID";case AV_PKT_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:        return "Content light level metadata";case AV_PKT_DATA_SPHERICAL:                  return "Spherical Mapping";case AV_PKT_DATA_A53_CC:                     return "A53 Closed Captions";case AV_PKT_DATA_ENCRYPTION_INIT_INFO:       return "Encryption initialization data";case AV_PKT_DATA_ENCRYPTION_INFO:            return "Encryption info";case AV_PKT_DATA_AFD:                        return "Active Format Description data";case AV_PKT_DATA_PRFT:                       return "Producer Reference Time";case AV_PKT_DATA_ICC_PROFILE:                return "ICC Profile";case AV_PKT_DATA_DOVI_CONF:                  return "DOVI configuration record";case AV_PKT_DATA_S12M_TIMECODE:              return "SMPTE ST 12-1:2014 timecode";case AV_PKT_DATA_DYNAMIC_HDR10_PLUS:         return "HDR10+ Dynamic Metadata (SMPTE 2094-40)";}return NULL;
}

uint8_t* av_packet_pack_dictionary(AVDictionary* dict, size_t* size);

将AVDictioary中的数据放到一整块内存并返回；

返回值是 avpacket->data_side_data 的指针。

实际开发中 需要再给返回值 copy 数据才算完成

/*** Pack a dictionary for use in side_data.** @param dict The dictionary to pack.* @param size pointer to store the size of the returned data* @return pointer to data if successful, NULL otherwise*/
uint8_t* av_packet_pack_dictionary(AVDictionary* dict, size_t* size);

源码实现

uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
{uint8_t *data = NULL;*size = 0;if (!dict)return NULL;for (int pass = 0; pass < 2; pass++) {const AVDictionaryEntry *t = NULL;size_t total_length = 0;while ((t = av_dict_iterate(dict, t))) {for (int i = 0; i < 2; i++) {const char  *str = i ? t->value : t->key;const size_t len = strlen(str) + 1;if (pass)memcpy(data + total_length, str, len);else if (len > SIZE_MAX - total_length)return NULL;total_length += len;}}if (pass)break;data = av_malloc(total_length);if (!data)return NULL;*size = total_length;}return data;
}

参考 av_packet_add_side_data 中例子。

int av_packet_unpack_dictionary(const uint8_t* data, size_t size,
    AVDictionary** dict);

从一整块数据中解析出一个AVDictionary；

实际上主要是给 dict 中传递数据解析 AVDictionary中 。

/*** Unpack a dictionary from side_data.** @param data data from side_data* @param size size of the data* @param dict the metadata storage dictionary* @return 0 on success, < 0 on failure*/
int av_packet_unpack_dictionary(const uint8_t* data, size_t size,AVDictionary** dict);

int av_packet_unpack_dictionary(const uint8_t *data, size_t size,AVDictionary **dict)
{const uint8_t *end;int ret;if (!dict || !data || !size)return 0;end = data + size;if (size && end[-1])return AVERROR_INVALIDDATA;while (data < end) {const uint8_t *key = data;const uint8_t *val = data + strlen(key) + 1;if (val >= end || !*key)return AVERROR_INVALIDDATA;ret = av_dict_set(dict, key, val, 0);if (ret < 0)return ret;data = val + strlen(val) + 1;}return 0;
}

void av_packet_free_side_data(AVPacket* pkt);

/*** Convenience function to free all the side data stored.* All the other fields stay untouched.** @param pkt packet*/
void av_packet_free_side_data(AVPacket* pkt);

实现

void av_packet_free_side_data(AVPacket *pkt)
{int i;for (i = 0; i < pkt->side_data_elems; i++)av_freep(&pkt->side_data[i].data);av_freep(&pkt->side_data);pkt->side_data_elems = 0;
}

int av_packet_ref(AVPacket* dst, const AVPacket* src);

引用计数加一

/*** Setup a new reference to the data described by a given packet** If src is reference-counted, setup dst as a new reference to the* buffer in src. Otherwise allocate a new buffer in dst and copy the* data from src into it.** All the other fields are copied from src.** @see av_packet_unref** @param dst Destination packet. Will be completely overwritten.* @param src Source packet** @return 0 on success, a negative AVERROR on error. On error, dst*         will be blank (as if returned by av_packet_alloc()).*/
int av_packet_ref(AVPacket* dst, const AVPacket* src);

源码

int av_packet_ref(AVPacket *dst, const AVPacket *src)
{int ret;dst->buf = NULL;ret = av_packet_copy_props(dst, src);if (ret < 0)goto fail;if (!src->buf) {ret = packet_alloc(&dst->buf, src->size);if (ret < 0)goto fail;av_assert1(!src->size || src->data);if (src->size)memcpy(dst->buf->data, src->data, src->size);dst->data = dst->buf->data;} else {dst->buf = av_buffer_ref(src->buf);if (!dst->buf) {ret = AVERROR(ENOMEM);goto fail;}dst->data = src->data;}dst->size = src->size;return 0;
fail:av_packet_unref(dst);return ret;
}

void av_packet_unref(AVPacket* pkt);

引用计数减一

/*** Wipe the packet.** Unreference the buffer referenced by the packet and reset the* remaining packet fields to their default values.** @param pkt The packet to be unreferenced.*/
void av_packet_unref(AVPacket* pkt);

void av_packet_unref(AVPacket *pkt)
{av_packet_free_side_data(pkt);av_buffer_unref(&pkt->opaque_ref);av_buffer_unref(&pkt->buf);get_packet_defaults(pkt);
}

void av_packet_move_ref(AVPacket* dst, AVPacket* src);

引用计数不变，将src 的所有东西都转移给dst，然后将src 的值都恢复成默认值

那么move 之后，src就不能使用了

/*** Move every field in src to dst and reset src.** @see av_packet_unref** @param src Source packet, will be reset* @param dst Destination packet*/
void av_packet_move_ref(AVPacket* dst, AVPacket* src);

void av_packet_move_ref(AVPacket *dst, AVPacket *src)
{*dst = *src;get_packet_defaults(src);
}

int av_packet_copy_props(AVPacket *dst, const AVPacket *src);

将src 中 "properties" 的字段拷贝给 dst，那么哪些属于是 "properties"呢？---》参考源码

/*** Copy only "properties" fields from src to dst.** Properties for the purpose of this function are all the fields* beside those related to the packet data (buf, data, size)** @param dst Destination packet* @param src Source packet** @return 0 on success AVERROR on failure.*/
int av_packet_copy_props(AVPacket *dst, const AVPacket *src);

实现：

int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
{int i, ret;dst->pts                  = src->pts;dst->dts                  = src->dts;dst->pos                  = src->pos;dst->duration             = src->duration;dst->flags                = src->flags;dst->stream_index         = src->stream_index;dst->opaque               = src->opaque;dst->time_base            = src->time_base;dst->opaque_ref           = NULL;dst->side_data            = NULL;dst->side_data_elems      = 0;ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);if (ret < 0)return ret;for (i = 0; i < src->side_data_elems; i++) {enum AVPacketSideDataType type = src->side_data[i].type;size_t size = src->side_data[i].size;uint8_t *src_data = src->side_data[i].data;uint8_t *dst_data = av_packet_new_side_data(dst, type, size);if (!dst_data) {av_buffer_unref(&dst->opaque_ref);av_packet_free_side_data(dst);return AVERROR(ENOMEM);}memcpy(dst_data, src_data, size);}return 0;
}

 int av_packet_make_writable(AVPacket *pkt);

从实现来看：如果传递的参数pkt  的 字段 ------ AVBufferRef *buf 不为null 且是可以写的，则直接返回0. AVPacket是否可写：对应的flags 非AV_BUFFER_FLAG_READONLY

如果buf 是null 或者不可写，则重新 alloc buf，并且传递给 pkt，总的来说，这个函数就是让 你传进来的pkt 的 buf字段变成可写的，将引用计数变为1

/*** Create a writable reference for the data described by a given packet,* avoiding data copy if possible.** @param pkt Packet whose data should be made writable.** @return 0 on success, a negative AVERROR on failure. On failure, the*         packet is unchanged.*/
int av_packet_make_writable(AVPacket *pkt);

实现

int av_packet_make_writable(AVPacket *pkt)
{AVBufferRef *buf = NULL;int ret;if (pkt->buf && av_buffer_is_writable(pkt->buf))return 0;ret = packet_alloc(&buf, pkt->size);if (ret < 0)return ret;av_assert1(!pkt->size || pkt->data);if (pkt->size)memcpy(buf->data, pkt->data, pkt->size);av_buffer_unref(&pkt->buf);pkt->buf  = buf;pkt->data = buf->data;return 0;
}

 

int av_packet_make_refcounted(AVPacket* pkt);

如果没有buf字段为null，则根据size 重新create buf，并将这个buf赋值给pkt的字段，最后将将引用计数变为1

/*** Ensure the data described by a given packet is reference counted.** @note This function does not ensure that the reference will be writable.*       Use av_packet_make_writable instead for that purpose.** @see av_packet_ref* @see av_packet_make_writable** @param pkt packet whose data should be made reference counted.** @return 0 on success, a negative AVERROR on error. On failure, the*         packet is unchanged.*/
int av_packet_make_refcounted(AVPacket* pkt);

int av_packet_make_refcounted(AVPacket *pkt)
{int ret;if (pkt->buf)return 0;ret = packet_alloc(&pkt->buf, pkt->size);if (ret < 0)return ret;av_assert1(!pkt->size || pkt->data);if (pkt->size)memcpy(pkt->buf->data, pkt->data, pkt->size);pkt->data = pkt->buf->data;return 0;
}

void av_packet_rescale_ts(AVPacket* pkt, AVRational tb_src, AVRational tb_dst);

/*** Convert valid timing fields (timestamps / durations) in a packet from one* timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be* ignored.** @param pkt packet on which the conversion will be performed* @param tb_src source timebase, in which the timing fields in pkt are*               expressed* @param tb_dst destination timebase, to which the timing fields will be*               converted*/
void av_packet_rescale_ts(AVPacket* pkt, AVRational tb_src, AVRational tb_dst);

实现：

void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
{if (pkt->pts != AV_NOPTS_VALUE)pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);if (pkt->dts != AV_NOPTS_VALUE)pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);if (pkt->duration > 0)pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
}

 参考

从零到一学FFmpeg：av_packet_rescale_ts 函数详析与实战_avpacket 时间戳-CSDN博客

av_packet_rescale_ts是FFmpeg库中的一个函数，用于重新缩放或转换媒体流中的时间戳（timestamp），以适配不同的时间基（timebase）。
在处理多媒体数据时，特别是当数据在不同组件间传递，或者在编码、解码、转封装等操作中，时间戳经常需要调整以匹配当前上下文的时间基。

参数说明

pkt: 指向AVPacket结构体的指针，该结构体包含了要调整时间戳的媒体数据包。
tb_src: 原始时间基，即pkt中时间戳所依据的时间基。
    通常，这来自于数据包来源的AVStream的time_base。
tb_dst: 目标时间基，即你想将时间戳转换到的时间基。
    这通常与你打算将数据包发送到的目标组件（如解码器、输出格式上下文等）的时间基相匹配。

二、功能描述
时间戳转换: 该函数通过计算两个时间基之间的比例，对AVPacket中的pts(显示时间戳)和dts(解码时间戳)进行相应的缩放。这对于确保媒体处理管道中各环节的时间戳一致性至关重要。

同步与播放: 时间戳的正确调整对于视频和音频的同步播放非常重要，尤其是在涉及不同速率或格式转换的场景下。

三、使用实例
仅调整时间戳，不对数据包内的数据进行任何修改。
确保tb_src和tb_dst都是有效的AVRational结构体，避免除以零的错误。
在进行解复用、编码、解码或复用等操作前后，通常需要调用此函数来适配不同的时间基需求。

AVPacket pkt;
// 假设pkt是从某个输入流中获取的，已带有基于该流时间基的时间戳
AVRational in_timebase = (AVRational){1, 25}; // 假设输入时间基为25fps
AVRational out_timebase = (AVRational){1, 1000}; // 假设目标时间基为毫秒单位// 调整时间戳
av_packet_rescale_ts(&pkt, in_timebase, out_timebase);// 现在pkt的时间戳已转换为目标时间基，可以安全地用于输出或进一步处理