FFmpeg
decode.c
Go to the documentation of this file.
1 /*
2  * generic decoding-related code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 #include <string.h>
23 
24 #include "config.h"
25 
26 #if CONFIG_ICONV
27 # include <iconv.h>
28 #endif
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/bprint.h"
33 #include "libavutil/common.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/intmath.h"
39 #include "libavutil/opt.h"
40 
41 #include "avcodec.h"
42 #include "bytestream.h"
43 #include "decode.h"
44 #include "hwconfig.h"
45 #include "internal.h"
46 #include "thread.h"
47 
48 typedef struct FramePool {
49  /**
50  * Pools for each data plane. For audio all the planes have the same size,
51  * so only pools[0] is used.
52  */
54 
55  /*
56  * Pool parameters
57  */
58  int format;
59  int width, height;
61  int linesize[4];
62  int planes;
63  int channels;
64  int samples;
65 } FramePool;
66 
67 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
68 {
69  int ret;
71  const uint8_t *data;
72  uint32_t flags;
73  int64_t val;
74 
76  if (!data)
77  return 0;
78 
79  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
80  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
81  "changes, but PARAM_CHANGE side data was sent to it.\n");
82  ret = AVERROR(EINVAL);
83  goto fail2;
84  }
85 
86  if (size < 4)
87  goto fail;
88 
89  flags = bytestream_get_le32(&data);
90  size -= 4;
91 
93  if (size < 4)
94  goto fail;
95  val = bytestream_get_le32(&data);
96  if (val <= 0 || val > INT_MAX) {
97  av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
98  ret = AVERROR_INVALIDDATA;
99  goto fail2;
100  }
101  avctx->channels = val;
102  size -= 4;
103  }
105  if (size < 8)
106  goto fail;
107  avctx->channel_layout = bytestream_get_le64(&data);
108  size -= 8;
109  }
111  if (size < 4)
112  goto fail;
113  val = bytestream_get_le32(&data);
114  if (val <= 0 || val > INT_MAX) {
115  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
116  ret = AVERROR_INVALIDDATA;
117  goto fail2;
118  }
119  avctx->sample_rate = val;
120  size -= 4;
121  }
123  if (size < 8)
124  goto fail;
125  avctx->width = bytestream_get_le32(&data);
126  avctx->height = bytestream_get_le32(&data);
127  size -= 8;
128  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
129  if (ret < 0)
130  goto fail2;
131  }
132 
133  return 0;
134 fail:
135  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
136  ret = AVERROR_INVALIDDATA;
137 fail2:
138  if (ret < 0) {
139  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
140  if (avctx->err_recognition & AV_EF_EXPLODE)
141  return ret;
142  }
143  return 0;
144 }
145 
146 #define IS_EMPTY(pkt) (!(pkt)->data)
147 
148 static int copy_packet_props(AVPacket *dst, const AVPacket *src)
149 {
150  int ret = av_packet_copy_props(dst, src);
151  if (ret < 0)
152  return ret;
153 
154  dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
155  dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
156 
157  return 0;
158 }
159 
161 {
162  AVPacket tmp = { 0 };
163  int ret = 0;
164 
165  if (IS_EMPTY(avci->last_pkt_props)) {
166  if (av_fifo_size(avci->pkt_props) >= sizeof(*pkt)) {
168  sizeof(*avci->last_pkt_props), NULL);
169  } else
170  return copy_packet_props(avci->last_pkt_props, pkt);
171  }
172 
173  if (av_fifo_space(avci->pkt_props) < sizeof(*pkt)) {
174  ret = av_fifo_grow(avci->pkt_props, sizeof(*pkt));
175  if (ret < 0)
176  return ret;
177  }
178 
179  ret = copy_packet_props(&tmp, pkt);
180  if (ret < 0)
181  return ret;
182 
183  av_fifo_generic_write(avci->pkt_props, &tmp, sizeof(tmp), NULL);
184 
185  return 0;
186 }
187 
189 {
190  AVCodecInternal *avci = avctx->internal;
191  int ret;
192 
193  if (avci->bsf)
194  return 0;
195 
196  ret = av_bsf_list_parse_str(avctx->codec->bsfs, &avci->bsf);
197  if (ret < 0) {
198  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", avctx->codec->bsfs, av_err2str(ret));
199  if (ret != AVERROR(ENOMEM))
200  ret = AVERROR_BUG;
201  goto fail;
202  }
203 
204  /* We do not currently have an API for passing the input timebase into decoders,
205  * but no filters used here should actually need it.
206  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
207  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
208  ret = avcodec_parameters_from_context(avci->bsf->par_in, avctx);
209  if (ret < 0)
210  goto fail;
211 
212  ret = av_bsf_init(avci->bsf);
213  if (ret < 0)
214  goto fail;
215 
216  return 0;
217 fail:
218  av_bsf_free(&avci->bsf);
219  return ret;
220 }
221 
223 {
224  AVCodecInternal *avci = avctx->internal;
225  int ret;
226 
227  if (avci->draining)
228  return AVERROR_EOF;
229 
230  ret = av_bsf_receive_packet(avci->bsf, pkt);
231  if (ret == AVERROR_EOF)
232  avci->draining = 1;
233  if (ret < 0)
234  return ret;
235 
236  ret = extract_packet_props(avctx->internal, pkt);
237  if (ret < 0)
238  goto finish;
239 
240  ret = apply_param_change(avctx, pkt);
241  if (ret < 0)
242  goto finish;
243 
244 #if FF_API_OLD_ENCDEC
245  if (avctx->codec->receive_frame)
246  avci->compat_decode_consumed += pkt->size;
247 #endif
248 
249  return 0;
250 finish:
251  av_packet_unref(pkt);
252  return ret;
253 }
254 
255 /**
256  * Attempt to guess proper monotonic timestamps for decoded video frames
257  * which might have incorrect times. Input timestamps may wrap around, in
258  * which case the output will as well.
259  *
260  * @param pts the pts field of the decoded AVPacket, as passed through
261  * AVFrame.pts
262  * @param dts the dts field of the decoded AVPacket
263  * @return one of the input values, may be AV_NOPTS_VALUE
264  */
266  int64_t reordered_pts, int64_t dts)
267 {
268  int64_t pts = AV_NOPTS_VALUE;
269 
270  if (dts != AV_NOPTS_VALUE) {
272  ctx->pts_correction_last_dts = dts;
273  } else if (reordered_pts != AV_NOPTS_VALUE)
274  ctx->pts_correction_last_dts = reordered_pts;
275 
276  if (reordered_pts != AV_NOPTS_VALUE) {
277  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
278  ctx->pts_correction_last_pts = reordered_pts;
279  } else if(dts != AV_NOPTS_VALUE)
280  ctx->pts_correction_last_pts = dts;
281 
283  && reordered_pts != AV_NOPTS_VALUE)
284  pts = reordered_pts;
285  else
286  pts = dts;
287 
288  return pts;
289 }
290 
291 /*
292  * The core of the receive_frame_wrapper for the decoders implementing
293  * the simple API. Certain decoders might consume partial packets without
294  * returning any output, so this function needs to be called in a loop until it
295  * returns EAGAIN.
296  **/
297 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
298 {
299  AVCodecInternal *avci = avctx->internal;
300  DecodeSimpleContext *ds = &avci->ds;
301  AVPacket *pkt = ds->in_pkt;
302  int got_frame, actual_got_frame;
303  int ret;
304 
305  if (!pkt->data && !avci->draining) {
306  av_packet_unref(pkt);
307  ret = ff_decode_get_packet(avctx, pkt);
308  if (ret < 0 && ret != AVERROR_EOF)
309  return ret;
310  }
311 
312  // Some codecs (at least wma lossless) will crash when feeding drain packets
313  // after EOF was signaled.
314  if (avci->draining_done)
315  return AVERROR_EOF;
316 
317  if (!pkt->data &&
318  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
320  return AVERROR_EOF;
321 
322  got_frame = 0;
323 
324  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
325  ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
326  } else {
327  ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
328 
330  frame->pkt_dts = pkt->dts;
331  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
332  if(!avctx->has_b_frames)
333  frame->pkt_pos = pkt->pos;
334  //FIXME these should be under if(!avctx->has_b_frames)
335  /* get_buffer is supposed to set frame parameters */
336  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
337  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
338  if (!frame->width) frame->width = avctx->width;
339  if (!frame->height) frame->height = avctx->height;
340  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
341  }
342  }
343  }
344  emms_c();
345  actual_got_frame = got_frame;
346 
347  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
348  if (frame->flags & AV_FRAME_FLAG_DISCARD)
349  got_frame = 0;
350  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
351  uint8_t *side;
352  buffer_size_t side_size;
353  uint32_t discard_padding = 0;
354  uint8_t skip_reason = 0;
355  uint8_t discard_reason = 0;
356 
357  if (ret >= 0 && got_frame) {
358  if (frame->format == AV_SAMPLE_FMT_NONE)
359  frame->format = avctx->sample_fmt;
360  if (!frame->channel_layout)
361  frame->channel_layout = avctx->channel_layout;
362  if (!frame->channels)
363  frame->channels = avctx->channels;
364  if (!frame->sample_rate)
365  frame->sample_rate = avctx->sample_rate;
366  }
367 
369  if(side && side_size>=10) {
370  avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
371  discard_padding = AV_RL32(side + 4);
372  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
373  avci->skip_samples, (int)discard_padding);
374  skip_reason = AV_RL8(side + 8);
375  discard_reason = AV_RL8(side + 9);
376  }
377 
378  if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
379  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
380  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
381  got_frame = 0;
382  *discarded_samples += frame->nb_samples;
383  }
384 
385  if (avci->skip_samples > 0 && got_frame &&
386  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
387  if(frame->nb_samples <= avci->skip_samples){
388  got_frame = 0;
389  *discarded_samples += frame->nb_samples;
390  avci->skip_samples -= frame->nb_samples;
391  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
392  avci->skip_samples);
393  } else {
394  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
395  frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
396  if(avctx->pkt_timebase.num && avctx->sample_rate) {
397  int64_t diff_ts = av_rescale_q(avci->skip_samples,
398  (AVRational){1, avctx->sample_rate},
399  avctx->pkt_timebase);
400  if(frame->pts!=AV_NOPTS_VALUE)
401  frame->pts += diff_ts;
402 #if FF_API_PKT_PTS
404  if(frame->pkt_pts!=AV_NOPTS_VALUE)
405  frame->pkt_pts += diff_ts;
407 #endif
408  if(frame->pkt_dts!=AV_NOPTS_VALUE)
409  frame->pkt_dts += diff_ts;
410  if (frame->pkt_duration >= diff_ts)
411  frame->pkt_duration -= diff_ts;
412  } else {
413  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
414  }
415  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
416  avci->skip_samples, frame->nb_samples);
417  *discarded_samples += avci->skip_samples;
418  frame->nb_samples -= avci->skip_samples;
419  avci->skip_samples = 0;
420  }
421  }
422 
423  if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
424  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
425  if (discard_padding == frame->nb_samples) {
426  *discarded_samples += frame->nb_samples;
427  got_frame = 0;
428  } else {
429  if(avctx->pkt_timebase.num && avctx->sample_rate) {
430  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
431  (AVRational){1, avctx->sample_rate},
432  avctx->pkt_timebase);
433  frame->pkt_duration = diff_ts;
434  } else {
435  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
436  }
437  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
438  (int)discard_padding, frame->nb_samples);
439  frame->nb_samples -= discard_padding;
440  }
441  }
442 
443  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
445  if (fside) {
446  AV_WL32(fside->data, avci->skip_samples);
447  AV_WL32(fside->data + 4, discard_padding);
448  AV_WL8(fside->data + 8, skip_reason);
449  AV_WL8(fside->data + 9, discard_reason);
450  avci->skip_samples = 0;
451  }
452  }
453  }
454 
455  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
457  ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
458  av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
459  avci->showed_multi_packet_warning = 1;
460  }
461 
462  if (!got_frame)
463  av_frame_unref(frame);
464 
465  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
466  ret = pkt->size;
467 
468 #if FF_API_AVCTX_TIMEBASE
469  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
470  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
471 #endif
472 
473  /* do not stop draining when actual_got_frame != 0 or ret < 0 */
474  /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
475  if (avci->draining && !actual_got_frame) {
476  if (ret < 0) {
477  /* prevent infinite loop if a decoder wrongly always return error on draining */
478  /* reasonable nb_errors_max = maximum b frames + thread count */
479  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
480  avctx->thread_count : 1);
481 
482  if (avci->nb_draining_errors++ >= nb_errors_max) {
483  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
484  "Stop draining and force EOF.\n");
485  avci->draining_done = 1;
486  ret = AVERROR_BUG;
487  }
488  } else {
489  avci->draining_done = 1;
490  }
491  }
492 
493 #if FF_API_OLD_ENCDEC
494  avci->compat_decode_consumed += ret;
495 #endif
496 
497  if (ret >= pkt->size || ret < 0) {
498  av_packet_unref(pkt);
500  } else {
501  int consumed = ret;
502 
503  pkt->data += consumed;
504  pkt->size -= consumed;
505  avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
506  pkt->pts = AV_NOPTS_VALUE;
507  pkt->dts = AV_NOPTS_VALUE;
510  }
511 
512  if (got_frame)
513  av_assert0(frame->buf[0]);
514 
515  return ret < 0 ? ret : 0;
516 }
517 
519 {
520  int ret;
521  int64_t discarded_samples = 0;
522 
523  while (!frame->buf[0]) {
524  if (discarded_samples > avctx->max_samples)
525  return AVERROR(EAGAIN);
526  ret = decode_simple_internal(avctx, frame, &discarded_samples);
527  if (ret < 0)
528  return ret;
529  }
530 
531  return 0;
532 }
533 
535 {
536  AVCodecInternal *avci = avctx->internal;
537  int ret;
538 
539  av_assert0(!frame->buf[0]);
540 
541  if (avctx->codec->receive_frame) {
542  ret = avctx->codec->receive_frame(avctx, frame);
543  if (ret != AVERROR(EAGAIN))
545  } else
546  ret = decode_simple_receive_frame(avctx, frame);
547 
548  if (ret == AVERROR_EOF)
549  avci->draining_done = 1;
550 
551  if (!ret) {
553  frame->pts,
554  frame->pkt_dts);
555 
556  /* the only case where decode data is not set should be decoders
557  * that do not call ff_get_buffer() */
558  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
559  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
560 
561  if (frame->private_ref) {
563 
564  if (fdd->post_process) {
565  ret = fdd->post_process(avctx, frame);
566  if (ret < 0) {
567  av_frame_unref(frame);
568  return ret;
569  }
570  }
571  }
572  }
573 
574  /* free the per-frame decode data */
575  av_buffer_unref(&frame->private_ref);
576 
577  return ret;
578 }
579 
580 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
581 {
582  AVCodecInternal *avci = avctx->internal;
583  int ret;
584 
585  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
586  return AVERROR(EINVAL);
587 
588  if (avctx->internal->draining)
589  return AVERROR_EOF;
590 
591  if (avpkt && !avpkt->size && avpkt->data)
592  return AVERROR(EINVAL);
593 
595  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
596  ret = av_packet_ref(avci->buffer_pkt, avpkt);
597  if (ret < 0)
598  return ret;
599  }
600 
601  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
602  if (ret < 0) {
604  return ret;
605  }
606 
607  if (!avci->buffer_frame->buf[0]) {
608  ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
609  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
610  return ret;
611  }
612 
613  return 0;
614 }
615 
617 {
618  /* make sure we are noisy about decoders returning invalid cropping data */
619  if (frame->crop_left >= INT_MAX - frame->crop_right ||
620  frame->crop_top >= INT_MAX - frame->crop_bottom ||
621  (frame->crop_left + frame->crop_right) >= frame->width ||
622  (frame->crop_top + frame->crop_bottom) >= frame->height) {
623  av_log(avctx, AV_LOG_WARNING,
624  "Invalid cropping information set by a decoder: "
626  "(frame size %dx%d). This is a bug, please report it\n",
627  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
628  frame->width, frame->height);
629  frame->crop_left = 0;
630  frame->crop_right = 0;
631  frame->crop_top = 0;
632  frame->crop_bottom = 0;
633  return 0;
634  }
635 
636  if (!avctx->apply_cropping)
637  return 0;
638 
639  return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
641 }
642 
643 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
644 {
645  AVCodecInternal *avci = avctx->internal;
646  int ret, changed;
647 
648  av_frame_unref(frame);
649 
650  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
651  return AVERROR(EINVAL);
652 
653  if (avci->buffer_frame->buf[0]) {
654  av_frame_move_ref(frame, avci->buffer_frame);
655  } else {
656  ret = decode_receive_frame_internal(avctx, frame);
657  if (ret < 0)
658  return ret;
659  }
660 
661  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
662  ret = apply_cropping(avctx, frame);
663  if (ret < 0) {
664  av_frame_unref(frame);
665  return ret;
666  }
667  }
668 
669  avctx->frame_number++;
670 
671  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
672 
673  if (avctx->frame_number == 1) {
674  avci->initial_format = frame->format;
675  switch(avctx->codec_type) {
676  case AVMEDIA_TYPE_VIDEO:
677  avci->initial_width = frame->width;
678  avci->initial_height = frame->height;
679  break;
680  case AVMEDIA_TYPE_AUDIO:
681  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
682  avctx->sample_rate;
683  avci->initial_channels = frame->channels;
684  avci->initial_channel_layout = frame->channel_layout;
685  break;
686  }
687  }
688 
689  if (avctx->frame_number > 1) {
690  changed = avci->initial_format != frame->format;
691 
692  switch(avctx->codec_type) {
693  case AVMEDIA_TYPE_VIDEO:
694  changed |= avci->initial_width != frame->width ||
695  avci->initial_height != frame->height;
696  break;
697  case AVMEDIA_TYPE_AUDIO:
698  changed |= avci->initial_sample_rate != frame->sample_rate ||
699  avci->initial_sample_rate != avctx->sample_rate ||
700  avci->initial_channels != frame->channels ||
701  avci->initial_channel_layout != frame->channel_layout;
702  break;
703  }
704 
705  if (changed) {
706  avci->changed_frames_dropped++;
707  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
708  " drop count: %d \n",
709  avctx->frame_number, frame->pts,
710  avci->changed_frames_dropped);
711  av_frame_unref(frame);
712  return AVERROR_INPUT_CHANGED;
713  }
714  }
715  }
716  return 0;
717 }
718 
719 #if FF_API_OLD_ENCDEC
722 {
723  int ret;
724 
725  /* move the original frame to our backup */
726  av_frame_unref(avci->to_free);
727  av_frame_move_ref(avci->to_free, frame);
728 
729  /* now copy everything except the AVBufferRefs back
730  * note that we make a COPY of the side data, so calling av_frame_free() on
731  * the caller's frame will work properly */
732  ret = av_frame_copy_props(frame, avci->to_free);
733  if (ret < 0)
734  return ret;
735 
736  memcpy(frame->data, avci->to_free->data, sizeof(frame->data));
737  memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
738  if (avci->to_free->extended_data != avci->to_free->data) {
739  int planes = avci->to_free->channels;
740  int size = planes * sizeof(*frame->extended_data);
741 
742  if (!size) {
743  av_frame_unref(frame);
744  return AVERROR_BUG;
745  }
746 
747  frame->extended_data = av_malloc(size);
748  if (!frame->extended_data) {
749  av_frame_unref(frame);
750  return AVERROR(ENOMEM);
751  }
752  memcpy(frame->extended_data, avci->to_free->extended_data,
753  size);
754  } else
755  frame->extended_data = frame->data;
756 
757  frame->format = avci->to_free->format;
758  frame->width = avci->to_free->width;
759  frame->height = avci->to_free->height;
760  frame->channel_layout = avci->to_free->channel_layout;
761  frame->nb_samples = avci->to_free->nb_samples;
762  frame->channels = avci->to_free->channels;
763 
764  return 0;
765 }
766 
768  int *got_frame, const AVPacket *pkt)
769 {
770  AVCodecInternal *avci = avctx->internal;
771  int ret = 0;
772 
774 
775  if (avci->draining_done && pkt && pkt->size != 0) {
776  av_log(avctx, AV_LOG_WARNING, "Got unexpected packet after EOF\n");
777  avcodec_flush_buffers(avctx);
778  }
779 
780  *got_frame = 0;
781 
782  if (avci->compat_decode_partial_size > 0 &&
783  avci->compat_decode_partial_size != pkt->size) {
784  av_log(avctx, AV_LOG_ERROR,
785  "Got unexpected packet size after a partial decode\n");
786  ret = AVERROR(EINVAL);
787  goto finish;
788  }
789 
790  if (!avci->compat_decode_partial_size) {
791  ret = avcodec_send_packet(avctx, pkt);
792  if (ret == AVERROR_EOF)
793  ret = 0;
794  else if (ret == AVERROR(EAGAIN)) {
795  /* we fully drain all the output in each decode call, so this should not
796  * ever happen */
797  ret = AVERROR_BUG;
798  goto finish;
799  } else if (ret < 0)
800  goto finish;
801  }
802 
803  while (ret >= 0) {
804  ret = avcodec_receive_frame(avctx, frame);
805  if (ret < 0) {
806  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
807  ret = 0;
808  goto finish;
809  }
810 
811  if (frame != avci->compat_decode_frame) {
812  if (!avctx->refcounted_frames) {
813  ret = unrefcount_frame(avci, frame);
814  if (ret < 0)
815  goto finish;
816  }
817 
818  *got_frame = 1;
819  frame = avci->compat_decode_frame;
820  } else {
821  if (!avci->compat_decode_warned) {
822  av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_decode_* "
823  "API cannot return all the frames for this decoder. "
824  "Some frames will be dropped. Update your code to the "
825  "new decoding API to fix this.\n");
826  avci->compat_decode_warned = 1;
827  }
828  }
829 
830  if (avci->draining || (!avctx->codec->bsfs && avci->compat_decode_consumed < pkt->size))
831  break;
832  }
833 
834 finish:
835  if (ret == 0) {
836  /* if there are any bsfs then assume full packet is always consumed */
837  if (avctx->codec->bsfs)
838  ret = pkt->size;
839  else
840  ret = FFMIN(avci->compat_decode_consumed, pkt->size);
841  }
842  avci->compat_decode_consumed = 0;
843  avci->compat_decode_partial_size = (ret >= 0) ? pkt->size - ret : 0;
844 
845  return ret;
846 }
847 
848 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
849  int *got_picture_ptr,
850  const AVPacket *avpkt)
851 {
852  return compat_decode(avctx, picture, got_picture_ptr, avpkt);
853 }
854 
855 int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
856  AVFrame *frame,
857  int *got_frame_ptr,
858  const AVPacket *avpkt)
859 {
860  return compat_decode(avctx, frame, got_frame_ptr, avpkt);
861 }
863 #endif
864 
866 {
867  memset(sub, 0, sizeof(*sub));
868  sub->pts = AV_NOPTS_VALUE;
869 }
870 
871 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
872 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
873  AVPacket *inpkt, AVPacket *buf_pkt)
874 {
875 #if CONFIG_ICONV
876  iconv_t cd = (iconv_t)-1;
877  int ret = 0;
878  char *inb, *outb;
879  size_t inl, outl;
880 #endif
881 
882  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
883  *outpkt = inpkt;
884  return 0;
885  }
886 
887 #if CONFIG_ICONV
888  inb = inpkt->data;
889  inl = inpkt->size;
890 
891  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
892  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
893  return AVERROR(ERANGE);
894  }
895 
896  cd = iconv_open("UTF-8", avctx->sub_charenc);
897  av_assert0(cd != (iconv_t)-1);
898 
899  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
900  if (ret < 0)
901  goto end;
902  ret = av_packet_copy_props(buf_pkt, inpkt);
903  if (ret < 0)
904  goto end;
905  outb = buf_pkt->data;
906  outl = buf_pkt->size;
907 
908  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
909  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
910  outl >= buf_pkt->size || inl != 0) {
911  ret = FFMIN(AVERROR(errno), -1);
912  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
913  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
914  goto end;
915  }
916  buf_pkt->size -= outl;
917  memset(buf_pkt->data + buf_pkt->size, 0, outl);
918  *outpkt = buf_pkt;
919 
920  ret = 0;
921 end:
922  if (ret < 0)
923  av_packet_unref(buf_pkt);
924  if (cd != (iconv_t)-1)
925  iconv_close(cd);
926  return ret;
927 #else
928  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
929  return AVERROR(EINVAL);
930 #endif
931 }
932 
933 static int utf8_check(const uint8_t *str)
934 {
935  const uint8_t *byte;
936  uint32_t codepoint, min;
937 
938  while (*str) {
939  byte = str;
940  GET_UTF8(codepoint, *(byte++), return 0;);
941  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
942  1 << (5 * (byte - str) - 4);
943  if (codepoint < min || codepoint >= 0x110000 ||
944  codepoint == 0xFFFE /* BOM */ ||
945  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
946  return 0;
947  str = byte;
948  }
949  return 1;
950 }
951 
952 #if FF_API_ASS_TIMING
953 static void insert_ts(AVBPrint *buf, int ts)
954 {
955  if (ts == -1) {
956  av_bprintf(buf, "9:59:59.99,");
957  } else {
958  int h, m, s;
959 
960  h = ts/360000; ts -= 360000*h;
961  m = ts/ 6000; ts -= 6000*m;
962  s = ts/ 100; ts -= 100*s;
963  av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
964  }
965 }
966 
968 {
969  int i;
970  AVBPrint buf;
971 
973 
974  for (i = 0; i < sub->num_rects; i++) {
975  char *final_dialog;
976  const char *dialog;
977  AVSubtitleRect *rect = sub->rects[i];
978  int ts_start, ts_duration = -1;
979  long int layer;
980 
981  if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
982  continue;
983 
984  av_bprint_clear(&buf);
985 
986  /* skip ReadOrder */
987  dialog = strchr(rect->ass, ',');
988  if (!dialog)
989  continue;
990  dialog++;
991 
992  /* extract Layer or Marked */
993  layer = strtol(dialog, (char**)&dialog, 10);
994  if (*dialog != ',')
995  continue;
996  dialog++;
997 
998  /* rescale timing to ASS time base (ms) */
999  ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
1000  if (pkt->duration != -1)
1001  ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
1002  sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
1003 
1004  /* construct ASS (standalone file form with timestamps) string */
1005  av_bprintf(&buf, "Dialogue: %ld,", layer);
1006  insert_ts(&buf, ts_start);
1007  insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
1008  av_bprintf(&buf, "%s\r\n", dialog);
1009 
1010  final_dialog = av_strdup(buf.str);
1011  if (!av_bprint_is_complete(&buf) || !final_dialog) {
1012  av_freep(&final_dialog);
1013  av_bprint_finalize(&buf, NULL);
1014  return AVERROR(ENOMEM);
1015  }
1016  av_freep(&rect->ass);
1017  rect->ass = final_dialog;
1018  }
1019 
1020  av_bprint_finalize(&buf, NULL);
1021  return 0;
1022 }
1023 #endif
1024 
1026  int *got_sub_ptr,
1027  AVPacket *avpkt)
1028 {
1029  int ret = 0;
1030 
1031  if (!avpkt->data && avpkt->size) {
1032  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
1033  return AVERROR(EINVAL);
1034  }
1035  if (!avctx->codec)
1036  return AVERROR(EINVAL);
1037  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
1038  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
1039  return AVERROR(EINVAL);
1040  }
1041 
1042  *got_sub_ptr = 0;
1043  get_subtitle_defaults(sub);
1044 
1045  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
1046  AVCodecInternal *avci = avctx->internal;
1047  AVPacket *pkt;
1048 
1049  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
1050  if (ret < 0)
1051  return ret;
1052 
1053  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
1054  sub->pts = av_rescale_q(avpkt->pts,
1055  avctx->pkt_timebase, AV_TIME_BASE_Q);
1056  ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
1057  av_assert1((ret >= 0) >= !!*got_sub_ptr &&
1058  !!*got_sub_ptr >= !!sub->num_rects);
1059 
1060 #if FF_API_ASS_TIMING
1062  && *got_sub_ptr && sub->num_rects) {
1063  const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
1064  : avctx->time_base;
1065  int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
1066  if (err < 0)
1067  ret = err;
1068  }
1069 #endif
1070 
1071  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1072  avctx->pkt_timebase.num) {
1073  AVRational ms = { 1, 1000 };
1074  sub->end_display_time = av_rescale_q(avpkt->duration,
1075  avctx->pkt_timebase, ms);
1076  }
1077 
1079  sub->format = 0;
1080  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1081  sub->format = 1;
1082 
1083  for (unsigned i = 0; i < sub->num_rects; i++) {
1085  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1086  av_log(avctx, AV_LOG_ERROR,
1087  "Invalid UTF-8 in decoded subtitles text; "
1088  "maybe missing -sub_charenc option\n");
1089  avsubtitle_free(sub);
1090  ret = AVERROR_INVALIDDATA;
1091  break;
1092  }
1093  }
1094 
1095  if (*got_sub_ptr)
1096  avctx->frame_number++;
1097 
1098  if (pkt == avci->buffer_pkt) // did we recode?
1099  av_packet_unref(avci->buffer_pkt);
1100  }
1101 
1102  return ret;
1103 }
1104 
1106  const enum AVPixelFormat *fmt)
1107 {
1108  const AVPixFmtDescriptor *desc;
1109  const AVCodecHWConfig *config;
1110  int i, n;
1111 
1112  // If a device was supplied when the codec was opened, assume that the
1113  // user wants to use it.
1114  if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
1115  AVHWDeviceContext *device_ctx =
1117  for (i = 0;; i++) {
1118  config = &avctx->codec->hw_configs[i]->public;
1119  if (!config)
1120  break;
1121  if (!(config->methods &
1123  continue;
1124  if (device_ctx->type != config->device_type)
1125  continue;
1126  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1127  if (config->pix_fmt == fmt[n])
1128  return fmt[n];
1129  }
1130  }
1131  }
1132  // No device or other setup, so we have to choose from things which
1133  // don't any other external information.
1134 
1135  // If the last element of the list is a software format, choose it
1136  // (this should be best software format if any exist).
1137  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1138  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1139  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1140  return fmt[n - 1];
1141 
1142  // Finally, traverse the list in order and choose the first entry
1143  // with no external dependencies (if there is no hardware configuration
1144  // information available then this just picks the first entry).
1145  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1146  for (i = 0;; i++) {
1147  config = avcodec_get_hw_config(avctx->codec, i);
1148  if (!config)
1149  break;
1150  if (config->pix_fmt == fmt[n])
1151  break;
1152  }
1153  if (!config) {
1154  // No specific config available, so the decoder must be able
1155  // to handle this format without any additional setup.
1156  return fmt[n];
1157  }
1159  // Usable with only internal setup.
1160  return fmt[n];
1161  }
1162  }
1163 
1164  // Nothing is usable, give up.
1165  return AV_PIX_FMT_NONE;
1166 }
1167 
1169  enum AVHWDeviceType dev_type)
1170 {
1171  AVHWDeviceContext *device_ctx;
1172  AVHWFramesContext *frames_ctx;
1173  int ret;
1174 
1175  if (!avctx->hwaccel)
1176  return AVERROR(ENOSYS);
1177 
1178  if (avctx->hw_frames_ctx)
1179  return 0;
1180  if (!avctx->hw_device_ctx) {
1181  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1182  "required for hardware accelerated decoding.\n");
1183  return AVERROR(EINVAL);
1184  }
1185 
1186  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1187  if (device_ctx->type != dev_type) {
1188  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1189  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1190  av_hwdevice_get_type_name(device_ctx->type));
1191  return AVERROR(EINVAL);
1192  }
1193 
1195  avctx->hw_device_ctx,
1196  avctx->hwaccel->pix_fmt,
1197  &avctx->hw_frames_ctx);
1198  if (ret < 0)
1199  return ret;
1200 
1201  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1202 
1203 
1204  if (frames_ctx->initial_pool_size) {
1205  // We guarantee 4 base work surfaces. The function above guarantees 1
1206  // (the absolute minimum), so add the missing count.
1207  frames_ctx->initial_pool_size += 3;
1208  }
1209 
1210  ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
1211  if (ret < 0) {
1212  av_buffer_unref(&avctx->hw_frames_ctx);
1213  return ret;
1214  }
1215 
1216  return 0;
1217 }
1218 
1220  AVBufferRef *device_ref,
1222  AVBufferRef **out_frames_ref)
1223 {
1224  AVBufferRef *frames_ref = NULL;
1225  const AVCodecHWConfigInternal *hw_config;
1226  const AVHWAccel *hwa;
1227  int i, ret;
1228 
1229  for (i = 0;; i++) {
1230  hw_config = avctx->codec->hw_configs[i];
1231  if (!hw_config)
1232  return AVERROR(ENOENT);
1233  if (hw_config->public.pix_fmt == hw_pix_fmt)
1234  break;
1235  }
1236 
1237  hwa = hw_config->hwaccel;
1238  if (!hwa || !hwa->frame_params)
1239  return AVERROR(ENOENT);
1240 
1241  frames_ref = av_hwframe_ctx_alloc(device_ref);
1242  if (!frames_ref)
1243  return AVERROR(ENOMEM);
1244 
1245  ret = hwa->frame_params(avctx, frames_ref);
1246  if (ret >= 0) {
1247  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1248 
1249  if (frames_ctx->initial_pool_size) {
1250  // If the user has requested that extra output surfaces be
1251  // available then add them here.
1252  if (avctx->extra_hw_frames > 0)
1253  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1254 
1255  // If frame threading is enabled then an extra surface per thread
1256  // is also required.
1257  if (avctx->active_thread_type & FF_THREAD_FRAME)
1258  frames_ctx->initial_pool_size += avctx->thread_count;
1259  }
1260 
1261  *out_frames_ref = frames_ref;
1262  } else {
1263  av_buffer_unref(&frames_ref);
1264  }
1265  return ret;
1266 }
1267 
1268 static int hwaccel_init(AVCodecContext *avctx,
1269  const AVCodecHWConfigInternal *hw_config)
1270 {
1271  const AVHWAccel *hwaccel;
1272  int err;
1273 
1274  hwaccel = hw_config->hwaccel;
1277  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1278  hwaccel->name);
1279  return AVERROR_PATCHWELCOME;
1280  }
1281 
1282  if (hwaccel->priv_data_size) {
1283  avctx->internal->hwaccel_priv_data =
1284  av_mallocz(hwaccel->priv_data_size);
1285  if (!avctx->internal->hwaccel_priv_data)
1286  return AVERROR(ENOMEM);
1287  }
1288 
1289  avctx->hwaccel = hwaccel;
1290  if (hwaccel->init) {
1291  err = hwaccel->init(avctx);
1292  if (err < 0) {
1293  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1294  "hwaccel initialisation returned error.\n",
1295  av_get_pix_fmt_name(hw_config->public.pix_fmt));
1297  avctx->hwaccel = NULL;
1298  return err;
1299  }
1300  }
1301 
1302  return 0;
1303 }
1304 
1305 static void hwaccel_uninit(AVCodecContext *avctx)
1306 {
1307  if (avctx->hwaccel && avctx->hwaccel->uninit)
1308  avctx->hwaccel->uninit(avctx);
1309 
1311 
1312  avctx->hwaccel = NULL;
1313 
1314  av_buffer_unref(&avctx->hw_frames_ctx);
1315 }
1316 
1317 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1318 {
1319  const AVPixFmtDescriptor *desc;
1320  enum AVPixelFormat *choices;
1321  enum AVPixelFormat ret, user_choice;
1322  const AVCodecHWConfigInternal *hw_config;
1323  const AVCodecHWConfig *config;
1324  int i, n, err;
1325 
1326  // Find end of list.
1327  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1328  // Must contain at least one entry.
1329  av_assert0(n >= 1);
1330  // If a software format is available, it must be the last entry.
1331  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1332  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1333  // No software format is available.
1334  } else {
1335  avctx->sw_pix_fmt = fmt[n - 1];
1336  }
1337 
1338  choices = av_malloc_array(n + 1, sizeof(*choices));
1339  if (!choices)
1340  return AV_PIX_FMT_NONE;
1341 
1342  memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1343 
1344  for (;;) {
1345  // Remove the previous hwaccel, if there was one.
1346  hwaccel_uninit(avctx);
1347 
1348  user_choice = avctx->get_format(avctx, choices);
1349  if (user_choice == AV_PIX_FMT_NONE) {
1350  // Explicitly chose nothing, give up.
1351  ret = AV_PIX_FMT_NONE;
1352  break;
1353  }
1354 
1355  desc = av_pix_fmt_desc_get(user_choice);
1356  if (!desc) {
1357  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1358  "get_format() callback.\n");
1359  ret = AV_PIX_FMT_NONE;
1360  break;
1361  }
1362  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1363  desc->name);
1364 
1365  for (i = 0; i < n; i++) {
1366  if (choices[i] == user_choice)
1367  break;
1368  }
1369  if (i == n) {
1370  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1371  "%s not in possible list.\n", desc->name);
1372  ret = AV_PIX_FMT_NONE;
1373  break;
1374  }
1375 
1376  if (avctx->codec->hw_configs) {
1377  for (i = 0;; i++) {
1378  hw_config = avctx->codec->hw_configs[i];
1379  if (!hw_config)
1380  break;
1381  if (hw_config->public.pix_fmt == user_choice)
1382  break;
1383  }
1384  } else {
1385  hw_config = NULL;
1386  }
1387 
1388  if (!hw_config) {
1389  // No config available, so no extra setup required.
1390  ret = user_choice;
1391  break;
1392  }
1393  config = &hw_config->public;
1394 
1395  if (config->methods &
1397  avctx->hw_frames_ctx) {
1398  const AVHWFramesContext *frames_ctx =
1400  if (frames_ctx->format != user_choice) {
1401  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1402  "does not match the format of the provided frames "
1403  "context.\n", desc->name);
1404  goto try_again;
1405  }
1406  } else if (config->methods &
1408  avctx->hw_device_ctx) {
1409  const AVHWDeviceContext *device_ctx =
1411  if (device_ctx->type != config->device_type) {
1412  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1413  "does not match the type of the provided device "
1414  "context.\n", desc->name);
1415  goto try_again;
1416  }
1417  } else if (config->methods &
1419  // Internal-only setup, no additional configuration.
1420  } else if (config->methods &
1422  // Some ad-hoc configuration we can't see and can't check.
1423  } else {
1424  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1425  "missing configuration.\n", desc->name);
1426  goto try_again;
1427  }
1428  if (hw_config->hwaccel) {
1429  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1430  "initialisation.\n", desc->name);
1431  err = hwaccel_init(avctx, hw_config);
1432  if (err < 0)
1433  goto try_again;
1434  }
1435  ret = user_choice;
1436  break;
1437 
1438  try_again:
1439  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1440  "get_format() without it.\n", desc->name);
1441  for (i = 0; i < n; i++) {
1442  if (choices[i] == user_choice)
1443  break;
1444  }
1445  for (; i + 1 < n; i++)
1446  choices[i] = choices[i + 1];
1447  --n;
1448  }
1449 
1450  av_freep(&choices);
1451  return ret;
1452 }
1453 
1454 static void frame_pool_free(void *opaque, uint8_t *data)
1455 {
1456  FramePool *pool = (FramePool*)data;
1457  int i;
1458 
1459  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1460  av_buffer_pool_uninit(&pool->pools[i]);
1461 
1462  av_freep(&data);
1463 }
1464 
1466 {
1467  FramePool *pool = av_mallocz(sizeof(*pool));
1468  AVBufferRef *buf;
1469 
1470  if (!pool)
1471  return NULL;
1472 
1473  buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1474  frame_pool_free, NULL, 0);
1475  if (!buf) {
1476  av_freep(&pool);
1477  return NULL;
1478  }
1479 
1480  return buf;
1481 }
1482 
1484 {
1485  FramePool *pool = avctx->internal->pool ?
1486  (FramePool*)avctx->internal->pool->data : NULL;
1487  AVBufferRef *pool_buf;
1488  int i, ret, ch, planes;
1489 
1490  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1491  int planar = av_sample_fmt_is_planar(frame->format);
1492  ch = frame->channels;
1493  planes = planar ? ch : 1;
1494  }
1495 
1496  if (pool && pool->format == frame->format) {
1497  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1498  pool->width == frame->width && pool->height == frame->height)
1499  return 0;
1500  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1501  pool->channels == ch && frame->nb_samples == pool->samples)
1502  return 0;
1503  }
1504 
1505  pool_buf = frame_pool_alloc();
1506  if (!pool_buf)
1507  return AVERROR(ENOMEM);
1508  pool = (FramePool*)pool_buf->data;
1509 
1510  switch (avctx->codec_type) {
1511  case AVMEDIA_TYPE_VIDEO: {
1512  int linesize[4];
1513  int w = frame->width;
1514  int h = frame->height;
1515  int unaligned;
1516  ptrdiff_t linesize1[4];
1517  size_t size[4];
1518 
1519  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1520 
1521  do {
1522  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
1523  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1524  ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
1525  if (ret < 0)
1526  goto fail;
1527  // increase alignment of w for next try (rhs gives the lowest bit set in w)
1528  w += w & ~(w - 1);
1529 
1530  unaligned = 0;
1531  for (i = 0; i < 4; i++)
1532  unaligned |= linesize[i] % pool->stride_align[i];
1533  } while (unaligned);
1534 
1535  for (i = 0; i < 4; i++)
1536  linesize1[i] = linesize[i];
1537  ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1538  if (ret < 0)
1539  goto fail;
1540 
1541  for (i = 0; i < 4; i++) {
1542  pool->linesize[i] = linesize[i];
1543  if (size[i]) {
1544  if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1545  ret = AVERROR(EINVAL);
1546  goto fail;
1547  }
1548  pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1549  CONFIG_MEMORY_POISONING ?
1550  NULL :
1552  if (!pool->pools[i]) {
1553  ret = AVERROR(ENOMEM);
1554  goto fail;
1555  }
1556  }
1557  }
1558  pool->format = frame->format;
1559  pool->width = frame->width;
1560  pool->height = frame->height;
1561 
1562  break;
1563  }
1564  case AVMEDIA_TYPE_AUDIO: {
1565  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1566  frame->nb_samples, frame->format, 0);
1567  if (ret < 0)
1568  goto fail;
1569 
1570  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1571  if (!pool->pools[0]) {
1572  ret = AVERROR(ENOMEM);
1573  goto fail;
1574  }
1575 
1576  pool->format = frame->format;
1577  pool->planes = planes;
1578  pool->channels = ch;
1579  pool->samples = frame->nb_samples;
1580  break;
1581  }
1582  default: av_assert0(0);
1583  }
1584 
1585  av_buffer_unref(&avctx->internal->pool);
1586  avctx->internal->pool = pool_buf;
1587 
1588  return 0;
1589 fail:
1590  av_buffer_unref(&pool_buf);
1591  return ret;
1592 }
1593 
1595 {
1596  FramePool *pool = (FramePool*)avctx->internal->pool->data;
1597  int planes = pool->planes;
1598  int i;
1599 
1600  frame->linesize[0] = pool->linesize[0];
1601 
1603  frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
1606  sizeof(*frame->extended_buf));
1607  if (!frame->extended_data || !frame->extended_buf) {
1608  av_freep(&frame->extended_data);
1609  av_freep(&frame->extended_buf);
1610  return AVERROR(ENOMEM);
1611  }
1612  } else {
1613  frame->extended_data = frame->data;
1614  av_assert0(frame->nb_extended_buf == 0);
1615  }
1616 
1617  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1618  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1619  if (!frame->buf[i])
1620  goto fail;
1621  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1622  }
1623  for (i = 0; i < frame->nb_extended_buf; i++) {
1624  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1625  if (!frame->extended_buf[i])
1626  goto fail;
1627  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1628  }
1629 
1630  if (avctx->debug & FF_DEBUG_BUFFERS)
1631  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1632 
1633  return 0;
1634 fail:
1635  av_frame_unref(frame);
1636  return AVERROR(ENOMEM);
1637 }
1638 
1640 {
1641  FramePool *pool = (FramePool*)s->internal->pool->data;
1643  int i;
1644 
1645  if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1646  av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1647  return -1;
1648  }
1649 
1650  if (!desc) {
1651  av_log(s, AV_LOG_ERROR,
1652  "Unable to get pixel format descriptor for format %s\n",
1653  av_get_pix_fmt_name(pic->format));
1654  return AVERROR(EINVAL);
1655  }
1656 
1657  memset(pic->data, 0, sizeof(pic->data));
1658  pic->extended_data = pic->data;
1659 
1660  for (i = 0; i < 4 && pool->pools[i]; i++) {
1661  pic->linesize[i] = pool->linesize[i];
1662 
1663  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1664  if (!pic->buf[i])
1665  goto fail;
1666 
1667  pic->data[i] = pic->buf[i]->data;
1668  }
1669  for (; i < AV_NUM_DATA_POINTERS; i++) {
1670  pic->data[i] = NULL;
1671  pic->linesize[i] = 0;
1672  }
1673  if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
1674  ((desc->flags & FF_PSEUDOPAL) && pic->data[1]))
1675  avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
1676 
1677  if (s->debug & FF_DEBUG_BUFFERS)
1678  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1679 
1680  return 0;
1681 fail:
1682  av_frame_unref(pic);
1683  return AVERROR(ENOMEM);
1684 }
1685 
1687 {
1688  int ret;
1689 
1690  if (avctx->hw_frames_ctx) {
1691  ret = av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
1692  frame->width = avctx->coded_width;
1693  frame->height = avctx->coded_height;
1694  return ret;
1695  }
1696 
1697  if ((ret = update_frame_pool(avctx, frame)) < 0)
1698  return ret;
1699 
1700  switch (avctx->codec_type) {
1701  case AVMEDIA_TYPE_VIDEO:
1702  return video_get_buffer(avctx, frame);
1703  case AVMEDIA_TYPE_AUDIO:
1704  return audio_get_buffer(avctx, frame);
1705  default:
1706  return -1;
1707  }
1708 }
1709 
1711 {
1713  const uint8_t *side_metadata;
1714 
1715  AVDictionary **frame_md = &frame->metadata;
1716 
1717  side_metadata = av_packet_get_side_data(avpkt,
1719  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1720 }
1721 
1723 {
1724  AVPacket *pkt = avctx->internal->last_pkt_props;
1725  static const struct {
1726  enum AVPacketSideDataType packet;
1728  } sd[] = {
1739  };
1740 
1741  if (IS_EMPTY(pkt) && av_fifo_size(avctx->internal->pkt_props) >= sizeof(*pkt))
1743  pkt, sizeof(*pkt), NULL);
1744 
1745  frame->pts = pkt->pts;
1746 #if FF_API_PKT_PTS
1748  frame->pkt_pts = pkt->pts;
1750 #endif
1751  frame->pkt_pos = pkt->pos;
1752  frame->pkt_duration = pkt->duration;
1753  frame->pkt_size = pkt->size;
1754 
1755  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1757  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1758  if (packet_sd) {
1759  AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
1760  sd[i].frame,
1761  size);
1762  if (!frame_sd)
1763  return AVERROR(ENOMEM);
1764 
1765  memcpy(frame_sd->data, packet_sd, size);
1766  }
1767  }
1768  add_metadata_from_side_data(pkt, frame);
1769 
1770  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1771  frame->flags |= AV_FRAME_FLAG_DISCARD;
1772  } else {
1773  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1774  }
1775  frame->reordered_opaque = avctx->reordered_opaque;
1776 
1777  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1778  frame->color_primaries = avctx->color_primaries;
1779  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1780  frame->color_trc = avctx->color_trc;
1781  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1782  frame->colorspace = avctx->colorspace;
1783  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1784  frame->color_range = avctx->color_range;
1786  frame->chroma_location = avctx->chroma_sample_location;
1787 
1788  switch (avctx->codec->type) {
1789  case AVMEDIA_TYPE_VIDEO:
1790  frame->format = avctx->pix_fmt;
1791  if (!frame->sample_aspect_ratio.num)
1792  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1793 
1794  if (frame->width && frame->height &&
1795  av_image_check_sar(frame->width, frame->height,
1796  frame->sample_aspect_ratio) < 0) {
1797  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1798  frame->sample_aspect_ratio.num,
1799  frame->sample_aspect_ratio.den);
1800  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1801  }
1802 
1803  break;
1804  case AVMEDIA_TYPE_AUDIO:
1805  if (!frame->sample_rate)
1806  frame->sample_rate = avctx->sample_rate;
1807  if (frame->format < 0)
1808  frame->format = avctx->sample_fmt;
1809  if (!frame->channel_layout) {
1810  if (avctx->channel_layout) {
1812  avctx->channels) {
1813  av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1814  "configuration.\n");
1815  return AVERROR(EINVAL);
1816  }
1817 
1818  frame->channel_layout = avctx->channel_layout;
1819  } else {
1820  if (avctx->channels > FF_SANE_NB_CHANNELS) {
1821  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1822  avctx->channels);
1823  return AVERROR(ENOSYS);
1824  }
1825  }
1826  }
1827  frame->channels = avctx->channels;
1828  break;
1829  }
1830  return 0;
1831 }
1832 
1834 {
1835  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1836  int i;
1837  int num_planes = av_pix_fmt_count_planes(frame->format);
1839  int flags = desc ? desc->flags : 0;
1840  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1841  num_planes = 2;
1842  if ((flags & FF_PSEUDOPAL) && frame->data[1])
1843  num_planes = 2;
1844  for (i = 0; i < num_planes; i++) {
1845  av_assert0(frame->data[i]);
1846  }
1847  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1848  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1849  if (frame->data[i])
1850  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1851  frame->data[i] = NULL;
1852  }
1853  }
1854 }
1855 
1856 static void decode_data_free(void *opaque, uint8_t *data)
1857 {
1858  FrameDecodeData *fdd = (FrameDecodeData*)data;
1859 
1860  if (fdd->post_process_opaque_free)
1862 
1863  if (fdd->hwaccel_priv_free)
1864  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1865 
1866  av_freep(&fdd);
1867 }
1868 
1870 {
1871  AVBufferRef *fdd_buf;
1872  FrameDecodeData *fdd;
1873 
1874  av_assert1(!frame->private_ref);
1875  av_buffer_unref(&frame->private_ref);
1876 
1877  fdd = av_mallocz(sizeof(*fdd));
1878  if (!fdd)
1879  return AVERROR(ENOMEM);
1880 
1881  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1883  if (!fdd_buf) {
1884  av_freep(&fdd);
1885  return AVERROR(ENOMEM);
1886  }
1887 
1888  frame->private_ref = fdd_buf;
1889 
1890  return 0;
1891 }
1892 
1894 {
1895  const AVHWAccel *hwaccel = avctx->hwaccel;
1896  int override_dimensions = 1;
1897  int ret;
1898 
1899  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1900  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1901  (ret = av_image_check_size2(FFALIGN(avctx->width, STRIDE_ALIGN), avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) {
1902  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1903  ret = AVERROR(EINVAL);
1904  goto fail;
1905  }
1906 
1907  if (frame->width <= 0 || frame->height <= 0) {
1908  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1909  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1910  override_dimensions = 0;
1911  }
1912 
1913  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1914  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1915  ret = AVERROR(EINVAL);
1916  goto fail;
1917  }
1918  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1919  if (frame->nb_samples * (int64_t)avctx->channels > avctx->max_samples) {
1920  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1921  ret = AVERROR(EINVAL);
1922  goto fail;
1923  }
1924  }
1925  ret = ff_decode_frame_props(avctx, frame);
1926  if (ret < 0)
1927  goto fail;
1928 
1929  if (hwaccel) {
1930  if (hwaccel->alloc_frame) {
1931  ret = hwaccel->alloc_frame(avctx, frame);
1932  goto end;
1933  }
1934  } else
1935  avctx->sw_pix_fmt = avctx->pix_fmt;
1936 
1937  ret = avctx->get_buffer2(avctx, frame, flags);
1938  if (ret < 0)
1939  goto fail;
1940 
1941  validate_avframe_allocation(avctx, frame);
1942 
1943  ret = ff_attach_decode_data(frame);
1944  if (ret < 0)
1945  goto fail;
1946 
1947 end:
1948  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1950  frame->width = avctx->width;
1951  frame->height = avctx->height;
1952  }
1953 
1954 fail:
1955  if (ret < 0) {
1956  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1957  av_frame_unref(frame);
1958  }
1959 
1960  return ret;
1961 }
1962 
1964 {
1965  AVFrame *tmp;
1966  int ret;
1967 
1969 
1970  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1971  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1972  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1973  av_frame_unref(frame);
1974  }
1975 
1976  if (!frame->data[0])
1977  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1978 
1979  if ((flags & FF_REGET_BUFFER_FLAG_READONLY) || av_frame_is_writable(frame))
1980  return ff_decode_frame_props(avctx, frame);
1981 
1982  tmp = av_frame_alloc();
1983  if (!tmp)
1984  return AVERROR(ENOMEM);
1985 
1986  av_frame_move_ref(tmp, frame);
1987 
1988  ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1989  if (ret < 0) {
1990  av_frame_free(&tmp);
1991  return ret;
1992  }
1993 
1994  av_frame_copy(frame, tmp);
1995  av_frame_free(&tmp);
1996 
1997  return 0;
1998 }
1999 
2001 {
2002  int ret = reget_buffer_internal(avctx, frame, flags);
2003  if (ret < 0)
2004  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
2005  return ret;
2006 }
2007 
2009 {
2010  int ret = 0;
2011 
2012  /* if the decoder init function was already called previously,
2013  * free the already allocated subtitle_header before overwriting it */
2014  av_freep(&avctx->subtitle_header);
2015 
2016 #if FF_API_THREAD_SAFE_CALLBACKS
2018  if ((avctx->thread_type & FF_THREAD_FRAME) &&
2020  !avctx->thread_safe_callbacks) {
2021  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
2022  "custom get_buffer2() implementation which is not marked as "
2023  "thread safe. This is not supported anymore, make your "
2024  "callback thread-safe.\n");
2025  }
2027 #endif
2028 
2029  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->channels == 0 &&
2031  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
2032  return AVERROR(EINVAL);
2033  }
2034  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
2035  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2036  avctx->codec->max_lowres);
2037  avctx->lowres = avctx->codec->max_lowres;
2038  }
2039  if (avctx->sub_charenc) {
2040  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2041  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
2042  "supported with subtitles codecs\n");
2043  return AVERROR(EINVAL);
2044  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
2045  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
2046  "subtitles character encoding will be ignored\n",
2047  avctx->codec_descriptor->name);
2049  } else {
2050  /* input character encoding is set for a text based subtitle
2051  * codec at this point */
2054 
2056 #if CONFIG_ICONV
2057  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
2058  if (cd == (iconv_t)-1) {
2059  ret = AVERROR(errno);
2060  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
2061  "with input character encoding \"%s\"\n", avctx->sub_charenc);
2062  return ret;
2063  }
2064  iconv_close(cd);
2065 #else
2066  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
2067  "conversion needs a libavcodec built with iconv support "
2068  "for this codec\n");
2069  return AVERROR(ENOSYS);
2070 #endif
2071  }
2072  }
2073  }
2074 
2076  avctx->pts_correction_num_faulty_dts = 0;
2077  avctx->pts_correction_last_pts =
2078  avctx->pts_correction_last_dts = INT64_MIN;
2079 
2080  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
2082  av_log(avctx, AV_LOG_WARNING,
2083  "gray decoding requested but not enabled at configuration time\n");
2084  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
2086  }
2087 
2088  ret = decode_bsfs_init(avctx);
2089  if (ret < 0)
2090  return ret;
2091 
2092  return 0;
2093 }
2094 
2095 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2096 {
2098  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2099 
2100  if (pal && size == AVPALETTE_SIZE) {
2101  memcpy(dst, pal, AVPALETTE_SIZE);
2102  return 1;
2103  } else if (pal) {
2104  av_log(logctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
2105  }
2106  return 0;
2107 }
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
#define FF_SANE_NB_CHANNELS
Definition: internal.h:102
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:788
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
int nb_draining_errors
Definition: internal.h:206
#define FF_SUB_CHARENC_MODE_PRE_DECODER
the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv ...
Definition: avcodec.h:2120
#define NULL
Definition: coverity.c:32
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1317
const struct AVCodec * codec
Definition: avcodec.h:545
AVRational framerate
Definition: avcodec.h:2071
int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
Enlarge an AVFifoBuffer.
Definition: fifo.c:107
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2092
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_NUM_DATA_POINTERS
Definition: frame.h:319
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
AVPacketSideDataType
Definition: packet.h:40
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:2119
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2100
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
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:499
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int stride_align[AV_NUM_DATA_POINTERS]
Definition: decode.c:60
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:113
int apply_cropping
Video decoding only.
Definition: avcodec.h:2306
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so, copy it to dst and return 1; else return 0.
Definition: decode.c:2095
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:534
#define AV_CODEC_FLAG2_SKIP_MANUAL
Do not skip samples and export skip information as frame side data.
Definition: avcodec.h:384
AVFifoBuffer * pkt_props
Definition: internal.h:155
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:589
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2471
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:154
const char * desc
Definition: libsvtav1.c:79
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
Definition: decode.c:967
int changed_frames_dropped
Definition: internal.h:209
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2613
AVFrame * to_free
Definition: internal.h:140
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:84
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:509
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:518
int width
Definition: decode.c:59
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:318
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
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
int nb_extended_buf
Number of elements in extended_buf.
Definition: frame.h:527
static FF_DISABLE_DEPRECATION_WARNINGS int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
Definition: decode.c:721
Content light level (based on CTA-861.3).
Definition: frame.h:136
int num
Numerator.
Definition: rational.h:59
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
#define FF_SUB_CHARENC_MODE_DO_NOTHING
do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for inst...
Definition: avcodec.h:2118
int size
Definition: packet.h:370
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:79
int initial_channels
Definition: internal.h:213
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2465
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:915
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:53
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:102
static void frame_pool_free(void *opaque, uint8_t *data)
Definition: decode.c:1454
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int samples
Definition: decode.c:64
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: decode.c:855
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
Mastering display metadata associated with a video frame.
Definition: frame.h:119
unsigned num_rects
Definition: avcodec.h:2726
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:583
enum AVMediaType type
Definition: codec.h:210
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
#define FF_ARRAY_ELEMS(a)
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:67
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
AVBufferPool * pools[4]
Pools for each data plane.
Definition: decode.c:53
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1722
size_t crop_bottom
Definition: frame.h:679
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:424
AVPacket * pkt
Definition: movenc.c:59
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1025
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: avcodec.h:2484
static int utf8_check(const uint8_t *str)
Definition: decode.c:933
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:616
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:659
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
AVSubtitleRect ** rects
Definition: avcodec.h:2727
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2576
static AVBufferRef * frame_pool_alloc(void)
Definition: decode.c:1465
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static FF_ENABLE_DEPRECATION_WARNINGS void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:865
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:2346
int height
Definition: decode.c:59
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1105
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1869
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:403
AVOptions.
static int64_t guess_correct_pts(AVCodecContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
Definition: decode.c:265
size_t crop_left
Definition: frame.h:680
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:176
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:271
#define AV_WL8(p, d)
Definition: intreadwrite.h:399
Multithreading support functions.
AVBufferRef * private_ref
AVBufferRef for internal use by a single libav* library.
Definition: frame.h:697
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:222
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:452
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
int planes
Definition: decode.c:62
Structure to hold side data for an AVFrame.
Definition: frame.h:220
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:322
size_t compat_decode_consumed
Definition: internal.h:193
static void finish(void)
Definition: movenc.c:342
uint8_t * data
Definition: packet.h:369
static int copy_packet_props(AVPacket *dst, const AVPacket *src)
Definition: decode.c:148
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: internal.h:307
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVDictionary * metadata
metadata.
Definition: frame.h:604
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1754
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:128
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: avcodec.h:2568
ptrdiff_t size
Definition: opengl_enc.c:100
int initial_height
Definition: internal.h:211
int initial_format
Definition: internal.h:210
The data represents the AVSphericalMapping structure defined in libavutil/spherical.h.
Definition: frame.h:130
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
The buffer pool.
const char * name
Definition: pixdesc.h:82
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:641
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:134
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
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 AV_RL8(x)
Definition: intreadwrite.h:398
#define src
Definition: vp8dsp.c:255
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2085
AVBSFContext * bsf
Definition: internal.h:148
int width
Definition: frame.h:376
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:826
void * post_process_opaque
Definition: decode.h:46
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
#define AV_BPRINT_SIZE_UNLIMITED
const struct AVCodecHWConfigInternal *const * hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec.h:343
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
Definition: decode.c:1268
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1833
int buffer_size_t
Definition: internal.h:306
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:72
int av_frame_apply_cropping(AVFrame *frame, int flags)
Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ crop_bottom fields...
Definition: frame.c:892
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1...
Definition: packet.h:274
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:2101
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available...
Definition: decode.c:2000
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
Definition: codec.h:457
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:796
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
Definition: decode.c:160
AVFrame * buffer_frame
Definition: internal.h:186
int capabilities
Codec capabilities.
Definition: codec.h:216
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:562
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:573
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:89
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
simple assert() macros that are a bit more flexible than ISO C assert().
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
int side_data_elems
Definition: packet.h:381
AVBufferRef * av_buffer_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:333
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:79
#define FFMAX(a, b)
Definition: common.h:103
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:502
#define fail()
Definition: checkasm.h:133
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:800
const AVHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
Definition: hwconfig.h:39
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: internal.h:67
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: avcodec.h:2582
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:148
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
uint32_t end_display_time
Definition: avcodec.h:2725
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2728
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:495
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
size_t crop_top
Definition: frame.h:678
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:199
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
Definition: bsf.c:523
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:600
int channels
number of audio channels, only used for audio.
Definition: frame.h:624
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:555
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2444
#define FFMIN(a, b)
Definition: common.h:105
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers, this array will hold all the references which cannot fit into AVFrame.buf.
Definition: frame.h:523
int channels
Definition: decode.c:63
AVFrame * compat_decode_frame
Definition: internal.h:197
int width
picture width / height.
Definition: avcodec.h:709
uint8_t w
Definition: llviddspenc.c:39
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2218
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1710
static int compat_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, const AVPacket *pkt)
Definition: decode.c:767
AVPacket * in_pkt
Definition: internal.h:117
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
AVFrameSideDataType
Definition: frame.h:48
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED) ...
Definition: error.h:73
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
uint16_t format
Definition: avcodec.h:2723
#define s(width, name)
Definition: cbs_vp9.c:257
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:143
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1635
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1673
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding...
Definition: codec.h:334
DecodeSimpleContext ds
Definition: internal.h:147
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2109
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1594
static int decode_bsfs_init(AVCodecContext *avctx)
Definition: decode.c:188
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:180
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1773
int linesize[4]
Definition: decode.c:61
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2117
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:556
if(ret)
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:444
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int(* post_process)(void *logctx, AVFrame *frame)
The callback to perform some delayed processing on the frame right before it is returned to the calle...
Definition: decode.h:45
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:303
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:391
Content light level (based on CTA-861.3).
Definition: packet.h:235
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:297
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h:47
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:201
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1686
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:544
int compat_decode_warned
Definition: internal.h:190
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:597
A list of zero terminated key/value strings.
Definition: packet.h:172
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: decode.c:848
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:84
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:595
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:91
int sample_rate
samples per second
Definition: avcodec.h:1196
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int initial_sample_rate
Definition: internal.h:212
int debug
debug
Definition: avcodec.h:1623
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:873
main external API structure.
Definition: avcodec.h:536
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
int skip_samples_multiplier
Definition: internal.h:203
uint8_t * data
The data buffer.
Definition: buffer.h:92
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:227
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1963
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:504
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:406
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
uint8_t * data
Definition: frame.h:222
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: codec_desc.h:97
int av_samples_copy(uint8_t **dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:213
size_t crop_right
Definition: frame.h:681
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2336
AVBufferRef * av_buffer_allocz(buffer_size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int coded_height
Definition: avcodec.h:724
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything)...
Definition: frame.h:485
int sample_rate
Sample rate of the audio data.
Definition: frame.h:490
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1351
int showed_multi_packet_warning
Definition: internal.h:201
Definition: f_ebur128.c:91
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:727
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:92
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: codec.h:95
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:308
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:119
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:90
Recommmends skipping the specified number of samples.
Definition: packet.h:156
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
int sub_text_format
Control the form of AVSubtitle.rects[N]->ass.
Definition: avcodec.h:2225
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:411
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:170
#define STRIDE_ALIGN
Definition: internal.h:113
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
enum AVChromaLocation chroma_location
Definition: frame.h:575
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
Definition: avcodec.h:2597
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:582
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1368
AVBufferRef * pool
Definition: internal.h:143
#define AV_CODEC_FLAG_DROPCHANGED
Don&#39;t output frames whose parameters differ from first decoded frame in stream.
Definition: avcodec.h:292
int size
Size of data in bytes.
Definition: buffer.h:97
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
static int64_t pts
#define SIZE_SPECIFIER
Definition: internal.h:193
#define flags(name, subs,...)
Definition: cbs_av1.c:561
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:99
The codec supports this format by some internal method.
Definition: codec.h:431
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: internal.h:56
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
Definition: decode.c:1168
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1856
#define UTF8_MAX_BYTES
Definition: decode.c:871
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:419
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:291
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
enum AVMediaType type
Definition: codec_desc.h:40
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:222
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:185
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:427
A reference to a data buffer.
Definition: buffer.h:84
int extra_hw_frames
Definition: avcodec.h:2320
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:34
int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, AVBufferRef *device_ref, enum AVPixelFormat hw_pix_fmt, AVBufferRef **out_frames_ref)
Create and return a AVHWFramesContext with values adequate for hardware decoding. ...
Definition: decode.c:1219
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:417
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
common internal api header.
common internal and external API header
AVBufferPool * av_buffer_pool_init(buffer_size_t size, AVBufferRef *(*alloc)(buffer_size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:266
#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
Definition: avcodec.h:2604
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:116
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:247
static void insert_ts(AVBPrint *buf, int ts)
Definition: decode.c:953
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:175
The codec supports this format by some ad-hoc method.
Definition: codec.h:440
int caps_internal
Internal codec capabilities.
Definition: codec.h:328
attribute_deprecated int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:1812
int den
Denominator.
Definition: rational.h:60
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:288
uint64_t initial_channel_layout
Definition: internal.h:214
#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
Apply the maximum possible cropping, even if it requires setting the AVFrame.data[] entries to unalig...
Definition: frame.h:970
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt, AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:872
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Definition: decode.c:1639
Formatted text, the ass field must be set by the decoder and is authoritative.
Definition: avcodec.h:2682
#define FF_PSEUDOPAL
Definition: internal.h:299
AVHWDeviceType
Definition: hwcontext.h:27
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int channels
number of audio channels
Definition: avcodec.h:1197
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:571
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2717
#define AV_FRAME_FLAG_DISCARD
A flag to mark the frames which need to be decoded, but shouldn&#39;t be output.
Definition: frame.h:547
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
enum AVColorPrimaries color_primaries
Definition: frame.h:564
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:380
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:2102
size_t compat_decode_partial_size
Definition: internal.h:196
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:317
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
#define IS_EMPTY(pkt)
Definition: decode.c:146
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1483
int height
Definition: frame.h:376
#define av_freep(p)
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
Definition: avcodec.h:2099
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:566
static float sub(float src0, float src1)
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:40
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:373
Recommmends skipping the specified number of samples.
Definition: frame.h:108
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:52
#define av_malloc_array(a, b)
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: codec.h:464
#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
Definition: avcodec.h:2228
#define FF_SUB_CHARENC_MODE_IGNORE
neither convert the subtitles, nor check them for valid UTF-8
Definition: avcodec.h:2121
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2489
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:76
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
enum AVSubtitleType type
Definition: avcodec.h:2708
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
int format
Definition: decode.c:58
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:2270
int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:633
float min
Stereoscopic 3d metadata.
Definition: frame.h:63
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:514
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:2008
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2078
for(j=16;j >0;--j)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:659
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static void hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1305
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1783
#define tb
Definition: regdef.h:68
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:120
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2016
static uint8_t tmp[11]
Definition: aes_ctr.c:27