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