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/common.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/mem.h"
29 
30 #include "bytestream.h"
31 #include "internal.h"
32 #include "packet.h"
33 #include "packet_internal.h"
34 
36 {
37  pkt->pts = AV_NOPTS_VALUE;
38  pkt->dts = AV_NOPTS_VALUE;
39  pkt->pos = -1;
40  pkt->duration = 0;
41 #if FF_API_CONVERGENCE_DURATION
43  pkt->convergence_duration = 0;
45 #endif
46  pkt->flags = 0;
47  pkt->stream_index = 0;
48  pkt->buf = NULL;
49  pkt->side_data = NULL;
50  pkt->side_data_elems = 0;
51 }
52 
54 {
55  AVPacket *pkt = av_mallocz(sizeof(AVPacket));
56  if (!pkt)
57  return pkt;
58 
59  av_init_packet(pkt);
60 
61  return pkt;
62 }
63 
65 {
66  if (!pkt || !*pkt)
67  return;
68 
69  av_packet_unref(*pkt);
70  av_freep(pkt);
71 }
72 
73 static int packet_alloc(AVBufferRef **buf, int size)
74 {
75  int ret;
77  return AVERROR(EINVAL);
78 
80  if (ret < 0)
81  return ret;
82 
83  memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
84 
85  return 0;
86 }
87 
89 {
90  AVBufferRef *buf = NULL;
91  int ret = packet_alloc(&buf, size);
92  if (ret < 0)
93  return ret;
94 
95  av_init_packet(pkt);
96  pkt->buf = buf;
97  pkt->data = buf->data;
98  pkt->size = size;
99 
100  return 0;
101 }
102 
104 {
105  if (pkt->size <= size)
106  return;
107  pkt->size = size;
108  memset(pkt->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
109 }
110 
111 int av_grow_packet(AVPacket *pkt, int grow_by)
112 {
113  int new_size;
114  av_assert0((unsigned)pkt->size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
115  if ((unsigned)grow_by >
116  INT_MAX - (pkt->size + AV_INPUT_BUFFER_PADDING_SIZE))
117  return AVERROR(ENOMEM);
118 
119  new_size = pkt->size + grow_by + AV_INPUT_BUFFER_PADDING_SIZE;
120  if (pkt->buf) {
121  size_t data_offset;
122  uint8_t *old_data = pkt->data;
123  if (pkt->data == NULL) {
124  data_offset = 0;
125  pkt->data = pkt->buf->data;
126  } else {
127  data_offset = pkt->data - pkt->buf->data;
128  if (data_offset > INT_MAX - new_size)
129  return AVERROR(ENOMEM);
130  }
131 
132  if (new_size + data_offset > pkt->buf->size ||
133  !av_buffer_is_writable(pkt->buf)) {
134  int ret = av_buffer_realloc(&pkt->buf, new_size + data_offset);
135  if (ret < 0) {
136  pkt->data = old_data;
137  return ret;
138  }
139  pkt->data = pkt->buf->data + data_offset;
140  }
141  } else {
142  pkt->buf = av_buffer_alloc(new_size);
143  if (!pkt->buf)
144  return AVERROR(ENOMEM);
145  if (pkt->size > 0)
146  memcpy(pkt->buf->data, pkt->data, pkt->size);
147  pkt->data = pkt->buf->data;
148  }
149  pkt->size += grow_by;
150  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
151 
152  return 0;
153 }
154 
156 {
157  if (size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
158  return AVERROR(EINVAL);
159 
162  if (!pkt->buf)
163  return AVERROR(ENOMEM);
164 
165  pkt->data = data;
166  pkt->size = size;
167 
168  return 0;
169 }
170 
171 #if FF_API_AVPACKET_OLD_API
173 #define ALLOC_MALLOC(data, size) data = av_malloc(size)
174 #define ALLOC_BUF(data, size) \
175 do { \
176  av_buffer_realloc(&pkt->buf, size); \
177  data = pkt->buf ? pkt->buf->data : NULL; \
178 } while (0)
179 
180 #define DUP_DATA(dst, src, size, padding, ALLOC) \
181  do { \
182  void *data; \
183  if (padding) { \
184  if ((unsigned)(size) > \
185  (unsigned)(size) + AV_INPUT_BUFFER_PADDING_SIZE) \
186  goto failed_alloc; \
187  ALLOC(data, size + AV_INPUT_BUFFER_PADDING_SIZE); \
188  } else { \
189  ALLOC(data, size); \
190  } \
191  if (!data) \
192  goto failed_alloc; \
193  memcpy(data, src, size); \
194  if (padding) \
195  memset((uint8_t *)data + size, 0, \
196  AV_INPUT_BUFFER_PADDING_SIZE); \
197  dst = data; \
198  } while (0)
199 
200 /* Makes duplicates of data, side_data, but does not copy any other fields */
201 static int copy_packet_data(AVPacket *pkt, const AVPacket *src, int dup)
202 {
203  pkt->data = NULL;
204  pkt->side_data = NULL;
205  pkt->side_data_elems = 0;
206  if (pkt->buf) {
207  AVBufferRef *ref = av_buffer_ref(src->buf);
208  if (!ref)
209  return AVERROR(ENOMEM);
210  pkt->buf = ref;
211  pkt->data = ref->data;
212  } else {
213  DUP_DATA(pkt->data, src->data, pkt->size, 1, ALLOC_BUF);
214  }
215  if (src->side_data_elems && dup) {
216  pkt->side_data = src->side_data;
217  pkt->side_data_elems = src->side_data_elems;
218  }
219  if (src->side_data_elems && !dup) {
220  return av_copy_packet_side_data(pkt, src);
221  }
222  return 0;
223 
224 failed_alloc:
225  av_packet_unref(pkt);
226  return AVERROR(ENOMEM);
227 }
228 
230 {
231  if (src->side_data_elems) {
232  int i;
233  DUP_DATA(pkt->side_data, src->side_data,
234  src->side_data_elems * sizeof(*src->side_data), 0, ALLOC_MALLOC);
235  if (src != pkt) {
236  memset(pkt->side_data, 0,
237  src->side_data_elems * sizeof(*src->side_data));
238  }
239  for (i = 0; i < src->side_data_elems; i++) {
240  DUP_DATA(pkt->side_data[i].data, src->side_data[i].data,
241  src->side_data[i].size, 1, ALLOC_MALLOC);
242  pkt->side_data[i].size = src->side_data[i].size;
243  pkt->side_data[i].type = src->side_data[i].type;
244  }
245  }
246  pkt->side_data_elems = src->side_data_elems;
247  return 0;
248 
249 failed_alloc:
250  av_packet_unref(pkt);
251  return AVERROR(ENOMEM);
252 }
253 
255 {
256  AVPacket tmp_pkt;
257 
258  if (!pkt->buf && pkt->data) {
259  tmp_pkt = *pkt;
260  return copy_packet_data(pkt, &tmp_pkt, 1);
261  }
262  return 0;
263 }
264 
266 {
267  *dst = *src;
268  return copy_packet_data(dst, src, 0);
269 }
271 #endif
272 
274 {
275  int i;
276  for (i = 0; i < pkt->side_data_elems; i++)
277  av_freep(&pkt->side_data[i].data);
278  av_freep(&pkt->side_data);
279  pkt->side_data_elems = 0;
280 }
281 
282 #if FF_API_AVPACKET_OLD_API
285 {
286  if (pkt) {
287  if (pkt->buf)
288  av_buffer_unref(&pkt->buf);
289  pkt->data = NULL;
290  pkt->size = 0;
291 
293  }
294 }
296 #endif
297 
299  uint8_t *data, size_t size)
300 {
302  int i, elems = pkt->side_data_elems;
303 
304  for (i = 0; i < elems; i++) {
305  AVPacketSideData *sd = &pkt->side_data[i];
306 
307  if (sd->type == type) {
308  av_free(sd->data);
309  sd->data = data;
310  sd->size = size;
311  return 0;
312  }
313  }
314 
315  if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
316  return AVERROR(ERANGE);
317 
318  tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
319  if (!tmp)
320  return AVERROR(ENOMEM);
321 
322  pkt->side_data = tmp;
323  pkt->side_data[elems].data = data;
324  pkt->side_data[elems].size = size;
325  pkt->side_data[elems].type = type;
326  pkt->side_data_elems++;
327 
328  return 0;
329 }
330 
331 
333  int size)
334 {
335  int ret;
336  uint8_t *data;
337 
338  if ((unsigned)size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
339  return NULL;
341  if (!data)
342  return NULL;
343 
344  ret = av_packet_add_side_data(pkt, type, data, size);
345  if (ret < 0) {
346  av_freep(&data);
347  return NULL;
348  }
349 
350  return data;
351 }
352 
354  int *size)
355 {
356  int i;
357 
358  for (i = 0; i < pkt->side_data_elems; i++) {
359  if (pkt->side_data[i].type == type) {
360  if (size)
361  *size = pkt->side_data[i].size;
362  return pkt->side_data[i].data;
363  }
364  }
365  if (size)
366  *size = 0;
367  return NULL;
368 }
369 
371 {
372  switch(type) {
373  case AV_PKT_DATA_PALETTE: return "Palette";
374  case AV_PKT_DATA_NEW_EXTRADATA: return "New Extradata";
375  case AV_PKT_DATA_PARAM_CHANGE: return "Param Change";
376  case AV_PKT_DATA_H263_MB_INFO: return "H263 MB Info";
377  case AV_PKT_DATA_REPLAYGAIN: return "Replay Gain";
378  case AV_PKT_DATA_DISPLAYMATRIX: return "Display Matrix";
379  case AV_PKT_DATA_STEREO3D: return "Stereo 3D";
380  case AV_PKT_DATA_AUDIO_SERVICE_TYPE: return "Audio Service Type";
381  case AV_PKT_DATA_QUALITY_STATS: return "Quality stats";
382  case AV_PKT_DATA_FALLBACK_TRACK: return "Fallback track";
383  case AV_PKT_DATA_CPB_PROPERTIES: return "CPB properties";
384  case AV_PKT_DATA_SKIP_SAMPLES: return "Skip Samples";
385  case AV_PKT_DATA_JP_DUALMONO: return "JP Dual Mono";
386  case AV_PKT_DATA_STRINGS_METADATA: return "Strings Metadata";
387  case AV_PKT_DATA_SUBTITLE_POSITION: return "Subtitle Position";
388  case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL: return "Matroska BlockAdditional";
389  case AV_PKT_DATA_WEBVTT_IDENTIFIER: return "WebVTT ID";
390  case AV_PKT_DATA_WEBVTT_SETTINGS: return "WebVTT Settings";
391  case AV_PKT_DATA_METADATA_UPDATE: return "Metadata Update";
392  case AV_PKT_DATA_MPEGTS_STREAM_ID: return "MPEGTS Stream ID";
393  case AV_PKT_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
394  case AV_PKT_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
395  case AV_PKT_DATA_SPHERICAL: return "Spherical Mapping";
396  case AV_PKT_DATA_A53_CC: return "A53 Closed Captions";
397  case AV_PKT_DATA_ENCRYPTION_INIT_INFO: return "Encryption initialization data";
398  case AV_PKT_DATA_ENCRYPTION_INFO: return "Encryption info";
399  case AV_PKT_DATA_AFD: return "Active Format Description data";
400  case AV_PKT_DATA_PRFT: return "Producer Reference Time";
401  case AV_PKT_DATA_ICC_PROFILE: return "ICC Profile";
402  case AV_PKT_DATA_DOVI_CONF: return "DOVI configuration record";
403  case AV_PKT_DATA_S12M_TIMECODE: return "SMPTE ST 12-1:2014 timecode";
404  }
405  return NULL;
406 }
407 
408 #if FF_API_MERGE_SD_API
409 
410 #define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
411 
413  if(pkt->side_data_elems){
414  AVBufferRef *buf;
415  int i;
416  uint8_t *p;
417  uint64_t size= pkt->size + 8LL + AV_INPUT_BUFFER_PADDING_SIZE;
418  AVPacket old= *pkt;
419  for (i=0; i<old.side_data_elems; i++) {
420  size += old.side_data[i].size + 5LL;
421  }
422  if (size > INT_MAX)
423  return AVERROR(EINVAL);
424  buf = av_buffer_alloc(size);
425  if (!buf)
426  return AVERROR(ENOMEM);
427  pkt->buf = buf;
428  pkt->data = p = buf->data;
429  pkt->size = size - AV_INPUT_BUFFER_PADDING_SIZE;
430  bytestream_put_buffer(&p, old.data, old.size);
431  for (i=old.side_data_elems-1; i>=0; i--) {
432  bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);
433  bytestream_put_be32(&p, old.side_data[i].size);
434  *p++ = old.side_data[i].type | ((i==old.side_data_elems-1)*128);
435  }
436  bytestream_put_be64(&p, FF_MERGE_MARKER);
437  av_assert0(p-pkt->data == pkt->size);
438  memset(p, 0, AV_INPUT_BUFFER_PADDING_SIZE);
439  av_packet_unref(&old);
440  pkt->side_data_elems = 0;
441  pkt->side_data = NULL;
442  return 1;
443  }
444  return 0;
445 }
446 
448  if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
449  int i;
450  unsigned int size;
451  uint8_t *p;
452 
453  p = pkt->data + pkt->size - 8 - 5;
454  for (i=1; ; i++){
455  size = AV_RB32(p);
456  if (size>INT_MAX - 5 || p - pkt->data < size)
457  return 0;
458  if (p[4]&128)
459  break;
460  if (p - pkt->data < size + 5)
461  return 0;
462  p-= size+5;
463  }
464 
465  if (i > AV_PKT_DATA_NB)
466  return AVERROR(ERANGE);
467 
468  pkt->side_data = av_malloc_array(i, sizeof(*pkt->side_data));
469  if (!pkt->side_data)
470  return AVERROR(ENOMEM);
471 
472  p= pkt->data + pkt->size - 8 - 5;
473  for (i=0; ; i++){
474  size= AV_RB32(p);
477  pkt->side_data[i].size = size;
478  pkt->side_data[i].type = p[4]&127;
479  if (!pkt->side_data[i].data)
480  return AVERROR(ENOMEM);
481  memcpy(pkt->side_data[i].data, p-size, size);
482  pkt->size -= size + 5;
483  if(p[4]&128)
484  break;
485  p-= size+5;
486  }
487  pkt->size -= 8;
488  pkt->side_data_elems = i+1;
489  return 1;
490  }
491  return 0;
492 }
493 #endif
494 
496 {
497  AVDictionaryEntry *t = NULL;
498  uint8_t *data = NULL;
499  *size = 0;
500 
501  if (!dict)
502  return NULL;
503 
504  while ((t = av_dict_get(dict, "", t, AV_DICT_IGNORE_SUFFIX))) {
505  const size_t keylen = strlen(t->key);
506  const size_t valuelen = strlen(t->value);
507  const size_t new_size = *size + keylen + 1 + valuelen + 1;
508  uint8_t *const new_data = av_realloc(data, new_size);
509 
510  if (!new_data)
511  goto fail;
512  data = new_data;
513  if (new_size > INT_MAX)
514  goto fail;
515 
516  memcpy(data + *size, t->key, keylen + 1);
517  memcpy(data + *size + keylen + 1, t->value, valuelen + 1);
518 
519  *size = new_size;
520  }
521 
522  return data;
523 
524 fail:
525  av_freep(&data);
526  *size = 0;
527  return NULL;
528 }
529 
531 {
532  const uint8_t *end;
533  int ret;
534 
535  if (!dict || !data || !size)
536  return 0;
537  end = data + size;
538  if (size && end[-1])
539  return AVERROR_INVALIDDATA;
540  while (data < end) {
541  const uint8_t *key = data;
542  const uint8_t *val = data + strlen(key) + 1;
543 
544  if (val >= end || !*key)
545  return AVERROR_INVALIDDATA;
546 
547  ret = av_dict_set(dict, key, val, 0);
548  if (ret < 0)
549  return ret;
550  data = val + strlen(val) + 1;
551  }
552 
553  return 0;
554 }
555 
557  int size)
558 {
559  int i;
560 
561  for (i = 0; i < pkt->side_data_elems; i++) {
562  if (pkt->side_data[i].type == type) {
563  if (size > pkt->side_data[i].size)
564  return AVERROR(ENOMEM);
565  pkt->side_data[i].size = size;
566  return 0;
567  }
568  }
569  return AVERROR(ENOENT);
570 }
571 
573 {
574  int i;
575 
576  dst->pts = src->pts;
577  dst->dts = src->dts;
578  dst->pos = src->pos;
579  dst->duration = src->duration;
580 #if FF_API_CONVERGENCE_DURATION
582  dst->convergence_duration = src->convergence_duration;
584 #endif
585  dst->flags = src->flags;
586  dst->stream_index = src->stream_index;
587 
588  dst->side_data = NULL;
589  dst->side_data_elems = 0;
590  for (i = 0; i < src->side_data_elems; i++) {
592  int size = src->side_data[i].size;
593  uint8_t *src_data = src->side_data[i].data;
594  uint8_t *dst_data = av_packet_new_side_data(dst, type, size);
595 
596  if (!dst_data) {
598  return AVERROR(ENOMEM);
599  }
600  memcpy(dst_data, src_data, size);
601  }
602 
603  return 0;
604 }
605 
607 {
609  av_buffer_unref(&pkt->buf);
610  av_init_packet(pkt);
611  pkt->data = NULL;
612  pkt->size = 0;
613 }
614 
616 {
617  int ret;
618 
619  dst->buf = NULL;
620 
621  ret = av_packet_copy_props(dst, src);
622  if (ret < 0)
623  goto fail;
624 
625  if (!src->buf) {
626  ret = packet_alloc(&dst->buf, src->size);
627  if (ret < 0)
628  goto fail;
629  av_assert1(!src->size || src->data);
630  if (src->size)
631  memcpy(dst->buf->data, src->data, src->size);
632 
633  dst->data = dst->buf->data;
634  } else {
635  dst->buf = av_buffer_ref(src->buf);
636  if (!dst->buf) {
637  ret = AVERROR(ENOMEM);
638  goto fail;
639  }
640  dst->data = src->data;
641  }
642 
643  dst->size = src->size;
644 
645  return 0;
646 fail:
647  av_packet_unref(dst);
648  return ret;
649 }
650 
652 {
654 
655  if (!ret)
656  return ret;
657 
658  if (av_packet_ref(ret, src))
659  av_packet_free(&ret);
660 
661  return ret;
662 }
663 
665 {
666  *dst = *src;
667  av_init_packet(src);
668  src->data = NULL;
669  src->size = 0;
670 }
671 
673 {
674  int ret;
675 
676  if (pkt->buf)
677  return 0;
678 
679  ret = packet_alloc(&pkt->buf, pkt->size);
680  if (ret < 0)
681  return ret;
682  av_assert1(!pkt->size || pkt->data);
683  if (pkt->size)
684  memcpy(pkt->buf->data, pkt->data, pkt->size);
685 
686  pkt->data = pkt->buf->data;
687 
688  return 0;
689 }
690 
692 {
693  AVBufferRef *buf = NULL;
694  int ret;
695 
696  if (pkt->buf && av_buffer_is_writable(pkt->buf))
697  return 0;
698 
699  ret = packet_alloc(&buf, pkt->size);
700  if (ret < 0)
701  return ret;
702  av_assert1(!pkt->size || pkt->data);
703  if (pkt->size)
704  memcpy(buf->data, pkt->data, pkt->size);
705 
706  av_buffer_unref(&pkt->buf);
707  pkt->buf = buf;
708  pkt->data = buf->data;
709 
710  return 0;
711 }
712 
714 {
715  if (pkt->pts != AV_NOPTS_VALUE)
716  pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);
717  if (pkt->dts != AV_NOPTS_VALUE)
718  pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);
719  if (pkt->duration > 0)
720  pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
721 #if FF_API_CONVERGENCE_DURATION
723  if (pkt->convergence_duration > 0)
724  pkt->convergence_duration = av_rescale_q(pkt->convergence_duration, src_tb, dst_tb);
726 #endif
727 }
728 
730  AVPacketList **plast_pktl,
731  AVPacket *pkt,
732  int (*copy)(AVPacket *dst, const AVPacket *src),
733  int flags)
734 {
735  AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
736  int ret;
737 
738  if (!pktl)
739  return AVERROR(ENOMEM);
740 
741  if (copy) {
742  ret = copy(&pktl->pkt, pkt);
743  if (ret < 0) {
744  av_free(pktl);
745  return ret;
746  }
747  } else {
748  ret = av_packet_make_refcounted(pkt);
749  if (ret < 0) {
750  av_free(pktl);
751  return ret;
752  }
753  av_packet_move_ref(&pktl->pkt, pkt);
754  }
755 
756  if (*packet_buffer)
757  (*plast_pktl)->next = pktl;
758  else
759  *packet_buffer = pktl;
760 
761  /* Add the packet in the buffered packet list. */
762  *plast_pktl = pktl;
763  return 0;
764 }
765 
767  AVPacketList **pkt_buffer_end,
768  AVPacket *pkt)
769 {
770  AVPacketList *pktl;
771  if (!*pkt_buffer)
772  return AVERROR(EAGAIN);
773  pktl = *pkt_buffer;
774  *pkt = pktl->pkt;
775  *pkt_buffer = pktl->next;
776  if (!pktl->next)
777  *pkt_buffer_end = NULL;
778  av_freep(&pktl);
779  return 0;
780 }
781 
782 void avpriv_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
783 {
784  AVPacketList *tmp = *pkt_buf;
785 
786  while (tmp) {
787  AVPacketList *pktl = tmp;
788  tmp = pktl->next;
789  av_packet_unref(&pktl->pkt);
790  av_freep(&pktl);
791  }
792  *pkt_buf = NULL;
793  *pkt_buf_end = NULL;
794 }
795 
796 int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
797 {
798  uint8_t *side_data;
799  int side_data_size;
800  int i;
801 
802  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS, &side_data_size);
803  if (!side_data) {
804  side_data_size = 4+4+8*error_count;
806  side_data_size);
807  }
808 
809  if (!side_data || side_data_size < 4+4+8*error_count)
810  return AVERROR(ENOMEM);
811 
812  AV_WL32(side_data , quality );
813  side_data[4] = pict_type;
814  side_data[5] = error_count;
815  for (i = 0; i<error_count; i++)
816  AV_WL64(side_data+8 + 8*i , error[i]);
817 
818  return 0;
819 }
820 
821 int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
822 {
824  uint8_t *side_data;
825  int side_data_size;
826 
827  side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);
828  if (!side_data) {
829  side_data_size = sizeof(AVProducerReferenceTime);
830  side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_PRFT, side_data_size);
831  }
832 
833  if (!side_data || side_data_size < sizeof(AVProducerReferenceTime))
834  return AVERROR(ENOMEM);
835 
836  prft = (AVProducerReferenceTime *)side_data;
837  prft->wallclock = timestamp;
838  prft->flags = 0;
839 
840  return 0;
841 }
#define NULL
Definition: coverity.c:32
#define DUP_DATA(dst, src, size, padding, ALLOC)
Definition: avpacket.c:180
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
Definition: packet.h:268
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVPacketSideDataType
Definition: packet.h:40
static void copy(const float *p1, float *p2, const int length)
A list of zero terminated key/value strings.
Definition: packet.h:209
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:125
The optional first identifier line of a WebVTT cue.
Definition: packet.h:196
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
Memory handling functions.
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
Subtitle event position.
Definition: packet.h:183
#define ALLOC_MALLOC(data, size)
Definition: avpacket.c:173
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:114
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:242
int size
Definition: packet.h:364
This side data contains an integer value representing the stream index of a "fallback" track...
Definition: packet.h:140
#define ALLOC_BUF(data, size)
Definition: avpacket.c:174
GLint GLenum type
Definition: opengl_enc.c:104
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static AVPacket pkt
static void error(const char *err)
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: packet.h:93
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
uint8_t
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:530
int av_packet_split_side_data(AVPacket *pkt)
Definition: avpacket.c:447
AVPacket pkt
Definition: packet.h:397
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
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:155
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
int av_packet_merge_side_data(AVPacket *pkt)
Definition: avpacket.c:412
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Definition: avcodec.h:502
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
uint8_t * data
Definition: packet.h:363
This side data is encryption initialization data.
Definition: packet.h:249
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:664
uint8_t * data
Definition: packet.h:307
ptrdiff_t size
Definition: opengl_enc.c:100
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:615
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:691
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:62
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:215
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
#define src
Definition: vp8dsp.c:254
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
#define AV_WL64(p, v)
Definition: intreadwrite.h:440
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2 dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3 Tags are stored in struct AVDOVIDecoderConfigurationRecord.
Definition: packet.h:283
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
AVPacket * av_packet_clone(const AVPacket *src)
Create a new packet that references the same data as src.
Definition: avpacket.c:651
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:713
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:72
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
FF_ENABLE_DEPRECATION_WARNINGS void av_packet_free_side_data(AVPacket *pkt)
Convenience function to free all the side data stored.
Definition: avpacket.c:273
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1...
Definition: packet.h:274
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:346
simple assert() macros that are a bit more flexible than ISO C assert().
enum AVPacketSideDataType type
Definition: packet.h:309
int side_data_elems
Definition: packet.h:375
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Shrink the already allocated side data buffer.
Definition: avpacket.c:556
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
#define fail()
Definition: checkasm.h:123
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int av_copy_packet_side_data(AVPacket *pkt, const AVPacket *src)
Definition: avpacket.c:229
common internal API header
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:572
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
This side data contains quality related information from the encoder.
Definition: packet.h:132
static int packet_alloc(AVBufferRef **buf, int size)
Definition: avpacket.c:73
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:672
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:261
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:133
int avpriv_packet_list_put(AVPacketList **packet_buffer, AVPacketList **plast_pktl, AVPacket *pkt, int(*copy)(AVPacket *dst, const AVPacket *src), int flags)
Append an AVPacket to the list.
Definition: avpacket.c:729
Content light level (based on CTA-861.3).
Definition: packet.h:235
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
A list of zero terminated key/value strings.
Definition: packet.h:172
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, int *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:495
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
uint8_t * data
The data buffer.
Definition: buffer.h:89
int avpriv_packet_list_get(AVPacketList **pkt_buffer, AVPacketList **pkt_buffer_end, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:766
Data found in BlockAdditional element of matroska container.
Definition: packet.h:191
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
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Recommmends skipping the specified number of samples.
Definition: packet.h:156
FF_ENABLE_DEPRECATION_WARNINGS 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:298
FF_DISABLE_DEPRECATION_WARNINGS void av_free_packet(AVPacket *pkt)
Definition: avpacket.c:284
This side data contains encryption info for how to decrypt the packet.
Definition: packet.h:255
static int copy_packet_data(AVPacket *pkt, const AVPacket *src, int dup)
Definition: avpacket.c:201
int size
Size of data in bytes.
Definition: buffer.h:93
int av_copy_packet(AVPacket *dst, const AVPacket *src)
Definition: avpacket.c:265
#define flags(name, subs,...)
Definition: cbs_av1.c:560
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:99
#define FF_MERGE_MARKER
Definition: avpacket.c:410
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:291
A reference to a data buffer.
Definition: buffer.h:81
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:87
An AV_PKT_DATA_JP_DUALMONO side data packet indicates that the packet may contain "dual mono" audio s...
Definition: packet.h:166
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:374
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
struct AVPacketList * next
Definition: packet.h:398
common internal and external API header
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:111
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
char * key
Definition: dict.h:86
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:202
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
This structure supplies correlation between a packet timestamp and a wall clock production time...
Definition: avcodec.h:498
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:821
int av_dup_packet(AVPacket *pkt)
Definition: avpacket.c:254
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:53
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
const char * av_packet_side_data_name(enum AVPacketSideDataType type)
Definition: avpacket.c:370
#define av_freep(p)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define av_malloc_array(a, b)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int stream_index
Definition: packet.h:365
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
The number of side data types.
Definition: packet.h:301
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
void avpriv_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
Wipe the list and unref all the packets in it.
Definition: avpacket.c:782
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:120
static uint8_t tmp[11]
Definition: aes_ctr.c:26