FFmpeg
avpacket.c
Go to the documentation of this file.
1 /*
2  * AVPacket functions for libavcodec
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <string.h>
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/rational.h"
29 
30 #include "defs.h"
31 #include "packet.h"
32 #include "packet_internal.h"
33 
34 #if FF_API_INIT_PACKET
35 void av_init_packet(AVPacket *pkt)
36 {
39  pkt->pos = -1;
40  pkt->duration = 0;
41  pkt->flags = 0;
42  pkt->stream_index = 0;
43  pkt->buf = NULL;
44  pkt->side_data = NULL;
45  pkt->side_data_elems = 0;
46  pkt->opaque = NULL;
47  pkt->opaque_ref = NULL;
48  pkt->time_base = av_make_q(0, 1);
49 }
50 #endif
51 
53 {
54  memset(pkt, 0, sizeof(*pkt));
55 
58  pkt->pos = -1;
59  pkt->time_base = av_make_q(0, 1);
60 }
61 
63 {
64  AVPacket *pkt = av_malloc(sizeof(AVPacket));
65  if (!pkt)
66  return pkt;
67 
69 
70  return pkt;
71 }
72 
74 {
75  if (!pkt || !*pkt)
76  return;
77 
79  av_freep(pkt);
80 }
81 
82 static int packet_alloc(AVBufferRef **buf, int size)
83 {
84  int ret;
85  if (size < 0 || size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
86  return AVERROR(EINVAL);
87 
89  if (ret < 0)
90  return ret;
91 
92  memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
93 
94  return 0;
95 }
96 
98 {
99  AVBufferRef *buf = NULL;
100  int ret = packet_alloc(&buf, size);
101  if (ret < 0)
102  return ret;
103 
105  pkt->buf = buf;
106  pkt->data = buf->data;
107  pkt->size = size;
108 
109  return 0;
110 }
111 
113 {
114  if (pkt->size <= size)
115  return;
116  pkt->size = size;
117  memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
118 }
119 
120 int av_grow_packet(AVPacket *pkt, int grow_by)
121 {
122  int new_size;
123  av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
124  if ((unsigned)grow_by >
125  INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))
126  return AVERROR(ENOMEM);
127 
128  new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;
129  if (pkt->buf) {
130  size_t data_offset;
131  uint8_t *old_data = pkt->data;
132  if (pkt->data == NULL) {
133  data_offset = 0;
134  pkt->data = pkt->buf->data;
135  } else {
136  data_offset = pkt->data - pkt->buf->data;
137  if (data_offset > INT_MAX - new_size)
138  return AVERROR(ENOMEM);
139  }
140 
141  if (new_size + data_offset > pkt->buf->size ||
143  int ret;
144 
145  // allocate slightly more than requested to avoid excessive
146  // reallocations
147  if (new_size + data_offset < INT_MAX - new_size/16)
148  new_size += new_size/16;
149 
150  ret = av_buffer_realloc(&pkt->buf, new_size + data_offset);
151  if (ret < 0) {
152  pkt->data = old_data;
153  return ret;
154  }
155  pkt->data = pkt->buf->data + data_offset;
156  }
157  } else {
158  pkt->buf = av_buffer_alloc(new_size);
159  if (!pkt->buf)
160  return AVERROR(ENOMEM);
161  if (pkt->size > 0)
162  memcpy(pkt->buf->data, pkt->data, pkt->size);
163  pkt->data = pkt->buf->data;
164  }
165  pkt->size += grow_by;
166  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
167 
168  return 0;
169 }
170 
172 {
173  if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
174  return AVERROR(EINVAL);
175 
178  if (!pkt->buf)
179  return AVERROR(ENOMEM);
180 
181  pkt->data = data;
182  pkt->size = size;
183 
184  return 0;
185 }
186 
188 {
189  int i;
190  for (i = 0; i < pkt->side_data_elems; i++)
193  pkt->side_data_elems = 0;
194 }
195 
197  uint8_t *data, size_t size)
198 {
200  int i, elems = pkt->side_data_elems;
201 
202  for (i = 0; i < elems; i++) {
203  AVPacketSideData *sd = &pkt->side_data[i];
204 
205  if (sd->type == type) {
206  av_free(sd->data);
207  sd->data = data;
208  sd->size = size;
209  return 0;
210  }
211  }
212 
213  if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
214  return AVERROR(ERANGE);
215 
216  tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
217  if (!tmp)
218  return AVERROR(ENOMEM);
219 
220  pkt->side_data = tmp;
221  pkt->side_data[elems].data = data;
222  pkt->side_data[elems].size = size;
223  pkt->side_data[elems].type = type;
224  pkt->side_data_elems++;
225 
226  return 0;
227 }
228 
229 
231  size_t size)
232 {
233  int ret;
234  uint8_t *data;
235 
236  if (size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
237  return NULL;
239  if (!data)
240  return NULL;
241 
243  if (ret < 0) {
244  av_freep(&data);
245  return NULL;
246  }
247 
248  return data;
249 }
250 
252  size_t *size)
253 {
254  int i;
255 
256  for (i = 0; i < pkt->side_data_elems; i++) {
257  if (pkt->side_data[i].type == type) {
258  if (size)
259  *size = pkt->side_data[i].size;
260  return pkt->side_data[i].data;
261  }
262  }
263  if (size)
264  *size = 0;
265  return NULL;
266 }
267 
269 {
270  switch(type) {
271  case AV_PKT_DATA_PALETTE: return "Palette";
272  case AV_PKT_DATA_NEW_EXTRADATA: return "New Extradata";
273  case AV_PKT_DATA_PARAM_CHANGE: return "Param Change";
274  case AV_PKT_DATA_H263_MB_INFO: return "H263 MB Info";
275  case AV_PKT_DATA_REPLAYGAIN: return "Replay Gain";
276  case AV_PKT_DATA_DISPLAYMATRIX: return "Display Matrix";
277  case AV_PKT_DATA_STEREO3D: return "Stereo 3D";
278  case AV_PKT_DATA_AUDIO_SERVICE_TYPE: return "Audio Service Type";
279  case AV_PKT_DATA_QUALITY_STATS: return "Quality stats";
280  case AV_PKT_DATA_FALLBACK_TRACK: return "Fallback track";
281  case AV_PKT_DATA_CPB_PROPERTIES: return "CPB properties";
282  case AV_PKT_DATA_SKIP_SAMPLES: return "Skip Samples";
283  case AV_PKT_DATA_JP_DUALMONO: return "JP Dual Mono";
284  case AV_PKT_DATA_STRINGS_METADATA: return "Strings Metadata";
285  case AV_PKT_DATA_SUBTITLE_POSITION: return "Subtitle Position";
286  case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL: return "Matroska BlockAdditional";
287  case AV_PKT_DATA_WEBVTT_IDENTIFIER: return "WebVTT ID";
288  case AV_PKT_DATA_WEBVTT_SETTINGS: return "WebVTT Settings";
289  case AV_PKT_DATA_METADATA_UPDATE: return "Metadata Update";
290  case AV_PKT_DATA_MPEGTS_STREAM_ID: return "MPEGTS Stream ID";
291  case AV_PKT_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
292  case AV_PKT_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
293  case AV_PKT_DATA_SPHERICAL: return "Spherical Mapping";
294  case AV_PKT_DATA_A53_CC: return "A53 Closed Captions";
295  case AV_PKT_DATA_ENCRYPTION_INIT_INFO: return "Encryption initialization data";
296  case AV_PKT_DATA_ENCRYPTION_INFO: return "Encryption info";
297  case AV_PKT_DATA_AFD: return "Active Format Description data";
298  case AV_PKT_DATA_PRFT: return "Producer Reference Time";
299  case AV_PKT_DATA_ICC_PROFILE: return "ICC Profile";
300  case AV_PKT_DATA_DOVI_CONF: return "DOVI configuration record";
301  case AV_PKT_DATA_S12M_TIMECODE: return "SMPTE ST 12-1:2014 timecode";
302  case AV_PKT_DATA_DYNAMIC_HDR10_PLUS: return "HDR10+ Dynamic Metadata (SMPTE 2094-40)";
303  }
304  return NULL;
305 }
306 
308 {
309  uint8_t *data = NULL;
310  *size = 0;
311 
312  if (!dict)
313  return NULL;
314 
315  for (int pass = 0; pass < 2; pass++) {
316  const AVDictionaryEntry *t = NULL;
317  size_t total_length = 0;
318 
319  while ((t = av_dict_get(dict, "", t, AV_DICT_IGNORE_SUFFIX))) {
320  for (int i = 0; i < 2; i++) {
321  const char *str = i ? t->value : t->key;
322  const size_t len = strlen(str) + 1;
323 
324  if (pass)
325  memcpy(data + total_length, str, len);
326  else if (len > SIZE_MAX - total_length)
327  return NULL;
328  total_length += len;
329  }
330  }
331  if (pass)
332  break;
333  data = av_malloc(total_length);
334  if (!data)
335  return NULL;
336  *size = total_length;
337  }
338 
339  return data;
340 }
341 
342 int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
343  AVDictionary **dict)
344 {
345  const uint8_t *end;
346  int ret;
347 
348  if (!dict || !data || !size)
349  return 0;
350  end = data + size;
351  if (size && end[-1])
352  return AVERROR_INVALIDDATA;
353  while (data < end) {
354  const uint8_t *key = data;
355  const uint8_t *val = data + strlen(key) + 1;
356 
357  if (val >= end || !*key)
358  return AVERROR_INVALIDDATA;
359 
360  ret = av_dict_set(dict, key, val, 0);
361  if (ret < 0)
362  return ret;
363  data = val + strlen(val) + 1;
364  }
365 
366  return 0;
367 }
368 
370  size_t size)
371 {
372  int i;
373 
374  for (i = 0; i < pkt->side_data_elems; i++) {
375  if (pkt->side_data[i].type == type) {
376  if (size > pkt->side_data[i].size)
377  return AVERROR(ENOMEM);
378  pkt->side_data[i].size = size;
379  return 0;
380  }
381  }
382  return AVERROR(ENOENT);
383 }
384 
386 {
387  int i, ret;
388 
389  dst->pts = src->pts;
390  dst->dts = src->dts;
391  dst->pos = src->pos;
392  dst->duration = src->duration;
393  dst->flags = src->flags;
394  dst->stream_index = src->stream_index;
395  dst->opaque = src->opaque;
396  dst->time_base = src->time_base;
397  dst->opaque_ref = NULL;
398  dst->side_data = NULL;
399  dst->side_data_elems = 0;
400 
401  ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
402  if (ret < 0)
403  return ret;
404 
405  for (i = 0; i < src->side_data_elems; i++) {
406  enum AVPacketSideDataType type = src->side_data[i].type;
407  size_t size = src->side_data[i].size;
408  uint8_t *src_data = src->side_data[i].data;
409  uint8_t *dst_data = av_packet_new_side_data(dst, type, size);
410 
411  if (!dst_data) {
414  return AVERROR(ENOMEM);
415  }
416  memcpy(dst_data, src_data, size);
417  }
418 
419  return 0;
420 }
421 
423 {
428 }
429 
431 {
432  int ret;
433 
434  dst->buf = NULL;
435 
436  ret = av_packet_copy_props(dst, src);
437  if (ret < 0)
438  goto fail;
439 
440  if (!src->buf) {
441  ret = packet_alloc(&dst->buf, src->size);
442  if (ret < 0)
443  goto fail;
444  av_assert1(!src->size || src->data);
445  if (src->size)
446  memcpy(dst->buf->data, src->data, src->size);
447 
448  dst->data = dst->buf->data;
449  } else {
450  dst->buf = av_buffer_ref(src->buf);
451  if (!dst->buf) {
452  ret = AVERROR(ENOMEM);
453  goto fail;
454  }
455  dst->data = src->data;
456  }
457 
458  dst->size = src->size;
459 
460  return 0;
461 fail:
462  av_packet_unref(dst);
463  return ret;
464 }
465 
467 {
469 
470  if (!ret)
471  return ret;
472 
473  if (av_packet_ref(ret, src))
475 
476  return ret;
477 }
478 
480 {
481  *dst = *src;
483 }
484 
486 {
487  int ret;
488 
489  if (pkt->buf)
490  return 0;
491 
492  ret = packet_alloc(&pkt->buf, pkt->size);
493  if (ret < 0)
494  return ret;
495  av_assert1(!pkt->size || pkt->data);
496  if (pkt->size)
497  memcpy(pkt->buf->data, pkt->data, pkt->size);
498 
499  pkt->data = pkt->buf->data;
500 
501  return 0;
502 }
503 
505 {
506  AVBufferRef *buf = NULL;
507  int ret;
508 
509  if (pkt->buf && av_buffer_is_writable(pkt->buf))
510  return 0;
511 
512  ret = packet_alloc(&buf, pkt->size);
513  if (ret < 0)
514  return ret;
515  av_assert1(!pkt->size || pkt->data);
516  if (pkt->size)
517  memcpy(buf->data, pkt->data, pkt->size);
518 
520  pkt->buf = buf;
521  pkt->data = buf->data;
522 
523  return 0;
524 }
525 
527 {
528  if (pkt->pts != AV_NOPTS_VALUE)
529  pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);
530  if (pkt->dts != AV_NOPTS_VALUE)
531  pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);
532  if (pkt->duration > 0)
533  pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
534 }
535 
537  AVPacket *pkt,
538  int (*copy)(AVPacket *dst, const AVPacket *src),
539  int flags)
540 {
541  PacketListEntry *pktl = av_malloc(sizeof(*pktl));
542  int ret;
543 
544  if (!pktl)
545  return AVERROR(ENOMEM);
546 
547  if (copy) {
548  get_packet_defaults(&pktl->pkt);
549  ret = copy(&pktl->pkt, pkt);
550  if (ret < 0) {
551  av_free(pktl);
552  return ret;
553  }
554  } else {
556  if (ret < 0) {
557  av_free(pktl);
558  return ret;
559  }
560  av_packet_move_ref(&pktl->pkt, pkt);
561  }
562 
563  pktl->next = NULL;
564 
565  if (packet_buffer->head)
566  packet_buffer->tail->next = pktl;
567  else
568  packet_buffer->head = pktl;
569 
570  /* Add the packet in the buffered packet list. */
571  packet_buffer->tail = pktl;
572  return 0;
573 }
574 
576  AVPacket *pkt)
577 {
578  PacketListEntry *pktl = pkt_buffer->head;
579  if (!pktl)
580  return AVERROR(EAGAIN);
581  *pkt = pktl->pkt;
582  pkt_buffer->head = pktl->next;
583  if (!pkt_buffer->head)
584  pkt_buffer->tail = NULL;
585  av_freep(&pktl);
586  return 0;
587 }
588 
590 {
591  PacketListEntry *tmp = pkt_buf->head;
592 
593  while (tmp) {
594  PacketListEntry *pktl = tmp;
595  tmp = pktl->next;
596  av_packet_unref(&pktl->pkt);
597  av_freep(&pktl);
598  }
599  pkt_buf->head = pkt_buf->tail = NULL;
600 }
601 
602 int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
603 {
604  uint8_t *side_data;
605  size_t side_data_size;
606  int i;
607 
608  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS, &side_data_size);
609  if (!side_data) {
610  side_data_size = 4+4+8*error_count;
612  side_data_size);
613  }
614 
615  if (!side_data || side_data_size < 4+4+8*error_count)
616  return AVERROR(ENOMEM);
617 
618  AV_WL32(side_data , quality );
619  side_data[4] = pict_type;
620  side_data[5] = error_count;
621  for (i = 0; i<error_count; i++)
622  AV_WL64(side_data+8 + 8*i , error[i]);
623 
624  return 0;
625 }
626 
627 int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
628 {
630  uint8_t *side_data;
631  size_t side_data_size;
632 
633  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);
634  if (!side_data) {
635  side_data_size = sizeof(AVProducerReferenceTime);
636  side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_PRFT, side_data_size);
637  }
638 
639  if (!side_data || side_data_size < sizeof(AVProducerReferenceTime))
640  return AVERROR(ENOMEM);
641 
642  prft = (AVProducerReferenceTime *)side_data;
643  prft->wallclock = timestamp;
644  prft->flags = 0;
645 
646  return 0;
647 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
avpriv_packet_list_put
int avpriv_packet_list_put(PacketList *packet_buffer, AVPacket *pkt, int(*copy)(AVPacket *dst, const AVPacket *src), int flags)
Append an AVPacket to the list.
Definition: avpacket.c:536
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:32
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:575
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AV_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:310
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AV_PKT_DATA_MPEGTS_STREAM_ID
@ AV_PKT_DATA_MPEGTS_STREAM_ID
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:216
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:73
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:602
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
rational.h
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:120
AV_PKT_DATA_ENCRYPTION_INFO
@ AV_PKT_DATA_ENCRYPTION_INFO
This side data contains encryption info for how to decrypt the packet.
Definition: packet.h:256
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacketSideData
Definition: packet.h:315
AVProducerReferenceTime::wallclock
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Definition: defs.h:157
AVPacket::data
uint8_t * data
Definition: packet.h:374
av_packet_shrink_side_data
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Shrink the already allocated side data buffer.
Definition: avpacket.c:369
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
PacketList
Definition: packet_internal.h:31
data
const char data[16]
Definition: mxf.c:146
AV_PKT_DATA_ENCRYPTION_INIT_INFO
@ AV_PKT_DATA_ENCRYPTION_INIT_INFO
This side data is encryption initialization data.
Definition: packet.h:250
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:262
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
mathematics.h
AVDictionary
Definition: dict.c:30
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
av_packet_free_side_data
void av_packet_free_side_data(AVPacket *pkt)
Convenience function to free all the side data stored.
Definition: avpacket.c:187
packet_alloc
static int packet_alloc(AVBufferRef **buf, int size)
Definition: avpacket.c:82
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:73
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVPacketSideData::size
size_t size
Definition: packet.h:317
av_packet_add_side_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.
Definition: avpacket.c:196
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:410
fail
#define fail()
Definition: checkasm.h:131
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
ff_side_data_set_prft
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:627
val
static double val(void *priv, double ch)
Definition: aeval.c:77
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:100
av_packet_side_data_name
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: avpacket.c:268
avassert.h
AV_PKT_DATA_WEBVTT_SETTINGS
@ AV_PKT_DATA_WEBVTT_SETTINGS
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:203
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:121
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
intreadwrite.h
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
AVDictionaryEntry::key
char * key
Definition: dict.h:80
av_buffer_default_free
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:72
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_PKT_DATA_ICC_PROFILE
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:275
AVPacketSideData::data
uint8_t * data
Definition: packet.h:316
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:300
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
key
const char * key
Definition: hwcontext_opencl.c:174
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:399
AV_PKT_DATA_PRFT
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
Definition: packet.h:269
pass
#define pass
Definition: fft_template.c:608
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:32
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:357
NULL
#define NULL
Definition: coverity.c:32
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:318
AV_PKT_DATA_SUBTITLE_POSITION
@ AV_PKT_DATA_SUBTITLE_POSITION
Subtitle event position.
Definition: packet.h:184
AVProducerReferenceTime
This structure supplies correlation between a packet timestamp and a wall clock production time.
Definition: defs.h:153
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:430
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:27
AVProducerReferenceTime::flags
int flags
Definition: defs.h:158
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
av_packet_from_data
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
Initialize a reference-counted packet from av_malloc()ed data.
Definition: avpacket.c:171
AVPacket::size
int size
Definition: packet.h:375
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:187
get_packet_defaults
static void get_packet_defaults(AVPacket *pkt)
Definition: avpacket.c:52
avpriv_packet_list_free
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
Definition: avpacket.c:589
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:28
AV_PKT_DATA_H263_MB_INFO
@ AV_PKT_DATA_H263_MB_INFO
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: packet.h:94
av_packet_unpack_dictionary
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:342
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AV_WL64
#define AV_WL64(p, v)
Definition: intreadwrite.h:440
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
av_packet_pack_dictionary
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:307
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:485
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:62
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
av_packet_rescale_ts
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
Definition: avpacket.c:526
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
AV_PKT_DATA_METADATA_UPDATE
@ AV_PKT_DATA_METADATA_UPDATE
A list of zero terminated key/value strings.
Definition: packet.h:210
AV_PKT_DATA_JP_DUALMONO
@ AV_PKT_DATA_JP_DUALMONO
An AV_PKT_DATA_JP_DUALMONO side data packet indicates that the packet may contain "dual mono" audio s...
Definition: packet.h:167
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:385
PacketListEntry
Definition: packet_internal.h:26
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
packet.h
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:251
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:243
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
len
int len
Definition: vorbis_enc_data.h:426
av_buffer_is_writable
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:147
ret
ret
Definition: filter_design.txt:187
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:284
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:385
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:292
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:230
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
defs.h
av_packet_make_writable
int av_packet_make_writable(AVPacket *pkt)
Create a writable reference for the data described by a given packet, avoiding data copy if possible.
Definition: avpacket.c:504
AVPacket::stream_index
int stream_index
Definition: packet.h:376
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:192
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:79
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
AV_PKT_DATA_FALLBACK_TRACK
@ AV_PKT_DATA_FALLBACK_TRACK
This side data contains an integer value representing the stream index of a "fallback" track.
Definition: packet.h:141
convert_header.str
string str
Definition: convert_header.py:20
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:133
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_PKT_DATA_WEBVTT_IDENTIFIER
@ AV_PKT_DATA_WEBVTT_IDENTIFIER
The optional first identifier line of a WebVTT cue.
Definition: packet.h:197
AVDictionaryEntry::value
char * value
Definition: dict.h:81
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:418
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:386
av_packet_clone
AVPacket * av_packet_clone(const AVPacket *src)
Create a new packet that references the same data as src.
Definition: avpacket.c:466