1/*
2 * AVPacket public API
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#ifndef AVCODEC_PACKET_H
22#define AVCODEC_PACKET_H
23
24#include <stddef.h>
25#include <stdint.h>
26
27#include "libavutil/attributes.h"
28#include "libavutil/buffer.h"
29#include "libavutil/dict.h"
30#include "libavutil/rational.h"
31
32#include "libavcodec/version.h"
33
34/**
35 * @defgroup lavc_packet AVPacket
36 *
37 * Types and functions for working with AVPacket.
38 * @{
39 */
40enum AVPacketSideDataType {
41 /**
42 * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
43 * bytes worth of palette. This side data signals that a new palette is
44 * present.
45 */
46 AV_PKT_DATA_PALETTE,
47
48 /**
49 * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
50 * that the extradata buffer was changed and the receiving side should
51 * act upon it appropriately. The new extradata is embedded in the side
52 * data buffer and should be immediately used for processing the current
53 * frame or packet.
54 */
55 AV_PKT_DATA_NEW_EXTRADATA,
56
57 /**
58 * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
59 * @code
60 * u32le param_flags
61 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
62 * s32le channel_count
63 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
64 * u64le channel_layout
65 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
66 * s32le sample_rate
67 * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
68 * s32le width
69 * s32le height
70 * @endcode
71 */
72 AV_PKT_DATA_PARAM_CHANGE,
73
74 /**
75 * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
76 * structures with info about macroblocks relevant to splitting the
77 * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
78 * That is, it does not necessarily contain info about all macroblocks,
79 * as long as the distance between macroblocks in the info is smaller
80 * than the target payload size.
81 * Each MB info structure is 12 bytes, and is laid out as follows:
82 * @code
83 * u32le bit offset from the start of the packet
84 * u8 current quantizer at the start of the macroblock
85 * u8 GOB number
86 * u16le macroblock address within the GOB
87 * u8 horizontal MV predictor
88 * u8 vertical MV predictor
89 * u8 horizontal MV predictor for block number 3
90 * u8 vertical MV predictor for block number 3
91 * @endcode
92 */
93 AV_PKT_DATA_H263_MB_INFO,
94
95 /**
96 * This side data should be associated with an audio stream and contains
97 * ReplayGain information in form of the AVReplayGain struct.
98 */
99 AV_PKT_DATA_REPLAYGAIN,
100
101 /**
102 * This side data contains a 3x3 transformation matrix describing an affine
103 * transformation that needs to be applied to the decoded video frames for
104 * correct presentation.
105 *
106 * See libavutil/display.h for a detailed description of the data.
107 */
108 AV_PKT_DATA_DISPLAYMATRIX,
109
110 /**
111 * This side data should be associated with a video stream and contains
112 * Stereoscopic 3D information in form of the AVStereo3D struct.
113 */
114 AV_PKT_DATA_STEREO3D,
115
116 /**
117 * This side data should be associated with an audio stream and corresponds
118 * to enum AVAudioServiceType.
119 */
120 AV_PKT_DATA_AUDIO_SERVICE_TYPE,
121
122 /**
123 * This side data contains quality related information from the encoder.
124 * @code
125 * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
126 * u8 picture type
127 * u8 error count
128 * u16 reserved
129 * u64le[error count] sum of squared differences between encoder in and output
130 * @endcode
131 */
132 AV_PKT_DATA_QUALITY_STATS,
133
134 /**
135 * This side data contains an integer value representing the stream index
136 * of a "fallback" track. A fallback track indicates an alternate
137 * track to use when the current track can not be decoded for some reason.
138 * e.g. no decoder available for codec.
139 */
140 AV_PKT_DATA_FALLBACK_TRACK,
141
142 /**
143 * This side data corresponds to the AVCPBProperties struct.
144 */
145 AV_PKT_DATA_CPB_PROPERTIES,
146
147 /**
148 * Recommmends skipping the specified number of samples
149 * @code
150 * u32le number of samples to skip from start of this packet
151 * u32le number of samples to skip from end of this packet
152 * u8 reason for start skip
153 * u8 reason for end skip (0=padding silence, 1=convergence)
154 * @endcode
155 */
156 AV_PKT_DATA_SKIP_SAMPLES,
157
158 /**
159 * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
160 * the packet may contain "dual mono" audio specific to Japanese DTV
161 * and if it is true, recommends only the selected channel to be used.
162 * @code
163 * u8 selected channels (0=mail/left, 1=sub/right, 2=both)
164 * @endcode
165 */
166 AV_PKT_DATA_JP_DUALMONO,
167
168 /**
169 * A list of zero terminated key/value strings. There is no end marker for
170 * the list, so it is required to rely on the side data size to stop.
171 */
172 AV_PKT_DATA_STRINGS_METADATA,
173
174 /**
175 * Subtitle event position
176 * @code
177 * u32le x1
178 * u32le y1
179 * u32le x2
180 * u32le y2
181 * @endcode
182 */
183 AV_PKT_DATA_SUBTITLE_POSITION,
184
185 /**
186 * Data found in BlockAdditional element of matroska container. There is
187 * no end marker for the data, so it is required to rely on the side data
188 * size to recognize the end. 8 byte id (as found in BlockAddId) followed
189 * by data.
190 */
191 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
192
193 /**
194 * The optional first identifier line of a WebVTT cue.
195 */
196 AV_PKT_DATA_WEBVTT_IDENTIFIER,
197
198 /**
199 * The optional settings (rendering instructions) that immediately
200 * follow the timestamp specifier of a WebVTT cue.
201 */
202 AV_PKT_DATA_WEBVTT_SETTINGS,
203
204 /**
205 * A list of zero terminated key/value strings. There is no end marker for
206 * the list, so it is required to rely on the side data size to stop. This
207 * side data includes updated metadata which appeared in the stream.
208 */
209 AV_PKT_DATA_METADATA_UPDATE,
210
211 /**
212 * MPEGTS stream ID as uint8_t, this is required to pass the stream ID
213 * information from the demuxer to the corresponding muxer.
214 */
215 AV_PKT_DATA_MPEGTS_STREAM_ID,
216
217 /**
218 * Mastering display metadata (based on SMPTE-2086:2014). This metadata
219 * should be associated with a video stream and contains data in the form
220 * of the AVMasteringDisplayMetadata struct.
221 */
222 AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
223
224 /**
225 * This side data should be associated with a video stream and corresponds
226 * to the AVSphericalMapping structure.
227 */
228 AV_PKT_DATA_SPHERICAL,
229
230 /**
231 * Content light level (based on CTA-861.3). This metadata should be
232 * associated with a video stream and contains data in the form of the
233 * AVContentLightMetadata struct.
234 */
235 AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
236
237 /**
238 * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
239 * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
240 * The number of bytes of CC data is AVPacketSideData.size.
241 */
242 AV_PKT_DATA_A53_CC,
243
244 /**
245 * This side data is encryption initialization data.
246 * The format is not part of ABI, use av_encryption_init_info_* methods to
247 * access.
248 */
249 AV_PKT_DATA_ENCRYPTION_INIT_INFO,
250
251 /**
252 * This side data contains encryption info for how to decrypt the packet.
253 * The format is not part of ABI, use av_encryption_info_* methods to access.
254 */
255 AV_PKT_DATA_ENCRYPTION_INFO,
256
257 /**
258 * Active Format Description data consisting of a single byte as specified
259 * in ETSI TS 101 154 using AVActiveFormatDescription enum.
260 */
261 AV_PKT_DATA_AFD,
262
263 /**
264 * Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
265 * usually exported by some encoders (on demand through the prft flag set in the
266 * AVCodecContext export_side_data field).
267 */
268 AV_PKT_DATA_PRFT,
269
270 /**
271 * ICC profile data consisting of an opaque octet buffer following the
272 * format described by ISO 15076-1.
273 */
274 AV_PKT_DATA_ICC_PROFILE,
275
276 /**
277 * DOVI configuration
278 * ref:
279 * dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
280 * dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
281 * Tags are stored in struct AVDOVIDecoderConfigurationRecord.
282 */
283 AV_PKT_DATA_DOVI_CONF,
284
285 /**
286 * Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t
287 * where the first uint32_t describes how many (1-3) of the other timecodes are used.
288 * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
289 * function in libavutil/timecode.h.
290 */
291 AV_PKT_DATA_S12M_TIMECODE,
292
293 /**
294 * The number of side data types.
295 * This is not part of the public API/ABI in the sense that it may
296 * change when new side data types are added.
297 * This must stay the last enum value.
298 * If its value becomes huge, some code using it
299 * needs to be updated as it assumes it to be smaller than other limits.
300 */
301 AV_PKT_DATA_NB
302};
303
304#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
305
306typedef struct AVPacketSideData {
307 uint8_t *data;
308#if FF_API_BUFFER_SIZE_T
309 int size;
310#else
311 size_t size;
312#endif
313 enum AVPacketSideDataType type;
314} AVPacketSideData;
315
316/**
317 * This structure stores compressed data. It is typically exported by demuxers
318 * and then passed as input to decoders, or received as output from encoders and
319 * then passed to muxers.
320 *
321 * For video, it should typically contain one compressed frame. For audio it may
322 * contain several compressed frames. Encoders are allowed to output empty
323 * packets, with no compressed data, containing only side data
324 * (e.g. to update some stream parameters at the end of encoding).
325 *
326 * The semantics of data ownership depends on the buf field.
327 * If it is set, the packet data is dynamically allocated and is
328 * valid indefinitely until a call to av_packet_unref() reduces the
329 * reference count to 0.
330 *
331 * If the buf field is not set av_packet_ref() would make a copy instead
332 * of increasing the reference count.
333 *
334 * The side data is always allocated with av_malloc(), copied by
335 * av_packet_ref() and freed by av_packet_unref().
336 *
337 * sizeof(AVPacket) being a part of the public ABI is deprecated. once
338 * av_init_packet() is removed, new packets will only be able to be allocated
339 * with av_packet_alloc(), and new fields may be added to the end of the struct
340 * with a minor bump.
341 *
342 * @see av_packet_alloc
343 * @see av_packet_ref
344 * @see av_packet_unref
345 */
346typedef struct AVPacket {
347 /**
348 * A reference to the reference-counted buffer where the packet data is
349 * stored.
350 * May be NULL, then the packet data is not reference-counted.
351 */
352 AVBufferRef *buf;
353 /**
354 * Presentation timestamp in AVStream->time_base units; the time at which
355 * the decompressed packet will be presented to the user.
356 * Can be AV_NOPTS_VALUE if it is not stored in the file.
357 * pts MUST be larger or equal to dts as presentation cannot happen before
358 * decompression, unless one wants to view hex dumps. Some formats misuse
359 * the terms dts and pts/cts to mean something different. Such timestamps
360 * must be converted to true pts/dts before they are stored in AVPacket.
361 */
362 int64_t pts;
363 /**
364 * Decompression timestamp in AVStream->time_base units; the time at which
365 * the packet is decompressed.
366 * Can be AV_NOPTS_VALUE if it is not stored in the file.
367 */
368 int64_t dts;
369 uint8_t *data;
370 int size;
371 int stream_index;
372 /**
373 * A combination of AV_PKT_FLAG values
374 */
375 int flags;
376 /**
377 * Additional packet data that can be provided by the container.
378 * Packet can contain several types of side information.
379 */
380 AVPacketSideData *side_data;
381 int side_data_elems;
382
383 /**
384 * Duration of this packet in AVStream->time_base units, 0 if unknown.
385 * Equals next_pts - this_pts in presentation order.
386 */
387 int64_t duration;
388
389 int64_t pos; ///< byte position in stream, -1 if unknown
390
391#if FF_API_CONVERGENCE_DURATION
392 /**
393 * @deprecated Same as the duration field, but as int64_t. This was required
394 * for Matroska subtitles, whose duration values could overflow when the
395 * duration field was still an int.
396 */
397 attribute_deprecated
398 int64_t convergence_duration;
399#endif
400} AVPacket;
401
402#if FF_API_INIT_PACKET
403attribute_deprecated
404typedef struct AVPacketList {
405 AVPacket pkt;
406 struct AVPacketList *next;
407} AVPacketList;
408#endif
409
410#define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
411#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
412/**
413 * Flag is used to discard packets which are required to maintain valid
414 * decoder state but are not required for output and should be dropped
415 * after decoding.
416 **/
417#define AV_PKT_FLAG_DISCARD 0x0004
418/**
419 * The packet comes from a trusted source.
420 *
421 * Otherwise-unsafe constructs such as arbitrary pointers to data
422 * outside the packet may be followed.
423 */
424#define AV_PKT_FLAG_TRUSTED 0x0008
425/**
426 * Flag is used to indicate packets that contain frames that can
427 * be discarded by the decoder. I.e. Non-reference frames.
428 */
429#define AV_PKT_FLAG_DISPOSABLE 0x0010
430
431enum AVSideDataParamChangeFlags {
432 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
433 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
434 AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
435 AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
436};
437
438/**
439 * Allocate an AVPacket and set its fields to default values. The resulting
440 * struct must be freed using av_packet_free().
441 *
442 * @return An AVPacket filled with default values or NULL on failure.
443 *
444 * @note this only allocates the AVPacket itself, not the data buffers. Those
445 * must be allocated through other means such as av_new_packet.
446 *
447 * @see av_new_packet
448 */
449AVPacket *av_packet_alloc(void);
450
451/**
452 * Create a new packet that references the same data as src.
453 *
454 * This is a shortcut for av_packet_alloc()+av_packet_ref().
455 *
456 * @return newly created AVPacket on success, NULL on error.
457 *
458 * @see av_packet_alloc
459 * @see av_packet_ref
460 */
461AVPacket *av_packet_clone(const AVPacket *src);
462
463/**
464 * Free the packet, if the packet is reference counted, it will be
465 * unreferenced first.
466 *
467 * @param pkt packet to be freed. The pointer will be set to NULL.
468 * @note passing NULL is a no-op.
469 */
470void av_packet_free(AVPacket **pkt);
471
472#if FF_API_INIT_PACKET
473/**
474 * Initialize optional fields of a packet with default values.
475 *
476 * Note, this does not touch the data and size members, which have to be
477 * initialized separately.
478 *
479 * @param pkt packet
480 *
481 * @see av_packet_alloc
482 * @see av_packet_unref
483 *
484 * @deprecated This function is deprecated. Once it's removed,
485 sizeof(AVPacket) will not be a part of the ABI anymore.
486 */
487attribute_deprecated
488void av_init_packet(AVPacket *pkt);
489#endif
490
491/**
492 * Allocate the payload of a packet and initialize its fields with
493 * default values.
494 *
495 * @param pkt packet
496 * @param size wanted payload size
497 * @return 0 if OK, AVERROR_xxx otherwise
498 */
499int av_new_packet(AVPacket *pkt, int size);
500
501/**
502 * Reduce packet size, correctly zeroing padding
503 *
504 * @param pkt packet
505 * @param size new size
506 */
507void av_shrink_packet(AVPacket *pkt, int size);
508
509/**
510 * Increase packet size, correctly zeroing padding
511 *
512 * @param pkt packet
513 * @param grow_by number of bytes by which to increase the size of the packet
514 */
515int av_grow_packet(AVPacket *pkt, int grow_by);
516
517/**
518 * Initialize a reference-counted packet from av_malloc()ed data.
519 *
520 * @param pkt packet to be initialized. This function will set the data, size,
521 * and buf fields, all others are left untouched.
522 * @param data Data allocated by av_malloc() to be used as packet data. If this
523 * function returns successfully, the data is owned by the underlying AVBuffer.
524 * The caller may not access the data through other means.
525 * @param size size of data in bytes, without the padding. I.e. the full buffer
526 * size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
527 *
528 * @return 0 on success, a negative AVERROR on error
529 */
530int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
531
532#if FF_API_AVPACKET_OLD_API
533/**
534 * @warning This is a hack - the packet memory allocation stuff is broken. The
535 * packet is allocated if it was not really allocated.
536 *
537 * @deprecated Use av_packet_ref or av_packet_make_refcounted
538 */
539attribute_deprecated
540int av_dup_packet(AVPacket *pkt);
541/**
542 * Copy packet, including contents
543 *
544 * @return 0 on success, negative AVERROR on fail
545 *
546 * @deprecated Use av_packet_ref
547 */
548attribute_deprecated
549int av_copy_packet(AVPacket *dst, const AVPacket *src);
550
551/**
552 * Copy packet side data
553 *
554 * @return 0 on success, negative AVERROR on fail
555 *
556 * @deprecated Use av_packet_copy_props
557 */
558attribute_deprecated
559int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
560
561/**
562 * Free a packet.
563 *
564 * @deprecated Use av_packet_unref
565 *
566 * @param pkt packet to free
567 */
568attribute_deprecated
569void av_free_packet(AVPacket *pkt);
570#endif
571/**
572 * Allocate new information of a packet.
573 *
574 * @param pkt packet
575 * @param type side information type
576 * @param size side information size
577 * @return pointer to fresh allocated data or NULL otherwise
578 */
579uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
580#if FF_API_BUFFER_SIZE_T
581 int size);
582#else
583 size_t size);
584#endif
585
586/**
587 * Wrap an existing array as a packet side data.
588 *
589 * @param pkt packet
590 * @param type side information type
591 * @param data the side data array. It must be allocated with the av_malloc()
592 * family of functions. The ownership of the data is transferred to
593 * pkt.
594 * @param size side information size
595 * @return a non-negative number on success, a negative AVERROR code on
596 * failure. On failure, the packet is unchanged and the data remains
597 * owned by the caller.
598 */
599int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
600 uint8_t *data, size_t size);
601
602/**
603 * Shrink the already allocated side data buffer
604 *
605 * @param pkt packet
606 * @param type side information type
607 * @param size new side information size
608 * @return 0 on success, < 0 on failure
609 */
610int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
611#if FF_API_BUFFER_SIZE_T
612 int size);
613#else
614 size_t size);
615#endif
616
617/**
618 * Get side information from packet.
619 *
620 * @param pkt packet
621 * @param type desired side information type
622 * @param size If supplied, *size will be set to the size of the side data
623 * or to zero if the desired side data is not present.
624 * @return pointer to data if present or NULL otherwise
625 */
626uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
627#if FF_API_BUFFER_SIZE_T
628 int *size);
629#else
630 size_t *size);
631#endif
632
633#if FF_API_MERGE_SD_API
634attribute_deprecated
635int av_packet_merge_side_data(AVPacket *pkt);
636
637attribute_deprecated
638int av_packet_split_side_data(AVPacket *pkt);
639#endif
640
641const char *av_packet_side_data_name(enum AVPacketSideDataType type);
642
643/**
644 * Pack a dictionary for use in side_data.
645 *
646 * @param dict The dictionary to pack.
647 * @param size pointer to store the size of the returned data
648 * @return pointer to data if successful, NULL otherwise
649 */
650#if FF_API_BUFFER_SIZE_T
651uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
652#else
653uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
654#endif
655/**
656 * Unpack a dictionary from side_data.
657 *
658 * @param data data from side_data
659 * @param size size of the data
660 * @param dict the metadata storage dictionary
661 * @return 0 on success, < 0 on failure
662 */
663#if FF_API_BUFFER_SIZE_T
664int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
665#else
666int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
667 AVDictionary **dict);
668#endif
669
670/**
671 * Convenience function to free all the side data stored.
672 * All the other fields stay untouched.
673 *
674 * @param pkt packet
675 */
676void av_packet_free_side_data(AVPacket *pkt);
677
678/**
679 * Setup a new reference to the data described by a given packet
680 *
681 * If src is reference-counted, setup dst as a new reference to the
682 * buffer in src. Otherwise allocate a new buffer in dst and copy the
683 * data from src into it.
684 *
685 * All the other fields are copied from src.
686 *
687 * @see av_packet_unref
688 *
689 * @param dst Destination packet. Will be completely overwritten.
690 * @param src Source packet
691 *
692 * @return 0 on success, a negative AVERROR on error. On error, dst
693 * will be blank (as if returned by av_packet_alloc()).
694 */
695int av_packet_ref(AVPacket *dst, const AVPacket *src);
696
697/**
698 * Wipe the packet.
699 *
700 * Unreference the buffer referenced by the packet and reset the
701 * remaining packet fields to their default values.
702 *
703 * @param pkt The packet to be unreferenced.
704 */
705void av_packet_unref(AVPacket *pkt);
706
707/**
708 * Move every field in src to dst and reset src.
709 *
710 * @see av_packet_unref
711 *
712 * @param src Source packet, will be reset
713 * @param dst Destination packet
714 */
715void av_packet_move_ref(AVPacket *dst, AVPacket *src);
716
717/**
718 * Copy only "properties" fields from src to dst.
719 *
720 * Properties for the purpose of this function are all the fields
721 * beside those related to the packet data (buf, data, size)
722 *
723 * @param dst Destination packet
724 * @param src Source packet
725 *
726 * @return 0 on success AVERROR on failure.
727 */
728int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
729
730/**
731 * Ensure the data described by a given packet is reference counted.
732 *
733 * @note This function does not ensure that the reference will be writable.
734 * Use av_packet_make_writable instead for that purpose.
735 *
736 * @see av_packet_ref
737 * @see av_packet_make_writable
738 *
739 * @param pkt packet whose data should be made reference counted.
740 *
741 * @return 0 on success, a negative AVERROR on error. On failure, the
742 * packet is unchanged.
743 */
744int av_packet_make_refcounted(AVPacket *pkt);
745
746/**
747 * Create a writable reference for the data described by a given packet,
748 * avoiding data copy if possible.
749 *
750 * @param pkt Packet whose data should be made writable.
751 *
752 * @return 0 on success, a negative AVERROR on failure. On failure, the
753 * packet is unchanged.
754 */
755int av_packet_make_writable(AVPacket *pkt);
756
757/**
758 * Convert valid timing fields (timestamps / durations) in a packet from one
759 * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
760 * ignored.
761 *
762 * @param pkt packet on which the conversion will be performed
763 * @param tb_src source timebase, in which the timing fields in pkt are
764 * expressed
765 * @param tb_dst destination timebase, to which the timing fields will be
766 * converted
767 */
768void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
769
770/**
771 * @}
772 */
773
774#endif // AVCODEC_PACKET_H
775

source code of include/x86_64-linux-gnu/libavcodec/packet.h