packet.h (24401B)
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 */ 40 enum 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 306 typedef 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 */ 346 typedef 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 403 attribute_deprecated 404 typedef 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 431 enum 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 */ 449 AVPacket *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 */ 461 AVPacket *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 */ 470 void 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 */ 487 attribute_deprecated 488 void 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 */ 499 int 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 */ 507 void 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 */ 515 int 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 */ 530 int 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 */ 539 attribute_deprecated 540 int 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 */ 548 attribute_deprecated 549 int 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 */ 558 attribute_deprecated 559 int 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 */ 568 attribute_deprecated 569 void 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 */ 579 uint8_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 */ 599 int 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 */ 610 int 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 */ 626 uint8_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 634 attribute_deprecated 635 int av_packet_merge_side_data(AVPacket *pkt); 636 637 attribute_deprecated 638 int av_packet_split_side_data(AVPacket *pkt); 639 #endif 640 641 const 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 651 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size); 652 #else 653 uint8_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 664 int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict); 665 #else 666 int 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 */ 676 void 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 */ 695 int 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 */ 705 void 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 */ 715 void 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 */ 728 int 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 */ 744 int 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 */ 755 int 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 */ 768 void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst); 769 770 /** 771 * @} 772 */ 773 774 #endif // AVCODEC_PACKET_H