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"
34 #include "libavutil/common.h"
35 #include "libavutil/fifo.h"
36 #include "libavutil/frame.h"
37 #include "libavutil/hwcontext.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/intmath.h"
41 #include "libavutil/opt.h"
42 
43 #include "avcodec.h"
44 #include "bytestream.h"
45 #include "bsf.h"
46 #include "codec_internal.h"
47 #include "decode.h"
48 #include "hwconfig.h"
49 #include "internal.h"
50 #include "thread.h"
51 
52 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
53 {
54  int ret;
55  size_t size;
56  const uint8_t *data;
57  uint32_t flags;
58  int64_t val;
59 
61  if (!data)
62  return 0;
63 
64  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
65  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
66  "changes, but PARAM_CHANGE side data was sent to it.\n");
67  ret = AVERROR(EINVAL);
68  goto fail2;
69  }
70 
71  if (size < 4)
72  goto fail;
73 
74  flags = bytestream_get_le32(&data);
75  size -= 4;
76 
77 #if FF_API_OLD_CHANNEL_LAYOUT
79  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
80  if (size < 4)
81  goto fail;
82  val = bytestream_get_le32(&data);
83  if (val <= 0 || val > INT_MAX) {
84  av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
86  goto fail2;
87  }
88  avctx->channels = val;
89  size -= 4;
90  }
91  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
92  if (size < 8)
93  goto fail;
94  avctx->channel_layout = bytestream_get_le64(&data);
95  size -= 8;
96  }
98 #endif
100  if (size < 4)
101  goto fail;
102  val = bytestream_get_le32(&data);
103  if (val <= 0 || val > INT_MAX) {
104  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
106  goto fail2;
107  }
108  avctx->sample_rate = val;
109  size -= 4;
110  }
112  if (size < 8)
113  goto fail;
114  avctx->width = bytestream_get_le32(&data);
115  avctx->height = bytestream_get_le32(&data);
116  size -= 8;
117  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
118  if (ret < 0)
119  goto fail2;
120  }
121 
122  return 0;
123 fail:
124  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
126 fail2:
127  if (ret < 0) {
128  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
129  if (avctx->err_recognition & AV_EF_EXPLODE)
130  return ret;
131  }
132  return 0;
133 }
134 
135 #define IS_EMPTY(pkt) (!(pkt)->data)
136 
137 static int copy_packet_props(AVPacket *dst, const AVPacket *src)
138 {
139  int ret = av_packet_copy_props(dst, src);
140  if (ret < 0)
141  return ret;
142 
143  dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
144  dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
145 
146  return 0;
147 }
148 
150 {
151  AVPacket tmp = { 0 };
152  int ret = 0;
153 
154  if (IS_EMPTY(avci->last_pkt_props)) {
155  if (av_fifo_read(avci->pkt_props, avci->last_pkt_props, 1) < 0)
156  return copy_packet_props(avci->last_pkt_props, pkt);
157  }
158 
160  if (ret < 0)
161  return ret;
162 
163  ret = av_fifo_write(avci->pkt_props, &tmp, 1);
164  if (ret < 0)
166 
167  return ret;
168 }
169 
171 {
172  AVCodecInternal *avci = avctx->internal;
173  const FFCodec *const codec = ffcodec(avctx->codec);
174  int ret;
175 
176  if (avci->bsf)
177  return 0;
178 
179  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
180  if (ret < 0) {
181  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
182  if (ret != AVERROR(ENOMEM))
183  ret = AVERROR_BUG;
184  goto fail;
185  }
186 
187  /* We do not currently have an API for passing the input timebase into decoders,
188  * but no filters used here should actually need it.
189  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
190  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
192  if (ret < 0)
193  goto fail;
194 
195  ret = av_bsf_init(avci->bsf);
196  if (ret < 0)
197  goto fail;
198 
199  return 0;
200 fail:
201  av_bsf_free(&avci->bsf);
202  return ret;
203 }
204 
206 {
207  AVCodecInternal *avci = avctx->internal;
208  int ret;
209 
210  if (avci->draining)
211  return AVERROR_EOF;
212 
213  ret = av_bsf_receive_packet(avci->bsf, pkt);
214  if (ret == AVERROR_EOF)
215  avci->draining = 1;
216  if (ret < 0)
217  return ret;
218 
221  if (ret < 0)
222  goto finish;
223  }
224 
225  ret = apply_param_change(avctx, pkt);
226  if (ret < 0)
227  goto finish;
228 
229  return 0;
230 finish:
232  return ret;
233 }
234 
235 /**
236  * Attempt to guess proper monotonic timestamps for decoded video frames
237  * which might have incorrect times. Input timestamps may wrap around, in
238  * which case the output will as well.
239  *
240  * @param pts the pts field of the decoded AVPacket, as passed through
241  * AVFrame.pts
242  * @param dts the dts field of the decoded AVPacket
243  * @return one of the input values, may be AV_NOPTS_VALUE
244  */
246  int64_t reordered_pts, int64_t dts)
247 {
248  int64_t pts = AV_NOPTS_VALUE;
249 
250  if (dts != AV_NOPTS_VALUE) {
251  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
252  ctx->pts_correction_last_dts = dts;
253  } else if (reordered_pts != AV_NOPTS_VALUE)
254  ctx->pts_correction_last_dts = reordered_pts;
255 
256  if (reordered_pts != AV_NOPTS_VALUE) {
257  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
258  ctx->pts_correction_last_pts = reordered_pts;
259  } else if(dts != AV_NOPTS_VALUE)
260  ctx->pts_correction_last_pts = dts;
261 
262  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
263  && reordered_pts != AV_NOPTS_VALUE)
264  pts = reordered_pts;
265  else
266  pts = dts;
267 
268  return pts;
269 }
270 
271 /*
272  * The core of the receive_frame_wrapper for the decoders implementing
273  * the simple API. Certain decoders might consume partial packets without
274  * returning any output, so this function needs to be called in a loop until it
275  * returns EAGAIN.
276  **/
277 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
278 {
279  AVCodecInternal *avci = avctx->internal;
280  AVPacket *const pkt = avci->in_pkt;
281  const FFCodec *const codec = ffcodec(avctx->codec);
282  int got_frame, actual_got_frame;
283  int ret;
284 
285  if (!pkt->data && !avci->draining) {
287  ret = ff_decode_get_packet(avctx, pkt);
288  if (ret < 0 && ret != AVERROR_EOF)
289  return ret;
290  }
291 
292  // Some codecs (at least wma lossless) will crash when feeding drain packets
293  // after EOF was signaled.
294  if (avci->draining_done)
295  return AVERROR_EOF;
296 
297  if (!pkt->data &&
298  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
300  return AVERROR_EOF;
301 
302  got_frame = 0;
303 
304  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
305  ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
306  } else {
307  ret = codec->cb.decode(avctx, frame, &got_frame, pkt);
308 
310  frame->pkt_dts = pkt->dts;
311  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
312  if(!avctx->has_b_frames)
313  frame->pkt_pos = pkt->pos;
314  //FIXME these should be under if(!avctx->has_b_frames)
315  /* get_buffer is supposed to set frame parameters */
316  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
317  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
318  if (!frame->width) frame->width = avctx->width;
319  if (!frame->height) frame->height = avctx->height;
320  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
321  }
322  }
323  }
324  emms_c();
325  actual_got_frame = got_frame;
326 
327  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
328  if (frame->flags & AV_FRAME_FLAG_DISCARD)
329  got_frame = 0;
330  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
331  uint8_t *side;
332  size_t side_size;
333  uint32_t discard_padding = 0;
334  uint8_t skip_reason = 0;
335  uint8_t discard_reason = 0;
336 
337  if (ret >= 0 && got_frame) {
338  if (frame->format == AV_SAMPLE_FMT_NONE)
339  frame->format = avctx->sample_fmt;
340  if (!frame->ch_layout.nb_channels) {
341  int ret2 = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
342  if (ret2 < 0) {
343  ret = ret2;
344  got_frame = 0;
345  }
346  }
347 #if FF_API_OLD_CHANNEL_LAYOUT
349  if (!frame->channel_layout)
350  frame->channel_layout = avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
351  avctx->ch_layout.u.mask : 0;
352  if (!frame->channels)
353  frame->channels = avctx->ch_layout.nb_channels;
355 #endif
356  if (!frame->sample_rate)
357  frame->sample_rate = avctx->sample_rate;
358  }
359 
361  if(side && side_size>=10) {
362  avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
363  avci->skip_samples = FFMAX(0, avci->skip_samples);
364  discard_padding = AV_RL32(side + 4);
365  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
366  avci->skip_samples, (int)discard_padding);
367  skip_reason = AV_RL8(side + 8);
368  discard_reason = AV_RL8(side + 9);
369  }
370 
371  if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
372  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
373  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
374  got_frame = 0;
375  *discarded_samples += frame->nb_samples;
376  }
377 
378  if (avci->skip_samples > 0 && got_frame &&
379  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
380  if(frame->nb_samples <= avci->skip_samples){
381  got_frame = 0;
382  *discarded_samples += frame->nb_samples;
383  avci->skip_samples -= frame->nb_samples;
384  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
385  avci->skip_samples);
386  } else {
387  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
388  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
389  if(avctx->pkt_timebase.num && avctx->sample_rate) {
390  int64_t diff_ts = av_rescale_q(avci->skip_samples,
391  (AVRational){1, avctx->sample_rate},
392  avctx->pkt_timebase);
393  if(frame->pts!=AV_NOPTS_VALUE)
394  frame->pts += diff_ts;
395  if(frame->pkt_dts!=AV_NOPTS_VALUE)
396  frame->pkt_dts += diff_ts;
397  if (frame->pkt_duration >= diff_ts)
398  frame->pkt_duration -= diff_ts;
399  } else {
400  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
401  }
402  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
403  avci->skip_samples, frame->nb_samples);
404  *discarded_samples += avci->skip_samples;
405  frame->nb_samples -= avci->skip_samples;
406  avci->skip_samples = 0;
407  }
408  }
409 
410  if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
411  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
412  if (discard_padding == frame->nb_samples) {
413  *discarded_samples += frame->nb_samples;
414  got_frame = 0;
415  } else {
416  if(avctx->pkt_timebase.num && avctx->sample_rate) {
417  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
418  (AVRational){1, avctx->sample_rate},
419  avctx->pkt_timebase);
420  frame->pkt_duration = diff_ts;
421  } else {
422  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
423  }
424  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
425  (int)discard_padding, frame->nb_samples);
426  frame->nb_samples -= discard_padding;
427  }
428  }
429 
430  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
432  if (fside) {
433  AV_WL32(fside->data, avci->skip_samples);
434  AV_WL32(fside->data + 4, discard_padding);
435  AV_WL8(fside->data + 8, skip_reason);
436  AV_WL8(fside->data + 9, discard_reason);
437  avci->skip_samples = 0;
438  }
439  }
440  }
441 
442  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
444  ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
445  av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
446  avci->showed_multi_packet_warning = 1;
447  }
448 
449  if (!got_frame)
451 
452 #if FF_API_FLAG_TRUNCATED
453  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
454 #else
455  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
456 #endif
457  ret = pkt->size;
458 
459 #if FF_API_AVCTX_TIMEBASE
460  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
461  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
462 #endif
463 
464  /* do not stop draining when actual_got_frame != 0 or ret < 0 */
465  /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
466  if (avci->draining && !actual_got_frame) {
467  if (ret < 0) {
468  /* prevent infinite loop if a decoder wrongly always return error on draining */
469  /* reasonable nb_errors_max = maximum b frames + thread count */
470  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
471  avctx->thread_count : 1);
472 
473  if (avci->nb_draining_errors++ >= nb_errors_max) {
474  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
475  "Stop draining and force EOF.\n");
476  avci->draining_done = 1;
477  ret = AVERROR_BUG;
478  }
479  } else {
480  avci->draining_done = 1;
481  }
482  }
483 
484  if (ret >= pkt->size || ret < 0) {
487  } else {
488  int consumed = ret;
489 
490  pkt->data += consumed;
491  pkt->size -= consumed;
495  avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
498  }
499  }
500 
501  if (got_frame)
502  av_assert0(frame->buf[0]);
503 
504  return ret < 0 ? ret : 0;
505 }
506 
508 {
509  int ret;
510  int64_t discarded_samples = 0;
511 
512  while (!frame->buf[0]) {
513  if (discarded_samples > avctx->max_samples)
514  return AVERROR(EAGAIN);
515  ret = decode_simple_internal(avctx, frame, &discarded_samples);
516  if (ret < 0)
517  return ret;
518  }
519 
520  return 0;
521 }
522 
524 {
525  AVCodecInternal *avci = avctx->internal;
526  const FFCodec *const codec = ffcodec(avctx->codec);
527  int ret;
528 
529  av_assert0(!frame->buf[0]);
530 
531  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
532  ret = codec->cb.receive_frame(avctx, frame);
533  if (ret != AVERROR(EAGAIN))
535  } else
537 
538  if (ret == AVERROR_EOF)
539  avci->draining_done = 1;
540 
542  IS_EMPTY(avci->last_pkt_props)) {
543  // May fail if the FIFO is empty.
544  av_fifo_read(avci->pkt_props, avci->last_pkt_props, 1);
545  }
546 
547  if (!ret) {
548  frame->best_effort_timestamp = guess_correct_pts(avctx,
549  frame->pts,
550  frame->pkt_dts);
551 
552  /* the only case where decode data is not set should be decoders
553  * that do not call ff_get_buffer() */
554  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
555  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
556 
557  if (frame->private_ref) {
558  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
559 
560  if (fdd->post_process) {
561  ret = fdd->post_process(avctx, frame);
562  if (ret < 0) {
564  return ret;
565  }
566  }
567  }
568  }
569 
570  /* free the per-frame decode data */
571  av_buffer_unref(&frame->private_ref);
572 
573  return ret;
574 }
575 
576 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
577 {
578  AVCodecInternal *avci = avctx->internal;
579  int ret;
580 
581  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
582  return AVERROR(EINVAL);
583 
584  if (avctx->internal->draining)
585  return AVERROR_EOF;
586 
587  if (avpkt && !avpkt->size && avpkt->data)
588  return AVERROR(EINVAL);
589 
591  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
592  ret = av_packet_ref(avci->buffer_pkt, avpkt);
593  if (ret < 0)
594  return ret;
595  }
596 
597  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
598  if (ret < 0) {
600  return ret;
601  }
602 
603  if (!avci->buffer_frame->buf[0]) {
605  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
606  return ret;
607  }
608 
609  return 0;
610 }
611 
613 {
614  /* make sure we are noisy about decoders returning invalid cropping data */
615  if (frame->crop_left >= INT_MAX - frame->crop_right ||
616  frame->crop_top >= INT_MAX - frame->crop_bottom ||
617  (frame->crop_left + frame->crop_right) >= frame->width ||
618  (frame->crop_top + frame->crop_bottom) >= frame->height) {
619  av_log(avctx, AV_LOG_WARNING,
620  "Invalid cropping information set by a decoder: "
622  "(frame size %dx%d). This is a bug, please report it\n",
623  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
624  frame->width, frame->height);
625  frame->crop_left = 0;
626  frame->crop_right = 0;
627  frame->crop_top = 0;
628  frame->crop_bottom = 0;
629  return 0;
630  }
631 
632  if (!avctx->apply_cropping)
633  return 0;
634 
637 }
638 
639 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
640 {
641  AVCodecInternal *avci = avctx->internal;
642  int ret, changed;
643 
645 
646  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
647  return AVERROR(EINVAL);
648 
649  if (avci->buffer_frame->buf[0]) {
651  } else {
653  if (ret < 0)
654  return ret;
655  }
656 
657  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
658  ret = apply_cropping(avctx, frame);
659  if (ret < 0) {
661  return ret;
662  }
663  }
664 
665  avctx->frame_number++;
666 
667  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
668 
669  if (avctx->frame_number == 1) {
670  avci->initial_format = frame->format;
671  switch(avctx->codec_type) {
672  case AVMEDIA_TYPE_VIDEO:
673  avci->initial_width = frame->width;
674  avci->initial_height = frame->height;
675  break;
676  case AVMEDIA_TYPE_AUDIO:
677  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
678  avctx->sample_rate;
679 #if FF_API_OLD_CHANNEL_LAYOUT
681  avci->initial_channels = frame->ch_layout.nb_channels;
682  avci->initial_channel_layout = frame->channel_layout;
684 #endif
685  ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
686  if (ret < 0) {
688  return ret;
689  }
690  break;
691  }
692  }
693 
694  if (avctx->frame_number > 1) {
695  changed = avci->initial_format != frame->format;
696 
697  switch(avctx->codec_type) {
698  case AVMEDIA_TYPE_VIDEO:
699  changed |= avci->initial_width != frame->width ||
700  avci->initial_height != frame->height;
701  break;
702  case AVMEDIA_TYPE_AUDIO:
704  changed |= avci->initial_sample_rate != frame->sample_rate ||
705  avci->initial_sample_rate != avctx->sample_rate ||
706 #if FF_API_OLD_CHANNEL_LAYOUT
707  avci->initial_channels != frame->channels ||
708  avci->initial_channel_layout != frame->channel_layout ||
709 #endif
712  break;
713  }
714 
715  if (changed) {
716  avci->changed_frames_dropped++;
717  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
718  " drop count: %d \n",
719  avctx->frame_number, frame->pts,
720  avci->changed_frames_dropped);
722  return AVERROR_INPUT_CHANGED;
723  }
724  }
725  }
726  return 0;
727 }
728 
730 {
731  memset(sub, 0, sizeof(*sub));
732  sub->pts = AV_NOPTS_VALUE;
733 }
734 
735 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
736 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
737  AVPacket *inpkt, AVPacket *buf_pkt)
738 {
739 #if CONFIG_ICONV
740  iconv_t cd = (iconv_t)-1;
741  int ret = 0;
742  char *inb, *outb;
743  size_t inl, outl;
744 #endif
745 
746  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
747  *outpkt = inpkt;
748  return 0;
749  }
750 
751 #if CONFIG_ICONV
752  inb = inpkt->data;
753  inl = inpkt->size;
754 
755  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
756  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
757  return AVERROR(ERANGE);
758  }
759 
760  cd = iconv_open("UTF-8", avctx->sub_charenc);
761  av_assert0(cd != (iconv_t)-1);
762 
763  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
764  if (ret < 0)
765  goto end;
766  ret = av_packet_copy_props(buf_pkt, inpkt);
767  if (ret < 0)
768  goto end;
769  outb = buf_pkt->data;
770  outl = buf_pkt->size;
771 
772  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
773  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
774  outl >= buf_pkt->size || inl != 0) {
775  ret = FFMIN(AVERROR(errno), -1);
776  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
777  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
778  goto end;
779  }
780  buf_pkt->size -= outl;
781  memset(buf_pkt->data + buf_pkt->size, 0, outl);
782  *outpkt = buf_pkt;
783 
784  ret = 0;
785 end:
786  if (ret < 0)
787  av_packet_unref(buf_pkt);
788  if (cd != (iconv_t)-1)
789  iconv_close(cd);
790  return ret;
791 #else
792  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
793  return AVERROR(EINVAL);
794 #endif
795 }
796 
797 static int utf8_check(const uint8_t *str)
798 {
799  const uint8_t *byte;
800  uint32_t codepoint, min;
801 
802  while (*str) {
803  byte = str;
804  GET_UTF8(codepoint, *(byte++), return 0;);
805  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
806  1 << (5 * (byte - str) - 4);
807  if (codepoint < min || codepoint >= 0x110000 ||
808  codepoint == 0xFFFE /* BOM */ ||
809  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
810  return 0;
811  str = byte;
812  }
813  return 1;
814 }
815 
817  int *got_sub_ptr,
818  AVPacket *avpkt)
819 {
820  int ret = 0;
821 
822  if (!avpkt->data && avpkt->size) {
823  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
824  return AVERROR(EINVAL);
825  }
826  if (!avctx->codec)
827  return AVERROR(EINVAL);
828  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
829  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
830  return AVERROR(EINVAL);
831  }
832 
833  *got_sub_ptr = 0;
835 
836  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
837  AVCodecInternal *avci = avctx->internal;
838  AVPacket *pkt;
839 
840  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
841  if (ret < 0)
842  return ret;
843 
844  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
845  sub->pts = av_rescale_q(avpkt->pts,
846  avctx->pkt_timebase, AV_TIME_BASE_Q);
847  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
848  if (pkt == avci->buffer_pkt) // did we recode?
850  if (ret < 0) {
851  *got_sub_ptr = 0;
853  return ret;
854  }
855  av_assert1(!sub->num_rects || *got_sub_ptr);
856 
857  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
858  avctx->pkt_timebase.num) {
859  AVRational ms = { 1, 1000 };
860  sub->end_display_time = av_rescale_q(avpkt->duration,
861  avctx->pkt_timebase, ms);
862  }
863 
865  sub->format = 0;
866  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
867  sub->format = 1;
868 
869  for (unsigned i = 0; i < sub->num_rects; i++) {
871  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
872  av_log(avctx, AV_LOG_ERROR,
873  "Invalid UTF-8 in decoded subtitles text; "
874  "maybe missing -sub_charenc option\n");
876  *got_sub_ptr = 0;
877  return AVERROR_INVALIDDATA;
878  }
879  }
880 
881  if (*got_sub_ptr)
882  avctx->frame_number++;
883  }
884 
885  return ret;
886 }
887 
889  const enum AVPixelFormat *fmt)
890 {
891  const AVPixFmtDescriptor *desc;
892  const AVCodecHWConfig *config;
893  int i, n;
894 
895  // If a device was supplied when the codec was opened, assume that the
896  // user wants to use it.
897  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
898  AVHWDeviceContext *device_ctx =
900  for (i = 0;; i++) {
901  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
902  if (!config)
903  break;
904  if (!(config->methods &
906  continue;
907  if (device_ctx->type != config->device_type)
908  continue;
909  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
910  if (config->pix_fmt == fmt[n])
911  return fmt[n];
912  }
913  }
914  }
915  // No device or other setup, so we have to choose from things which
916  // don't any other external information.
917 
918  // If the last element of the list is a software format, choose it
919  // (this should be best software format if any exist).
920  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
921  desc = av_pix_fmt_desc_get(fmt[n - 1]);
922  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
923  return fmt[n - 1];
924 
925  // Finally, traverse the list in order and choose the first entry
926  // with no external dependencies (if there is no hardware configuration
927  // information available then this just picks the first entry).
928  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
929  for (i = 0;; i++) {
930  config = avcodec_get_hw_config(avctx->codec, i);
931  if (!config)
932  break;
933  if (config->pix_fmt == fmt[n])
934  break;
935  }
936  if (!config) {
937  // No specific config available, so the decoder must be able
938  // to handle this format without any additional setup.
939  return fmt[n];
940  }
942  // Usable with only internal setup.
943  return fmt[n];
944  }
945  }
946 
947  // Nothing is usable, give up.
948  return AV_PIX_FMT_NONE;
949 }
950 
952  enum AVHWDeviceType dev_type)
953 {
954  AVHWDeviceContext *device_ctx;
955  AVHWFramesContext *frames_ctx;
956  int ret;
957 
958  if (!avctx->hwaccel)
959  return AVERROR(ENOSYS);
960 
961  if (avctx->hw_frames_ctx)
962  return 0;
963  if (!avctx->hw_device_ctx) {
964  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
965  "required for hardware accelerated decoding.\n");
966  return AVERROR(EINVAL);
967  }
968 
969  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
970  if (device_ctx->type != dev_type) {
971  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
972  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
973  av_hwdevice_get_type_name(device_ctx->type));
974  return AVERROR(EINVAL);
975  }
976 
978  avctx->hw_device_ctx,
979  avctx->hwaccel->pix_fmt,
980  &avctx->hw_frames_ctx);
981  if (ret < 0)
982  return ret;
983 
984  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
985 
986 
987  if (frames_ctx->initial_pool_size) {
988  // We guarantee 4 base work surfaces. The function above guarantees 1
989  // (the absolute minimum), so add the missing count.
990  frames_ctx->initial_pool_size += 3;
991  }
992 
994  if (ret < 0) {
996  return ret;
997  }
998 
999  return 0;
1000 }
1001 
1003  AVBufferRef *device_ref,
1005  AVBufferRef **out_frames_ref)
1006 {
1007  AVBufferRef *frames_ref = NULL;
1008  const AVCodecHWConfigInternal *hw_config;
1009  const AVHWAccel *hwa;
1010  int i, ret;
1011 
1012  for (i = 0;; i++) {
1013  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1014  if (!hw_config)
1015  return AVERROR(ENOENT);
1016  if (hw_config->public.pix_fmt == hw_pix_fmt)
1017  break;
1018  }
1019 
1020  hwa = hw_config->hwaccel;
1021  if (!hwa || !hwa->frame_params)
1022  return AVERROR(ENOENT);
1023 
1024  frames_ref = av_hwframe_ctx_alloc(device_ref);
1025  if (!frames_ref)
1026  return AVERROR(ENOMEM);
1027 
1028  ret = hwa->frame_params(avctx, frames_ref);
1029  if (ret >= 0) {
1030  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1031 
1032  if (frames_ctx->initial_pool_size) {
1033  // If the user has requested that extra output surfaces be
1034  // available then add them here.
1035  if (avctx->extra_hw_frames > 0)
1036  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1037 
1038  // If frame threading is enabled then an extra surface per thread
1039  // is also required.
1040  if (avctx->active_thread_type & FF_THREAD_FRAME)
1041  frames_ctx->initial_pool_size += avctx->thread_count;
1042  }
1043 
1044  *out_frames_ref = frames_ref;
1045  } else {
1046  av_buffer_unref(&frames_ref);
1047  }
1048  return ret;
1049 }
1050 
1051 static int hwaccel_init(AVCodecContext *avctx,
1052  const AVCodecHWConfigInternal *hw_config)
1053 {
1054  const AVHWAccel *hwaccel;
1055  int err;
1056 
1057  hwaccel = hw_config->hwaccel;
1060  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1061  hwaccel->name);
1062  return AVERROR_PATCHWELCOME;
1063  }
1064 
1065  if (hwaccel->priv_data_size) {
1066  avctx->internal->hwaccel_priv_data =
1067  av_mallocz(hwaccel->priv_data_size);
1068  if (!avctx->internal->hwaccel_priv_data)
1069  return AVERROR(ENOMEM);
1070  }
1071 
1072  avctx->hwaccel = hwaccel;
1073  if (hwaccel->init) {
1074  err = hwaccel->init(avctx);
1075  if (err < 0) {
1076  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1077  "hwaccel initialisation returned error.\n",
1078  av_get_pix_fmt_name(hw_config->public.pix_fmt));
1080  avctx->hwaccel = NULL;
1081  return err;
1082  }
1083  }
1084 
1085  return 0;
1086 }
1087 
1088 static void hwaccel_uninit(AVCodecContext *avctx)
1089 {
1090  if (avctx->hwaccel && avctx->hwaccel->uninit)
1091  avctx->hwaccel->uninit(avctx);
1092 
1094 
1095  avctx->hwaccel = NULL;
1096 
1097  av_buffer_unref(&avctx->hw_frames_ctx);
1098 }
1099 
1100 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1101 {
1102  const AVPixFmtDescriptor *desc;
1103  enum AVPixelFormat *choices;
1104  enum AVPixelFormat ret, user_choice;
1105  const AVCodecHWConfigInternal *hw_config;
1106  const AVCodecHWConfig *config;
1107  int i, n, err;
1108 
1109  // Find end of list.
1110  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1111  // Must contain at least one entry.
1112  av_assert0(n >= 1);
1113  // If a software format is available, it must be the last entry.
1114  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1115  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1116  // No software format is available.
1117  } else {
1118  avctx->sw_pix_fmt = fmt[n - 1];
1119  }
1120 
1121  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1122  if (!choices)
1123  return AV_PIX_FMT_NONE;
1124 
1125  for (;;) {
1126  // Remove the previous hwaccel, if there was one.
1127  hwaccel_uninit(avctx);
1128 
1129  user_choice = avctx->get_format(avctx, choices);
1130  if (user_choice == AV_PIX_FMT_NONE) {
1131  // Explicitly chose nothing, give up.
1132  ret = AV_PIX_FMT_NONE;
1133  break;
1134  }
1135 
1136  desc = av_pix_fmt_desc_get(user_choice);
1137  if (!desc) {
1138  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1139  "get_format() callback.\n");
1140  ret = AV_PIX_FMT_NONE;
1141  break;
1142  }
1143  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1144  desc->name);
1145 
1146  for (i = 0; i < n; i++) {
1147  if (choices[i] == user_choice)
1148  break;
1149  }
1150  if (i == n) {
1151  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1152  "%s not in possible list.\n", desc->name);
1153  ret = AV_PIX_FMT_NONE;
1154  break;
1155  }
1156 
1157  if (ffcodec(avctx->codec)->hw_configs) {
1158  for (i = 0;; i++) {
1159  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1160  if (!hw_config)
1161  break;
1162  if (hw_config->public.pix_fmt == user_choice)
1163  break;
1164  }
1165  } else {
1166  hw_config = NULL;
1167  }
1168 
1169  if (!hw_config) {
1170  // No config available, so no extra setup required.
1171  ret = user_choice;
1172  break;
1173  }
1174  config = &hw_config->public;
1175 
1176  if (config->methods &
1178  avctx->hw_frames_ctx) {
1179  const AVHWFramesContext *frames_ctx =
1181  if (frames_ctx->format != user_choice) {
1182  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1183  "does not match the format of the provided frames "
1184  "context.\n", desc->name);
1185  goto try_again;
1186  }
1187  } else if (config->methods &
1189  avctx->hw_device_ctx) {
1190  const AVHWDeviceContext *device_ctx =
1192  if (device_ctx->type != config->device_type) {
1193  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1194  "does not match the type of the provided device "
1195  "context.\n", desc->name);
1196  goto try_again;
1197  }
1198  } else if (config->methods &
1200  // Internal-only setup, no additional configuration.
1201  } else if (config->methods &
1203  // Some ad-hoc configuration we can't see and can't check.
1204  } else {
1205  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1206  "missing configuration.\n", desc->name);
1207  goto try_again;
1208  }
1209  if (hw_config->hwaccel) {
1210  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1211  "initialisation.\n", desc->name);
1212  err = hwaccel_init(avctx, hw_config);
1213  if (err < 0)
1214  goto try_again;
1215  }
1216  ret = user_choice;
1217  break;
1218 
1219  try_again:
1220  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1221  "get_format() without it.\n", desc->name);
1222  for (i = 0; i < n; i++) {
1223  if (choices[i] == user_choice)
1224  break;
1225  }
1226  for (; i + 1 < n; i++)
1227  choices[i] = choices[i + 1];
1228  --n;
1229  }
1230 
1231  av_freep(&choices);
1232  return ret;
1233 }
1234 
1236 {
1237  size_t size;
1238  const uint8_t *side_metadata;
1239 
1240  AVDictionary **frame_md = &frame->metadata;
1241 
1242  side_metadata = av_packet_get_side_data(avpkt,
1244  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1245 }
1246 
1248 {
1249  AVPacket *pkt = avctx->internal->last_pkt_props;
1250  static const struct {
1251  enum AVPacketSideDataType packet;
1253  } sd[] = {
1265  };
1266 
1268  frame->pts = pkt->pts;
1269  frame->pkt_pos = pkt->pos;
1270  frame->pkt_duration = pkt->duration;
1271  frame->pkt_size = pkt->size;
1272 
1273  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1274  size_t size;
1275  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1276  if (packet_sd) {
1278  sd[i].frame,
1279  size);
1280  if (!frame_sd)
1281  return AVERROR(ENOMEM);
1282 
1283  memcpy(frame_sd->data, packet_sd, size);
1284  }
1285  }
1287 
1288  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1289  frame->flags |= AV_FRAME_FLAG_DISCARD;
1290  } else {
1291  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1292  }
1293  }
1294  frame->reordered_opaque = avctx->reordered_opaque;
1295 
1296  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1297  frame->color_primaries = avctx->color_primaries;
1298  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1299  frame->color_trc = avctx->color_trc;
1300  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1301  frame->colorspace = avctx->colorspace;
1302  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1303  frame->color_range = avctx->color_range;
1304  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1305  frame->chroma_location = avctx->chroma_sample_location;
1306 
1307  switch (avctx->codec->type) {
1308  case AVMEDIA_TYPE_VIDEO:
1309  frame->format = avctx->pix_fmt;
1310  if (!frame->sample_aspect_ratio.num)
1311  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1312 
1313  if (frame->width && frame->height &&
1314  av_image_check_sar(frame->width, frame->height,
1315  frame->sample_aspect_ratio) < 0) {
1316  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1317  frame->sample_aspect_ratio.num,
1318  frame->sample_aspect_ratio.den);
1319  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1320  }
1321 
1322  break;
1323  case AVMEDIA_TYPE_AUDIO:
1324  if (!frame->sample_rate)
1325  frame->sample_rate = avctx->sample_rate;
1326  if (frame->format < 0)
1327  frame->format = avctx->sample_fmt;
1328  if (!frame->ch_layout.nb_channels) {
1329  int ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
1330  if (ret < 0)
1331  return ret;
1332  }
1333 #if FF_API_OLD_CHANNEL_LAYOUT
1335  frame->channels = frame->ch_layout.nb_channels;
1336  frame->channel_layout = frame->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
1337  frame->ch_layout.u.mask : 0;
1339 #endif
1340  break;
1341  }
1342  return 0;
1343 }
1344 
1346 {
1347  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1348  int i;
1349  int num_planes = av_pix_fmt_count_planes(frame->format);
1351  int flags = desc ? desc->flags : 0;
1352  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1353  num_planes = 2;
1354  for (i = 0; i < num_planes; i++) {
1355  av_assert0(frame->data[i]);
1356  }
1357  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1358  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1359  if (frame->data[i])
1360  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1361  frame->data[i] = NULL;
1362  }
1363  }
1364 }
1365 
1366 static void decode_data_free(void *opaque, uint8_t *data)
1367 {
1369 
1370  if (fdd->post_process_opaque_free)
1372 
1373  if (fdd->hwaccel_priv_free)
1374  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1375 
1376  av_freep(&fdd);
1377 }
1378 
1380 {
1381  AVBufferRef *fdd_buf;
1382  FrameDecodeData *fdd;
1383 
1384  av_assert1(!frame->private_ref);
1385  av_buffer_unref(&frame->private_ref);
1386 
1387  fdd = av_mallocz(sizeof(*fdd));
1388  if (!fdd)
1389  return AVERROR(ENOMEM);
1390 
1391  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1393  if (!fdd_buf) {
1394  av_freep(&fdd);
1395  return AVERROR(ENOMEM);
1396  }
1397 
1398  frame->private_ref = fdd_buf;
1399 
1400  return 0;
1401 }
1402 
1404 {
1405  const AVHWAccel *hwaccel = avctx->hwaccel;
1406  int override_dimensions = 1;
1407  int ret;
1408 
1410 
1411  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1412  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1413  (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) {
1414  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1415  ret = AVERROR(EINVAL);
1416  goto fail;
1417  }
1418 
1419  if (frame->width <= 0 || frame->height <= 0) {
1420  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1421  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1422  override_dimensions = 0;
1423  }
1424 
1425  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1426  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1427  ret = AVERROR(EINVAL);
1428  goto fail;
1429  }
1430  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1431 #if FF_API_OLD_CHANNEL_LAYOUT
1433  /* compat layer for old-style get_buffer() implementations */
1434  avctx->channels = avctx->ch_layout.nb_channels;
1435  avctx->channel_layout = (avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) ?
1436  avctx->ch_layout.u.mask : 0;
1438 #endif
1439 
1440  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1441  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1442  ret = AVERROR(EINVAL);
1443  goto fail;
1444  }
1445  }
1446  ret = ff_decode_frame_props(avctx, frame);
1447  if (ret < 0)
1448  goto fail;
1449 
1450  if (hwaccel) {
1451  if (hwaccel->alloc_frame) {
1452  ret = hwaccel->alloc_frame(avctx, frame);
1453  goto end;
1454  }
1455  } else
1456  avctx->sw_pix_fmt = avctx->pix_fmt;
1457 
1458  ret = avctx->get_buffer2(avctx, frame, flags);
1459  if (ret < 0)
1460  goto fail;
1461 
1463 
1465  if (ret < 0)
1466  goto fail;
1467 
1468 end:
1469  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1471  frame->width = avctx->width;
1472  frame->height = avctx->height;
1473  }
1474 
1475 fail:
1476  if (ret < 0) {
1477  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1479  }
1480 
1481  return ret;
1482 }
1483 
1485 {
1486  AVFrame *tmp;
1487  int ret;
1488 
1490 
1491  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1492  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1493  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1495  }
1496 
1497  if (!frame->data[0])
1498  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1499 
1501  return ff_decode_frame_props(avctx, frame);
1502 
1503  tmp = av_frame_alloc();
1504  if (!tmp)
1505  return AVERROR(ENOMEM);
1506 
1508 
1510  if (ret < 0) {
1511  av_frame_free(&tmp);
1512  return ret;
1513  }
1514 
1516  av_frame_free(&tmp);
1517 
1518  return 0;
1519 }
1520 
1522 {
1523  int ret = reget_buffer_internal(avctx, frame, flags);
1524  if (ret < 0)
1525  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1526  return ret;
1527 }
1528 
1530 {
1531  AVCodecInternal *avci = avctx->internal;
1532  int ret = 0;
1533 
1534  /* if the decoder init function was already called previously,
1535  * free the already allocated subtitle_header before overwriting it */
1536  av_freep(&avctx->subtitle_header);
1537 
1538 #if FF_API_THREAD_SAFE_CALLBACKS
1540  if ((avctx->thread_type & FF_THREAD_FRAME) &&
1542  !avctx->thread_safe_callbacks) {
1543  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
1544  "custom get_buffer2() implementation which is not marked as "
1545  "thread safe. This is not supported anymore, make your "
1546  "callback thread-safe.\n");
1547  }
1549 #endif
1550 
1551  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->ch_layout.nb_channels == 0 &&
1553  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
1554  return AVERROR(EINVAL);
1555  }
1556  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1557  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1558  avctx->codec->max_lowres);
1559  avctx->lowres = avctx->codec->max_lowres;
1560  }
1561  if (avctx->sub_charenc) {
1562  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1563  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1564  "supported with subtitles codecs\n");
1565  return AVERROR(EINVAL);
1566  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1567  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1568  "subtitles character encoding will be ignored\n",
1569  avctx->codec_descriptor->name);
1571  } else {
1572  /* input character encoding is set for a text based subtitle
1573  * codec at this point */
1576 
1578 #if CONFIG_ICONV
1579  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1580  if (cd == (iconv_t)-1) {
1581  ret = AVERROR(errno);
1582  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1583  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1584  return ret;
1585  }
1586  iconv_close(cd);
1587 #else
1588  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1589  "conversion needs a libavcodec built with iconv support "
1590  "for this codec\n");
1591  return AVERROR(ENOSYS);
1592 #endif
1593  }
1594  }
1595  }
1596 
1598  avctx->pts_correction_num_faulty_dts = 0;
1599  avctx->pts_correction_last_pts =
1600  avctx->pts_correction_last_dts = INT64_MIN;
1601 
1602  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1604  av_log(avctx, AV_LOG_WARNING,
1605  "gray decoding requested but not enabled at configuration time\n");
1606  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1608  }
1609 
1610  avci->in_pkt = av_packet_alloc();
1611  avci->last_pkt_props = av_packet_alloc();
1612  avci->pkt_props = av_fifo_alloc2(1, sizeof(*avci->last_pkt_props),
1614  if (!avci->in_pkt || !avci->last_pkt_props || !avci->pkt_props)
1615  return AVERROR(ENOMEM);
1616 
1617  ret = decode_bsfs_init(avctx);
1618  if (ret < 0)
1619  return ret;
1620 
1621  return 0;
1622 }
1623 
1624 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1625 {
1626  size_t size;
1627  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1628 
1629  if (pal && size == AVPALETTE_SIZE) {
1630  memcpy(dst, pal, AVPALETTE_SIZE);
1631  return 1;
1632  } else if (pal) {
1633  av_log(logctx, AV_LOG_ERROR,
1634  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1635  }
1636  return 0;
1637 }
AVSubtitle
Definition: avcodec.h:2306
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:145
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1379
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:318
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:195
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:205
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:653
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:966
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1100
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:612
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1305
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:672
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:73
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
Definition: avcodec.h:2222
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
avcodec_parameters_from_context
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:99
AV_PKT_FLAG_DISCARD
#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:436
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:115
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1344
AV_CODEC_FLAG_UNALIGNED
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e....
Definition: avcodec.h:212
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
AV_WL8
#define AV_WL8(p, d)
Definition: intreadwrite.h:399
decode_simple_receive_frame
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:507
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:34
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:334
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:959
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:215
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:816
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:58
AVHWAccel::capabilities
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2101
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:499
AV_CODEC_HW_CONFIG_METHOD_AD_HOC
@ AV_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
Definition: codec.h:347
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
data
const char data[16]
Definition: mxf.c:143
AVHWAccel::init
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: avcodec.h:2186
FFCodec
Definition: codec_internal.h:112
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1706
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:458
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:53
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
FF_SUB_CHARENC_MODE_PRE_DECODER
#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:1782
AVDictionary
Definition: dict.c:30
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:888
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:715
AVChannelLayout::mask
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
Definition: channel_layout.h:322
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:525
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:398
av_bsf_free
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:53
FF_SUB_CHARENC_MODE_AUTOMATIC
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:1781
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
av_frame_apply_cropping
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:863
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:637
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:338
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:312
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1733
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:216
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2702
AVHWAccel
Definition: avcodec.h:2068
fifo.h
finish
static void finish(void)
Definition: movenc.c:342
bsf.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:398
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:45
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
fail
#define fail()
Definition: checkasm.h:131
AVCodecInternal::showed_multi_packet_warning
int showed_multi_packet_warning
Definition: internal.h:134
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1463
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
AV_FRAME_CROP_UNALIGNED
@ AV_FRAME_CROP_UNALIGNED
Apply the maximum possible cropping, even if it requires setting the AVFrame.data[] entries to unalig...
Definition: frame.h:917
FF_SUB_CHARENC_MODE_DO_NOTHING
#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:1780
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FrameDecodeData::post_process_opaque_free
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h:47
pts
static int64_t pts
Definition: transcode_aac.c:654
add_metadata_from_side_data
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1235
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:577
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
guess_correct_pts
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:245
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1997
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
AVHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: avcodec.h:2200
av_image_check_size2
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:289
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:418
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:100
AVCodecContext::get_buffer2
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:1167
GET_UTF8
#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:469
AV_CODEC_FLAG_DROPCHANGED
#define AV_CODEC_FLAG_DROPCHANGED
Don't output frames whose parameters differ from first decoded frame in stream.
Definition: avcodec.h:233
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:952
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVCodecContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
Definition: avcodec.h:1761
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:112
hwaccel_uninit
static void hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1088
AVHWAccel::alloc_frame
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: avcodec.h:2114
copy_packet_props
static int copy_packet_props(AVPacket *dst, const AVPacket *src)
Definition: decode.c:137
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:121
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:685
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:459
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:729
FrameDecodeData::post_process_opaque
void * post_process_opaque
Definition: decode.h:46
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1345
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:130
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2194
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:367
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVERROR_INPUT_CHANGED
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
Definition: error.h:75
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:114
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:639
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AVCodecContext::thread_type
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1473
AV_PKT_DATA_ICC_PROFILE
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:275
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
FFCodec::cb
union FFCodec::@44 cb
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:300
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVCodecHWConfig::pix_fmt
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:359
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1909
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:93
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:474
FFCodec::decode
int(* decode)(struct AVCodecContext *avctx, struct AVFrame *frame, int *got_frame_ptr, struct AVPacket *avpkt)
Decode to an AVFrame.
Definition: codec_internal.h:178
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1366
ff_decode_get_hw_frames_ctx
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
Definition: decode.c:951
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecInternal::changed_frames_dropped
int changed_frames_dropped
Definition: internal.h:142
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:1771
AV_CODEC_FLAG2_SKIP_MANUAL
#define AV_CODEC_FLAG2_SKIP_MANUAL
Do not skip samples and export skip information as frame side data.
Definition: avcodec.h:329
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:150
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:797
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
AVChannelLayout::u
union AVChannelLayout::@296 u
Details about which channels are present in this layout.
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1967
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:973
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:231
AVCodec::type
enum AVMediaType type
Definition: codec.h:209
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:424
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_CODEC_PROP_BITMAP_SUB
#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
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:930
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
AV_CODEC_FLAG_TRUNCATED
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:261
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
AVCodecInternal::initial_height
int initial_height
Definition: internal.h:144
AVCodecContext::thread_safe_callbacks
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:1502
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:136
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:430
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1355
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:132
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:735
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:565
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:80
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:512
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:82
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1455
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:476
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:77
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:249
AVPacket::size
int size
Definition: packet.h:375
ff_thread_decode_frame
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
Definition: pthread_frame.c:510
byte
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:99
AVCodecContext::extra_hw_frames
int extra_hw_frames
Definition: avcodec.h:1981
codec_internal.h
FrameDecodeData::post_process
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
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:120
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:764
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:203
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
FF_CODEC_CAP_SETS_FRAME_PROPS
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
Definition: codec_internal.h:75
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:143
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:74
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1747
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:57
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrameSideData::data
uint8_t * data
Definition: frame.h:233
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:273
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:523
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:619
AVCodecHWConfigInternal
Definition: hwconfig.h:29
frame.h
av_packet_unpack_dictionary
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:342
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:1762
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:1763
hwaccel_init
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
Definition: decode.c:1051
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:62
AVCodecInternal
Definition: internal.h:48
FFCodec::hw_configs
const struct AVCodecHWConfigInternal *const * hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec_internal.h:246
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodecInternal::pkt_props
struct AVFifo * pkt_props
Definition: internal.h:81
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1474
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2074
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:290
avcodec_send_packet
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:576
av_samples_copy
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:222
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:121
extract_packet_props
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
Definition: decode.c:149
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:385
bprint.h
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:144
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1484
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:251
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:523
internal.h
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
common.h
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:73
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:243
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:1764
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1529
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:506
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1931
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:980
FF_CODEC_CAP_SETS_PKT_DTS
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: codec_internal.h:46
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:528
AVCodecContext::height
int height
Definition: avcodec.h:562
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:277
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:139
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1881
avcodec.h
FFCodec::decode_sub
int(* decode_sub)(struct AVCodecContext *avctx, struct AVSubtitle *sub, int *got_frame_ptr, const struct AVPacket *avpkt)
Decode subtitle data to an AVSubtitle.
Definition: codec_internal.h:186
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1779
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
avcodec_get_hw_frames_parameters
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:1002
ff_reget_buffer
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:1521
ret
ret
Definition: filter_design.txt:187
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:79
frame
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
Definition: filter_design.txt:264
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1300
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: internal.h:208
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:102
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:292
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:195
apply_param_change
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:52
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1247
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:331
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:389
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1482
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1754
channel_layout.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:2007
AV_CODEC_CAP_DELAY
#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:82
FF_CODEC_CB_TYPE_RECEIVE_FRAME
@ FF_CODEC_CB_TYPE_RECEIVE_FRAME
Definition: codec_internal.h:100
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
FFCodec::cb_type
unsigned cb_type
This field determines the type of the codec (decoder/encoder) and also the exact callback cb implemen...
Definition: codec_internal.h:128
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:879
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:131
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:121
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:125
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:237
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:577
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:199
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:397
AV_FRAME_FLAG_DISCARD
#define AV_FRAME_FLAG_DISCARD
A flag to mark the frames which need to be decoded, but shouldn't be output.
Definition: frame.h:563
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_bsf_list_parse_str
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:527
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
ff_set_dimensions
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:90
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:348
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:100
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1379
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:150
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1037
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt, AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:736
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:231
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:325
IS_EMPTY
#define IS_EMPTY(pkt)
Definition: decode.c:135
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVHWAccel::frame_params
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
Definition: avcodec.h:2215
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
AVCodecContext::reordered_opaque
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame....
Definition: avcodec.h:1372
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:52
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVCodecHWConfigInternal::hwaccel
const AVHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
Definition: hwconfig.h:39
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVCodecHWConfig
Definition: codec.h:350
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1740
av_image_check_sar
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:323
avstring.h
ff_copy_palette
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,...
Definition: decode.c:1624
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
decode_bsfs_init
static int decode_bsfs_init(AVCodecContext *avctx)
Definition: decode.c:170
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2095
AVCodecContext::sample_aspect_ratio
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:759
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:386
av_get_pix_fmt_name
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:2582
FF_SUB_CHARENC_MODE_IGNORE
#define FF_SUB_CHARENC_MODE_IGNORE
neither convert the subtitles, nor check them for valid UTF-8
Definition: avcodec.h:1783
min
float min
Definition: vorbis_enc_data.h:429
intmath.h