FFmpeg: libavcodec/packet.c Source File

FFmpeg
packet.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/avutil.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/rational.h"
30 
31 #include "defs.h"
32 #include "packet.h"
33 #include "packet_internal.h"
34 
35 #if FF_API_INIT_PACKET
36 void av_init_packet(AVPacket *pkt)
37 {
38  pkt->pts = AV_NOPTS_VALUE;
39  pkt->dts = AV_NOPTS_VALUE;
40  pkt->pos = -1;
41  pkt->duration = 0;
42  pkt->flags = 0;
43  pkt->stream_index = 0;
44  pkt->buf = NULL;
45  pkt->side_data = NULL;
46  pkt->side_data_elems = 0;
47  pkt->opaque = NULL;
48  pkt->opaque_ref = NULL;
49  pkt->time_base = av_make_q(0, 1);
50 }
51 #endif
52 
53  static void get_packet_defaults(AVPacket *pkt)
54 {
55  memset(pkt, 0, sizeof(*pkt));
56 
57  pkt->pts = AV_NOPTS_VALUE;
58  pkt->dts = AV_NOPTS_VALUE;
59  pkt->pos = -1;
60  pkt->time_base = av_make_q(0, 1);
61 }
62 
63  AVPacket *av_packet_alloc(void)
64 {
65  AVPacket *pkt = av_malloc(sizeof(AVPacket));
66  if (!pkt)
67  return pkt;
68 
69  get_packet_defaults(pkt);
70 
71  return pkt;
72 }
73 
74  void av_packet_free(AVPacket **pkt)
75 {
76  if (!pkt || !*pkt)
77  return;
78 
79  av_packet_unref(*pkt);
80  av_freep(pkt);
81 }
82 
83  static int packet_alloc(AVBufferRef **buf, int size)
84 {
85  int ret;
86  if (size < 0 || size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
87  return AVERROR(EINVAL);
88 
89  ret = av_buffer_realloc(buf, size + AV_INPUT_BUFFER_PADDING_SIZE);
90  if (ret < 0)
91  return ret;
92 
93  memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
94 
95  return 0;
96 }
97 
98  int av_new_packet(AVPacket *pkt, int size)
99 {
100  AVBufferRef *buf = NULL;
101  int ret = packet_alloc(&buf, size);
102  if (ret < 0)
103  return ret;
104 
105  get_packet_defaults(pkt);
106  pkt->buf = buf;
107  pkt->data = buf->data;
108  pkt->size = size;
109 
110  return 0;
111 }
112 
113  void av_shrink_packet(AVPacket *pkt, int size)
114 {
115  if (pkt->size <= size)
116  return;
117  pkt->size = size;
118  memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
119 }
120 
121  int av_grow_packet(AVPacket *pkt, int grow_by)
122 {
123  int new_size;
124  av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
125  if ((unsigned)grow_by >
126  INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))
127  return AVERROR(ENOMEM);
128 
129  new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;
130  if (pkt->buf) {
131  size_t data_offset;
132  uint8_t *old_data = pkt->data;
133  if (pkt->data == NULL) {
134  data_offset = 0;
135  pkt->data = pkt->buf->data;
136  } else {
137  data_offset = pkt->data - pkt->buf->data;
138  if (data_offset > INT_MAX - new_size)
139  return AVERROR(ENOMEM);
140  }
141 
142  if (new_size + data_offset > pkt->buf->size ||
143  !av_buffer_is_writable(pkt->buf)) {
144  int ret;
145 
146  // allocate slightly more than requested to avoid excessive
147  // reallocations
148  if (new_size + data_offset < INT_MAX - new_size/16)
149  new_size += new_size/16;
150 
151  ret = av_buffer_realloc(&pkt->buf, new_size + data_offset);
152  if (ret < 0) {
153  pkt->data = old_data;
154  return ret;
155  }
156  pkt->data = pkt->buf->data + data_offset;
157  }
158  } else {
159  pkt->buf = av_buffer_alloc(new_size);
160  if (!pkt->buf)
161  return AVERROR(ENOMEM);
162  if (pkt->size > 0)
163  memcpy(pkt->buf->data, pkt->data, pkt->size);
164  pkt->data = pkt->buf->data;
165  }
166  pkt->size += grow_by;
167  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
168 
169  return 0;
170 }
171 
172  int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
173 {
174  if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
175  return AVERROR(EINVAL);
176 
177  pkt->buf = av_buffer_create(data, size + AV_INPUT_BUFFER_PADDING_SIZE,
178  av_buffer_default_free, NULL, 0);
179  if (!pkt->buf)
180  return AVERROR(ENOMEM);
181 
182  pkt->data = data;
183  pkt->size = size;
184 
185  return 0;
186 }
187 
188  void av_packet_free_side_data(AVPacket *pkt)
189 {
190  int i;
191  for (i = 0; i < pkt->side_data_elems; i++)
192  av_freep(&pkt->side_data[i].data);
193  av_freep(&pkt->side_data);
194  pkt->side_data_elems = 0;
195 }
196 
197  int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
198  uint8_t *data, size_t size)
199 {
200  AVPacketSideData *tmp;
201  int i, elems = pkt->side_data_elems;
202 
203  for (i = 0; i < elems; i++) {
204  AVPacketSideData *sd = &pkt->side_data[i];
205 
206  if (sd->type == type) {
207  av_free(sd->data);
208  sd->data = data;
209  sd->size = size;
210  return 0;
211  }
212  }
213 
214  if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
215  return AVERROR(ERANGE);
216 
217  tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
218  if (!tmp)
219  return AVERROR(ENOMEM);
220 
221  pkt->side_data = tmp;
222  pkt->side_data[elems].data = data;
223  pkt->side_data[elems].size = size;
224  pkt->side_data[elems].type = type;
225  pkt->side_data_elems++;
226 
227  return 0;
228 }
229 
230 
231  uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
232  size_t size)
233 {
234  int ret;
235  uint8_t *data;
236 
237  if (size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
238  return NULL;
239  data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
240  if (!data)
241  return NULL;
242 
243  ret = av_packet_add_side_data(pkt, type, data, size);
244  if (ret < 0) {
245  av_freep(&data);
246  return NULL;
247  }
248 
249  return data;
250 }
251 
252  uint8_t *av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
253  size_t *size)
254 {
255  int i;
256 
257  for (i = 0; i < pkt->side_data_elems; i++) {
258  if (pkt->side_data[i].type == type) {
259  if (size)
260  *size = pkt->side_data[i].size;
261  return pkt->side_data[i].data;
262  }
263  }
264  if (size)
265  *size = 0;
266  return NULL;
267 }
268 
269  const char *av_packet_side_data_name(enum AVPacketSideDataType type)
270 {
271  switch(type) {
272  case AV_PKT_DATA_PALETTE: return "Palette";
273  case AV_PKT_DATA_NEW_EXTRADATA: return "New Extradata";
274  case AV_PKT_DATA_PARAM_CHANGE: return "Param Change";
275  case AV_PKT_DATA_H263_MB_INFO: return "H263 MB Info";
276  case AV_PKT_DATA_REPLAYGAIN: return "Replay Gain";
277  case AV_PKT_DATA_DISPLAYMATRIX: return "Display Matrix";
278  case AV_PKT_DATA_STEREO3D: return "Stereo 3D";
279  case AV_PKT_DATA_AUDIO_SERVICE_TYPE: return "Audio Service Type";
280  case AV_PKT_DATA_QUALITY_STATS: return "Quality stats";
281  case AV_PKT_DATA_FALLBACK_TRACK: return "Fallback track";
282  case AV_PKT_DATA_CPB_PROPERTIES: return "CPB properties";
283  case AV_PKT_DATA_SKIP_SAMPLES: return "Skip Samples";
284  case AV_PKT_DATA_JP_DUALMONO: return "JP Dual Mono";
285  case AV_PKT_DATA_STRINGS_METADATA: return "Strings Metadata";
286  case AV_PKT_DATA_SUBTITLE_POSITION: return "Subtitle Position";
287  case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL: return "Matroska BlockAdditional";
288  case AV_PKT_DATA_WEBVTT_IDENTIFIER: return "WebVTT ID";
289  case AV_PKT_DATA_WEBVTT_SETTINGS: return "WebVTT Settings";
290  case AV_PKT_DATA_METADATA_UPDATE: return "Metadata Update";
291  case AV_PKT_DATA_MPEGTS_STREAM_ID: return "MPEGTS Stream ID";
292  case AV_PKT_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
293  case AV_PKT_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
294  case AV_PKT_DATA_SPHERICAL: return "Spherical Mapping";
295  case AV_PKT_DATA_A53_CC: return "A53 Closed Captions";
296  case AV_PKT_DATA_ENCRYPTION_INIT_INFO: return "Encryption initialization data";
297  case AV_PKT_DATA_ENCRYPTION_INFO: return "Encryption info";
298  case AV_PKT_DATA_AFD: return "Active Format Description data";
299  case AV_PKT_DATA_PRFT: return "Producer Reference Time";
300  case AV_PKT_DATA_ICC_PROFILE: return "ICC Profile";
301  case AV_PKT_DATA_DOVI_CONF: return "DOVI configuration record";
302  case AV_PKT_DATA_S12M_TIMECODE: return "SMPTE ST 12-1:2014 timecode";
303  case AV_PKT_DATA_DYNAMIC_HDR10_PLUS: return "HDR10+ Dynamic Metadata (SMPTE 2094-40)";
304  case AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT:return "Ambient viewing environment";
305  case AV_PKT_DATA_IAMF_MIX_GAIN_PARAM: return "IAMF Mix Gain Parameter Data";
306  case AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM: return "IAMF Demixing Info Parameter Data";
307  case AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM: return "IAMF Recon Gain Info Parameter Data";
308  case AV_PKT_DATA_FRAME_CROPPING: return "Frame Cropping";
309  case AV_PKT_DATA_LCEVC: return "LCEVC NAL data";
310  }
311  return NULL;
312 }
313 
314  uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
315 {
316  uint8_t *data = NULL;
317  *size = 0;
318 
319  if (!dict)
320  return NULL;
321 
322  for (int pass = 0; pass < 2; pass++) {
323  const AVDictionaryEntry *t = NULL;
324  size_t total_length = 0;
325 
326  while ((t = av_dict_iterate(dict, t))) {
327  for (int i = 0; i < 2; i++) {
328  const char *str = i ? t->value : t->key;
329  const size_t len = strlen(str) + 1;
330 
331  if (pass)
332  memcpy(data + total_length, str, len);
333  else if (len > SIZE_MAX - total_length)
334  return NULL;
335  total_length += len;
336  }
337  }
338  if (pass)
339  break;
340  data = av_malloc(total_length);
341  if (!data)
342  return NULL;
343  *size = total_length;
344  }
345 
346  return data;
347 }
348 
349  int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
350  AVDictionary **dict)
351 {
352  const uint8_t *end;
353  int ret;
354 
355  if (!dict || !data || !size)
356  return 0;
357  end = data + size;
358  if (size && end[-1])
359  return AVERROR_INVALIDDATA;
360  while (data < end) {
361  const uint8_t *key = data;
362  const uint8_t *val = data + strlen(key) + 1;
363 
364  if (val >= end || !*key)
365  return AVERROR_INVALIDDATA;
366 
367  ret = av_dict_set(dict, key, val, 0);
368  if (ret < 0)
369  return ret;
370  data = val + strlen(val) + 1;
371  }
372 
373  return 0;
374 }
375 
376  int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
377  size_t size)
378 {
379  int i;
380 
381  for (i = 0; i < pkt->side_data_elems; i++) {
382  if (pkt->side_data[i].type == type) {
383  if (size > pkt->side_data[i].size)
384  return AVERROR(ENOMEM);
385  pkt->side_data[i].size = size;
386  return 0;
387  }
388  }
389  return AVERROR(ENOENT);
390 }
391 
392  int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
393 {
394  int i, ret;
395 
396  dst->pts = src->pts;
397  dst->dts = src->dts;
398  dst->pos = src->pos;
399  dst->duration = src->duration;
400  dst->flags = src->flags;
401  dst->stream_index = src->stream_index;
402  dst->opaque = src->opaque;
403  dst->time_base = src->time_base;
404  dst->opaque_ref = NULL;
405  dst->side_data = NULL;
406  dst->side_data_elems = 0;
407 
408  ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
409  if (ret < 0)
410  return ret;
411 
412  for (i = 0; i < src->side_data_elems; i++) {
413  enum AVPacketSideDataType type = src->side_data[i].type;
414  size_t size = src->side_data[i].size;
415  uint8_t *src_data = src->side_data[i].data;
416  uint8_t *dst_data = av_packet_new_side_data(dst, type, size);
417 
418  if (!dst_data) {
419  av_buffer_unref(&dst->opaque_ref);
420  av_packet_free_side_data(dst);
421  return AVERROR(ENOMEM);
422  }
423  memcpy(dst_data, src_data, size);
424  }
425 
426  return 0;
427 }
428 
429  void av_packet_unref(AVPacket *pkt)
430 {
431  av_packet_free_side_data(pkt);
432  av_buffer_unref(&pkt->opaque_ref);
433  av_buffer_unref(&pkt->buf);
434  get_packet_defaults(pkt);
435 }
436 
437  int av_packet_ref(AVPacket *dst, const AVPacket *src)
438 {
439  int ret;
440 
441  dst->buf = NULL;
442 
443  ret = av_packet_copy_props(dst, src);
444  if (ret < 0)
445  goto fail;
446 
447  if (!src->buf) {
448  ret = packet_alloc(&dst->buf, src->size);
449  if (ret < 0)
450  goto fail;
451  av_assert1(!src->size || src->data);
452  if (src->size)
453  memcpy(dst->buf->data, src->data, src->size);
454 
455  dst->data = dst->buf->data;
456  } else {
457  dst->buf = av_buffer_ref(src->buf);
458  if (!dst->buf) {
459  ret = AVERROR(ENOMEM);
460  goto fail;
461  }
462  dst->data = src->data;
463  }
464 
465  dst->size = src->size;
466 
467  return 0;
468 fail:
469  av_packet_unref(dst);
470  return ret;
471 }
472 
473  AVPacket *av_packet_clone(const AVPacket *src)
474 {
475  AVPacket *ret = av_packet_alloc();
476 
477  if (!ret)
478  return ret;
479 
480  if (av_packet_ref(ret, src))
481  av_packet_free(&ret);
482 
483  return ret;
484 }
485 
486  void av_packet_move_ref(AVPacket *dst, AVPacket *src)
487 {
488  *dst = *src;
489  get_packet_defaults(src);
490 }
491 
492  int av_packet_make_refcounted(AVPacket *pkt)
493 {
494  int ret;
495 
496  if (pkt->buf)
497  return 0;
498 
499  ret = packet_alloc(&pkt->buf, pkt->size);
500  if (ret < 0)
501  return ret;
502  av_assert1(!pkt->size || pkt->data);
503  if (pkt->size)
504  memcpy(pkt->buf->data, pkt->data, pkt->size);
505 
506  pkt->data = pkt->buf->data;
507 
508  return 0;
509 }
510 
511  int av_packet_make_writable(AVPacket *pkt)
512 {
513  AVBufferRef *buf = NULL;
514  int ret;
515 
516  if (pkt->buf && av_buffer_is_writable(pkt->buf))
517  return 0;
518 
519  ret = packet_alloc(&buf, pkt->size);
520  if (ret < 0)
521  return ret;
522  av_assert1(!pkt->size || pkt->data);
523  if (pkt->size)
524  memcpy(buf->data, pkt->data, pkt->size);
525 
526  av_buffer_unref(&pkt->buf);
527  pkt->buf = buf;
528  pkt->data = buf->data;
529 
530  return 0;
531 }
532 
533  void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
534 {
535  if (pkt->pts != AV_NOPTS_VALUE)
536  pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);
537  if (pkt->dts != AV_NOPTS_VALUE)
538  pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);
539  if (pkt->duration > 0)
540  pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
541 }
542 
543  int avpriv_packet_list_put(PacketList *packet_buffer,
544  AVPacket *pkt,
545  int (*copy)(AVPacket *dst, const AVPacket *src),
546  int flags)
547 {
548  PacketListEntry *pktl = av_malloc(sizeof(*pktl));
549  int ret;
550 
551  if (!pktl)
552  return AVERROR(ENOMEM);
553 
554  if (copy) {
555  get_packet_defaults(&pktl->pkt);
556  ret = copy(&pktl->pkt, pkt);
557  if (ret < 0) {
558  av_free(pktl);
559  return ret;
560  }
561  } else {
562  ret = av_packet_make_refcounted(pkt);
563  if (ret < 0) {
564  av_free(pktl);
565  return ret;
566  }
567  av_packet_move_ref(&pktl->pkt, pkt);
568  }
569 
570  pktl->next = NULL;
571 
572  if (packet_buffer->head)
573  packet_buffer->tail->next = pktl;
574  else
575  packet_buffer->head = pktl;
576 
577  /* Add the packet in the buffered packet list. */
578  packet_buffer->tail = pktl;
579  return 0;
580 }
581 
582  int avpriv_packet_list_get(PacketList *pkt_buffer,
583  AVPacket *pkt)
584 {
585  PacketListEntry *pktl = pkt_buffer->head;
586  if (!pktl)
587  return AVERROR(EAGAIN);
588  *pkt = pktl->pkt;
589  pkt_buffer->head = pktl->next;
590  if (!pkt_buffer->head)
591  pkt_buffer->tail = NULL;
592  av_freep(&pktl);
593  return 0;
594 }
595 
596  void avpriv_packet_list_free(PacketList *pkt_buf)
597 {
598  PacketListEntry *tmp = pkt_buf->head;
599 
600  while (tmp) {
601  PacketListEntry *pktl = tmp;
602  tmp = pktl->next;
603  av_packet_unref(&pktl->pkt);
604  av_freep(&pktl);
605  }
606  pkt_buf->head = pkt_buf->tail = NULL;
607 }
608 
609  int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
610 {
611  uint8_t *side_data;
612  size_t side_data_size;
613  int i;
614 
615  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS, &side_data_size);
616  if (!side_data) {
617  side_data_size = 4+4+8*error_count;
618  side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
619  side_data_size);
620  }
621 
622  if (!side_data || side_data_size < 4+4+8*error_count)
623  return AVERROR(ENOMEM);
624 
625  AV_WL32(side_data , quality );
626  side_data[4] = pict_type;
627  side_data[5] = error_count;
628  for (i = 0; i<error_count; i++)
629  AV_WL64(side_data+8 + 8*i , error[i]);
630 
631  return 0;
632 }
633 
634  int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
635 {
636  AVProducerReferenceTime *prft;
637  uint8_t *side_data;
638  size_t side_data_size;
639 
640  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);
641  if (!side_data) {
642  side_data_size = sizeof(AVProducerReferenceTime);
643  side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_PRFT, side_data_size);
644  }
645 
646  if (!side_data || side_data_size < sizeof(AVProducerReferenceTime))
647  return AVERROR(ENOMEM);
648 
649  prft = (AVProducerReferenceTime *)side_data;
650  prft->wallclock = timestamp;
651  prft->flags = 0;
652 
653  return 0;
654 }
655 
656  const AVPacketSideData *av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd,
657  enum AVPacketSideDataType type)
658 {
659  for (int i = 0; i < nb_sd; i++)
660  if (sd[i].type == type)
661  return &sd[i];
662 
663  return NULL;
664 }
665 
666  static AVPacketSideData *packet_side_data_add(AVPacketSideData **psd, int *pnb_sd,
667  enum AVPacketSideDataType type,
668  void *data, size_t size)
669 {
670  AVPacketSideData *sd = *psd, *tmp;
671  int nb_sd = *pnb_sd;
672 
673  for (int i = 0; i < nb_sd; i++) {
674  if (sd[i].type != type)
675  continue;
676 
677  av_free(sd[i].data);
678  sd[i].data = data;
679  sd[i].size = size;
680  return &sd[i];
681  }
682 
683  if (nb_sd == INT_MAX)
684  return NULL;
685 
686  tmp = av_realloc_array(sd, nb_sd + 1, sizeof(*tmp));
687  if (!tmp)
688  return NULL;
689 
690  *psd = sd = tmp;
691  sd[nb_sd].type = type;
692  sd[nb_sd].data = data;
693  sd[nb_sd].size = size;
694  *pnb_sd = nb_sd + 1;
695 
696  return &sd[nb_sd];
697 }
698 
699  AVPacketSideData *av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd,
700  enum AVPacketSideDataType type,
701  void *data, size_t size, int flags)
702 {
703  return packet_side_data_add(psd, pnb_sd, type, data, size);
704 }
705 
706  AVPacketSideData *av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd,
707  enum AVPacketSideDataType type,
708  size_t size, int flags)
709 {
710  AVPacketSideData *sd = NULL;
711  uint8_t *data;
712 
713  if (size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
714  return NULL;
715 
716  data = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
717  if (!data)
718  return NULL;
719  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
720 
721  sd = packet_side_data_add(psd, pnb_sd, type, data, size);
722  if (!sd)
723  av_freep(&data);
724 
725  return sd;
726 }
727 
728  void av_packet_side_data_remove(AVPacketSideData *sd, int *pnb_sd,
729  enum AVPacketSideDataType type)
730 {
731  int nb_sd = *pnb_sd;
732 
733  for (int i = nb_sd - 1; i >= 0; i--) {
734  if (sd[i].type != type)
735  continue;
736  av_free(sd[i].data);
737  sd[i] = sd[--nb_sd];
738  break;
739  }
740 
741  *pnb_sd = nb_sd;
742 }
743 
744  void av_packet_side_data_free(AVPacketSideData **psd, int *pnb_sd)
745 {
746  AVPacketSideData *sd = *psd;
747  int nb_sd = *pnb_sd;
748 
749  for (int i = 0; i < nb_sd; i++)
750  av_free(sd[i].data);
751 
752  av_freep(psd);
753  *pnb_sd = 0;
754 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
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:105
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:327
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_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:129
AV_PKT_DATA_FRAME_CROPPING
@ AV_PKT_DATA_FRAME_CROPPING
The number of pixels to discard from the top/bottom/left/right border of the decoded frame to obtain ...
Definition: packet.h:340
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
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:219
rational.h
int64_t
long long int64_t
Definition: coverity.c:34
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: packet.c:121
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
AVProducerReferenceTime::wallclock
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Definition: defs.h:324
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_PKT_DATA_ENCRYPTION_INIT_INFO
@ AV_PKT_DATA_ENCRYPTION_INIT_INFO
This side data is encryption initialization data.
Definition: packet.h:246
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: packet.c:376
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:137
PacketList
Definition: packet_internal.h:33
data
const char data[16]
Definition: mxf.c:148
av_packet_side_data_remove
void av_packet_side_data_remove(AVPacketSideData *sd, int *pnb_sd, enum AVPacketSideDataType type)
Remove side data of the given type from a side data array.
Definition: packet.c:728
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:288
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
mathematics.h
AVDictionary
Definition: dict.c:34
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_packet_free_side_data
void av_packet_free_side_data(AVPacket *pkt)
Convenience function to free all the side data stored.
Definition: packet.c:188
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
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
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:280
AVPacketSideData::size
size_t size
Definition: packet.h:392
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:96
AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM
@ AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM
IAMF Recon Gain Info Parameter Data associated with the audio frame.
Definition: packet.h:320
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: packet.c:197
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
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
fail
#define fail()
Definition: checkasm.h:188
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
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: packet.c:582
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_WEBVTT_SETTINGS
@ AV_PKT_DATA_WEBVTT_SETTINGS
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:199
avassert.h
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:69
pkt
AVPacket * pkt
Definition: movenc.c:60
av_packet_side_data_name
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: packet.c:269
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: packet.c:98
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVDictionaryEntry::key
char * key
Definition: dict.h:90
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:40
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
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:111
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
AV_PKT_DATA_SUBTITLE_POSITION
@ AV_PKT_DATA_SUBTITLE_POSITION
Subtitle event position.
Definition: packet.h:180
AV_PKT_DATA_LCEVC
@ AV_PKT_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: packet.h:346
packet_side_data_add
static AVPacketSideData * packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size)
Definition: packet.c:666
key
const char * key
Definition: hwcontext_opencl.c:189
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
av_packet_side_data_free
void av_packet_side_data_free(AVPacketSideData **psd, int *pnb_sd)
Convenience function to free all the side data stored in an array, and the array itself.
Definition: packet.c:744
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
avpriv_packet_list_free
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
Definition: packet.c:596
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
NULL
#define NULL
Definition: coverity.c:32
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
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: packet.c:543
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:393
AVProducerReferenceTime
This structure supplies correlation between a packet timestamp and a wall clock production time.
Definition: defs.h:320
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: packet.c:437
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:486
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:29
AVProducerReferenceTime::flags
int flags
Definition: defs.h:325
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:232
packet_alloc
static int packet_alloc(AVBufferRef **buf, int size)
Definition: packet.c:83
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_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:356
av_packet_side_data_get
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
Definition: packet.c:656
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:225
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: packet.c:172
AVPacket::size
int size
Definition: packet.h:540
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:296
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_PKT_DATA_METADATA_UPDATE
@ AV_PKT_DATA_METADATA_UPDATE
A list of zero terminated key/value strings.
Definition: packet.h:206
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
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: packet.c:349
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
AV_WL64
#define AV_WL64(p, v)
Definition: intreadwrite.h:436
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c:699
AV_PKT_DATA_PRFT
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
Definition: packet.h:265
av_packet_pack_dictionary
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: packet.c:314
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: packet.c:492
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
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: packet.c:533
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:169
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: packet.c:392
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:142
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:90
PacketListEntry
Definition: packet_internal.h:28
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
get_packet_defaults
static void get_packet_defaults(AVPacket *pkt)
Definition: packet.c:53
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: packet.c:252
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:271
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
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:256
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:212
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
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
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:188
ret
ret
Definition: filter_design.txt:187
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:163
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: packet.c:706
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:550
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_PKT_DATA_WEBVTT_IDENTIFIER
@ AV_PKT_DATA_WEBVTT_IDENTIFIER
The optional first identifier line of a WebVTT cue.
Definition: packet.h:193
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: packet.c:231
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: packet.c:511
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:258
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
AVPacket::stream_index
int stream_index
Definition: packet.h:541
ff_side_data_set_prft
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: packet.c:634
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
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:252
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:117
avutil.h
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:239
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVPacket
This structure stores compressed data.
Definition: packet.h:516
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:88
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
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: packet.c:609
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_PKT_DATA_IAMF_MIX_GAIN_PARAM
@ AV_PKT_DATA_IAMF_MIX_GAIN_PARAM
IAMF Mix Gain Parameter Data associated with the audio frame.
Definition: packet.h:304
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
src
#define src
Definition: vp8dsp.c:248
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:583
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:551
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
av_packet_clone
AVPacket * av_packet_clone(const AVPacket *src)
Create a new packet that references the same data as src.
Definition: packet.c:473
AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM
@ AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM
IAMF Demixing Info Parameter Data associated with the audio frame.
Definition: packet.h:312
Generated on Fri Aug 22 2025 13:58:45 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /