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"
32 #include "libavutil/common.h"
33 #include "libavutil/emms.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
39 #include "libavutil/mem.h"
40 
41 #include "avcodec.h"
42 #include "avcodec_internal.h"
43 #include "bytestream.h"
44 #include "bsf.h"
45 #include "codec_desc.h"
46 #include "codec_internal.h"
47 #include "decode.h"
48 #include "hwaccel_internal.h"
49 #include "hwconfig.h"
50 #include "internal.h"
51 #include "packet_internal.h"
52 #include "progressframe.h"
53 #include "refstruct.h"
54 #include "thread.h"
55 #include "threadprogress.h"
56 
57 typedef struct DecodeContext {
59 
60  /**
61  * This is set to AV_FRAME_FLAG_KEY for decoders of intra-only formats
62  * (those whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set)
63  * to set the flag generically.
64  */
66 
67  /**
68  * This is set to AV_PICTURE_TYPE_I for intra only video decoders
69  * and to AV_PICTURE_TYPE_NONE for other decoders. It is used to set
70  * the AVFrame's pict_type before the decoder receives it.
71  */
73 
74  /* to prevent infinite loop on errors when draining */
76 
77  /**
78  * The caller has submitted a NULL packet on input.
79  */
81 
82  int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
83  int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
84  int64_t pts_correction_last_pts; /// PTS of the last frame
85  int64_t pts_correction_last_dts; /// DTS of the last frame
86 
87  /**
88  * Bitmask indicating for which side data types we prefer user-supplied
89  * (global or attached to packets) side data over bytestream.
90  */
93 
95 {
96  return (DecodeContext *)avci;
97 }
98 
99 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
100 {
101  int ret;
102  size_t size;
103  const uint8_t *data;
104  uint32_t flags;
105  int64_t val;
106 
108  if (!data)
109  return 0;
110 
111  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
112  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
113  "changes, but PARAM_CHANGE side data was sent to it.\n");
114  ret = AVERROR(EINVAL);
115  goto fail2;
116  }
117 
118  if (size < 4)
119  goto fail;
120 
121  flags = bytestream_get_le32(&data);
122  size -= 4;
123 
125  if (size < 4)
126  goto fail;
127  val = bytestream_get_le32(&data);
128  if (val <= 0 || val > INT_MAX) {
129  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
131  goto fail2;
132  }
133  avctx->sample_rate = val;
134  size -= 4;
135  }
137  if (size < 8)
138  goto fail;
139  avctx->width = bytestream_get_le32(&data);
140  avctx->height = bytestream_get_le32(&data);
141  size -= 8;
142  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
143  if (ret < 0)
144  goto fail2;
145  }
146 
147  return 0;
148 fail:
149  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
151 fail2:
152  if (ret < 0) {
153  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
154  if (avctx->err_recognition & AV_EF_EXPLODE)
155  return ret;
156  }
157  return 0;
158 }
159 
161 {
162  int ret = 0;
163 
165  if (pkt) {
167 #if FF_API_FRAME_PKT
168  if (!ret)
169  avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props().
170 #endif
171  }
172  return ret;
173 }
174 
176 {
177  AVCodecInternal *avci = avctx->internal;
178  const FFCodec *const codec = ffcodec(avctx->codec);
179  int ret;
180 
181  if (avci->bsf)
182  return 0;
183 
184  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
185  if (ret < 0) {
186  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
187  if (ret != AVERROR(ENOMEM))
188  ret = AVERROR_BUG;
189  goto fail;
190  }
191 
192  /* We do not currently have an API for passing the input timebase into decoders,
193  * but no filters used here should actually need it.
194  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
195  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
197  if (ret < 0)
198  goto fail;
199 
200  ret = av_bsf_init(avci->bsf);
201  if (ret < 0)
202  goto fail;
203 
204  return 0;
205 fail:
206  av_bsf_free(&avci->bsf);
207  return ret;
208 }
209 
211 {
212  AVCodecInternal *avci = avctx->internal;
213  int ret;
214 
215  ret = av_bsf_receive_packet(avci->bsf, pkt);
216  if (ret == AVERROR_EOF)
217  avci->draining = 1;
218  if (ret < 0)
219  return ret;
220 
223  if (ret < 0)
224  goto finish;
225  }
226 
227  ret = apply_param_change(avctx, pkt);
228  if (ret < 0)
229  goto finish;
230 
231  return 0;
232 finish:
234  return ret;
235 }
236 
238 {
239  AVCodecInternal *avci = avctx->internal;
240  DecodeContext *dc = decode_ctx(avci);
241 
242  if (avci->draining)
243  return AVERROR_EOF;
244 
245  while (1) {
246  int ret = decode_get_packet(avctx, pkt);
247  if (ret == AVERROR(EAGAIN) &&
248  (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
249  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
250  if (ret < 0) {
252  return ret;
253  }
254 
255  continue;
256  }
257 
258  return ret;
259  }
260 }
261 
262 /**
263  * Attempt to guess proper monotonic timestamps for decoded video frames
264  * which might have incorrect times. Input timestamps may wrap around, in
265  * which case the output will as well.
266  *
267  * @param pts the pts field of the decoded AVPacket, as passed through
268  * AVFrame.pts
269  * @param dts the dts field of the decoded AVPacket
270  * @return one of the input values, may be AV_NOPTS_VALUE
271  */
273  int64_t reordered_pts, int64_t dts)
274 {
275  int64_t pts = AV_NOPTS_VALUE;
276 
277  if (dts != AV_NOPTS_VALUE) {
278  dc->pts_correction_num_faulty_dts += dts <= dc->pts_correction_last_dts;
279  dc->pts_correction_last_dts = dts;
280  } else if (reordered_pts != AV_NOPTS_VALUE)
281  dc->pts_correction_last_dts = reordered_pts;
282 
283  if (reordered_pts != AV_NOPTS_VALUE) {
284  dc->pts_correction_num_faulty_pts += reordered_pts <= dc->pts_correction_last_pts;
285  dc->pts_correction_last_pts = reordered_pts;
286  } else if(dts != AV_NOPTS_VALUE)
287  dc->pts_correction_last_pts = dts;
288 
289  if ((dc->pts_correction_num_faulty_pts<=dc->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
290  && reordered_pts != AV_NOPTS_VALUE)
291  pts = reordered_pts;
292  else
293  pts = dts;
294 
295  return pts;
296 }
297 
298 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
299 {
300  AVCodecInternal *avci = avctx->internal;
301  AVFrameSideData *side;
302  uint32_t discard_padding = 0;
303  uint8_t skip_reason = 0;
304  uint8_t discard_reason = 0;
305 
307  if (side && side->size >= 10) {
308  avci->skip_samples = AV_RL32(side->data);
309  avci->skip_samples = FFMAX(0, avci->skip_samples);
310  discard_padding = AV_RL32(side->data + 4);
311  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
312  avci->skip_samples, (int)discard_padding);
313  skip_reason = AV_RL8(side->data + 8);
314  discard_reason = AV_RL8(side->data + 9);
315  }
316 
317  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
318  if (!side && (avci->skip_samples || discard_padding))
320  if (side && (avci->skip_samples || discard_padding)) {
321  AV_WL32(side->data, avci->skip_samples);
322  AV_WL32(side->data + 4, discard_padding);
323  AV_WL8(side->data + 8, skip_reason);
324  AV_WL8(side->data + 9, discard_reason);
325  avci->skip_samples = 0;
326  }
327  return 0;
328  }
330 
331  if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
332  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
333  *discarded_samples += frame->nb_samples;
334  return AVERROR(EAGAIN);
335  }
336 
337  if (avci->skip_samples > 0) {
338  if (frame->nb_samples <= avci->skip_samples){
339  *discarded_samples += frame->nb_samples;
340  avci->skip_samples -= frame->nb_samples;
341  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
342  avci->skip_samples);
343  return AVERROR(EAGAIN);
344  } else {
345  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
346  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
347  if (avctx->pkt_timebase.num && avctx->sample_rate) {
348  int64_t diff_ts = av_rescale_q(avci->skip_samples,
349  (AVRational){1, avctx->sample_rate},
350  avctx->pkt_timebase);
351  if (frame->pts != AV_NOPTS_VALUE)
352  frame->pts += diff_ts;
353  if (frame->pkt_dts != AV_NOPTS_VALUE)
354  frame->pkt_dts += diff_ts;
355  if (frame->duration >= diff_ts)
356  frame->duration -= diff_ts;
357  } else
358  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
359 
360  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
361  avci->skip_samples, frame->nb_samples);
362  *discarded_samples += avci->skip_samples;
363  frame->nb_samples -= avci->skip_samples;
364  avci->skip_samples = 0;
365  }
366  }
367 
368  if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
369  if (discard_padding == frame->nb_samples) {
370  *discarded_samples += frame->nb_samples;
371  return AVERROR(EAGAIN);
372  } else {
373  if (avctx->pkt_timebase.num && avctx->sample_rate) {
374  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
375  (AVRational){1, avctx->sample_rate},
376  avctx->pkt_timebase);
377  frame->duration = diff_ts;
378  } else
379  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
380 
381  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
382  (int)discard_padding, frame->nb_samples);
383  frame->nb_samples -= discard_padding;
384  }
385  }
386 
387  return 0;
388 }
389 
390 /*
391  * The core of the receive_frame_wrapper for the decoders implementing
392  * the simple API. Certain decoders might consume partial packets without
393  * returning any output, so this function needs to be called in a loop until it
394  * returns EAGAIN.
395  **/
396 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
397 {
398  AVCodecInternal *avci = avctx->internal;
399  DecodeContext *dc = decode_ctx(avci);
400  AVPacket *const pkt = avci->in_pkt;
401  const FFCodec *const codec = ffcodec(avctx->codec);
402  int got_frame, consumed;
403  int ret;
404 
405  if (!pkt->data && !avci->draining) {
407  ret = ff_decode_get_packet(avctx, pkt);
408  if (ret < 0 && ret != AVERROR_EOF)
409  return ret;
410  }
411 
412  // Some codecs (at least wma lossless) will crash when feeding drain packets
413  // after EOF was signaled.
414  if (avci->draining_done)
415  return AVERROR_EOF;
416 
417  if (!pkt->data &&
418  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
420  return AVERROR_EOF;
421 
422  got_frame = 0;
423 
424  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
425  consumed = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
426  } else {
427  frame->pict_type = dc->initial_pict_type;
428  frame->flags |= dc->intra_only_flag;
429  consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
430 
432  frame->pkt_dts = pkt->dts;
433  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
434 #if FF_API_FRAME_PKT
436  if(!avctx->has_b_frames)
437  frame->pkt_pos = pkt->pos;
439 #endif
440  }
441  }
442  emms_c();
443 
444  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
445  ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
446  ? AVERROR(EAGAIN)
447  : 0;
448  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
449  ret = !got_frame ? AVERROR(EAGAIN)
450  : discard_samples(avctx, frame, discarded_samples);
451  } else
452  av_assert0(0);
453 
454  if (ret == AVERROR(EAGAIN))
456 
457  // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
458  // code later will add AVERROR(EAGAIN) to a pointer
459  av_assert0(consumed != AVERROR(EAGAIN));
460  if (consumed < 0)
461  ret = consumed;
462  if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
463  consumed = pkt->size;
464 
465  if (!ret)
466  av_assert0(frame->buf[0]);
467  if (ret == AVERROR(EAGAIN))
468  ret = 0;
469 
470  /* do not stop draining when got_frame != 0 or ret < 0 */
471  if (avci->draining && !got_frame) {
472  if (ret < 0) {
473  /* prevent infinite loop if a decoder wrongly always return error on draining */
474  /* reasonable nb_errors_max = maximum b frames + thread count */
475  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
476  avctx->thread_count : 1);
477 
478  if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
479  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
480  "Stop draining and force EOF.\n");
481  avci->draining_done = 1;
482  ret = AVERROR_BUG;
483  }
484  } else {
485  avci->draining_done = 1;
486  }
487  }
488 
489  if (consumed >= pkt->size || ret < 0) {
491  } else {
492  pkt->data += consumed;
493  pkt->size -= consumed;
497 #if FF_API_FRAME_PKT
498  // See extract_packet_props() comment.
499  avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed;
500 #endif
503  }
504  }
505 
506  return ret;
507 }
508 
509 #if CONFIG_LCMS2
510 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
511 {
512  AVCodecInternal *avci = avctx->internal;
514  AVColorPrimariesDesc coeffs;
515  enum AVColorPrimaries prim;
516  cmsHPROFILE profile;
517  AVFrameSideData *sd;
518  int ret;
519  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
520  return 0;
521 
523  if (!sd || !sd->size)
524  return 0;
525 
526  if (!avci->icc.avctx) {
527  ret = ff_icc_context_init(&avci->icc, avctx);
528  if (ret < 0)
529  return ret;
530  }
531 
532  profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
533  if (!profile)
534  return AVERROR_INVALIDDATA;
535 
536  ret = ff_icc_profile_sanitize(&avci->icc, profile);
537  if (!ret)
538  ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
539  if (!ret)
540  ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
541  cmsCloseProfile(profile);
542  if (ret < 0)
543  return ret;
544 
545  prim = av_csp_primaries_id_from_desc(&coeffs);
546  if (prim != AVCOL_PRI_UNSPECIFIED)
547  frame->color_primaries = prim;
548  if (trc != AVCOL_TRC_UNSPECIFIED)
549  frame->color_trc = trc;
550  return 0;
551 }
552 #else /* !CONFIG_LCMS2 */
554 {
555  return 0;
556 }
557 #endif
558 
559 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
560 {
561  int ret;
562 
563  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
564  frame->color_primaries = avctx->color_primaries;
565  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
566  frame->color_trc = avctx->color_trc;
567  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
568  frame->colorspace = avctx->colorspace;
569  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
570  frame->color_range = avctx->color_range;
571  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
572  frame->chroma_location = avctx->chroma_sample_location;
573 
574  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
575  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
576  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
577  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
578  if (frame->format == AV_SAMPLE_FMT_NONE)
579  frame->format = avctx->sample_fmt;
580  if (!frame->ch_layout.nb_channels) {
581  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
582  if (ret < 0)
583  return ret;
584  }
585  if (!frame->sample_rate)
586  frame->sample_rate = avctx->sample_rate;
587  }
588 
589  return 0;
590 }
591 
593 {
594  int ret;
595  int64_t discarded_samples = 0;
596 
597  while (!frame->buf[0]) {
598  if (discarded_samples > avctx->max_samples)
599  return AVERROR(EAGAIN);
600  ret = decode_simple_internal(avctx, frame, &discarded_samples);
601  if (ret < 0)
602  return ret;
603  }
604 
605  return 0;
606 }
607 
609 {
610  AVCodecInternal *avci = avctx->internal;
611  DecodeContext *dc = decode_ctx(avci);
612  const FFCodec *const codec = ffcodec(avctx->codec);
613  int ret, ok;
614 
615  av_assert0(!frame->buf[0]);
616 
617  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
618  frame->pict_type = dc->initial_pict_type;
619  frame->flags |= dc->intra_only_flag;
620  ret = codec->cb.receive_frame(avctx, frame);
621  emms_c();
622  if (!ret) {
623  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO)
624  ret = (frame->flags & AV_FRAME_FLAG_DISCARD) ? AVERROR(EAGAIN) : 0;
625  else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
626  int64_t discarded_samples = 0;
627  ret = discard_samples(avctx, frame, &discarded_samples);
628  }
629  }
630  } else
632 
633  if (ret == AVERROR_EOF)
634  avci->draining_done = 1;
635 
636  /* preserve ret */
637  ok = detect_colorspace(avctx, frame);
638  if (ok < 0) {
640  return ok;
641  }
642 
643  if (!ret) {
644  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
645  if (!frame->width)
646  frame->width = avctx->width;
647  if (!frame->height)
648  frame->height = avctx->height;
649  }
650 
651  ret = fill_frame_props(avctx, frame);
652  if (ret < 0) {
654  return ret;
655  }
656 
657 #if FF_API_FRAME_KEY
659  frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY);
661 #endif
662 #if FF_API_INTERLACED_FRAME
664  frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED);
665  frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
667 #endif
668  frame->best_effort_timestamp = guess_correct_pts(dc,
669  frame->pts,
670  frame->pkt_dts);
671 
672  /* the only case where decode data is not set should be decoders
673  * that do not call ff_get_buffer() */
674  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
675  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
676 
677  if (frame->private_ref) {
678  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
679 
680  if (fdd->post_process) {
681  ret = fdd->post_process(avctx, frame);
682  if (ret < 0) {
684  return ret;
685  }
686  }
687  }
688  }
689 
690  /* free the per-frame decode data */
691  av_buffer_unref(&frame->private_ref);
692 
693  return ret;
694 }
695 
697 {
698  AVCodecInternal *avci = avctx->internal;
699  DecodeContext *dc = decode_ctx(avci);
700  int ret;
701 
702  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
703  return AVERROR(EINVAL);
704 
705  if (dc->draining_started)
706  return AVERROR_EOF;
707 
708  if (avpkt && !avpkt->size && avpkt->data)
709  return AVERROR(EINVAL);
710 
711  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
712  if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
713  return AVERROR(EAGAIN);
714  ret = av_packet_ref(avci->buffer_pkt, avpkt);
715  if (ret < 0)
716  return ret;
717  } else
718  dc->draining_started = 1;
719 
720  if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
722  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
723  return ret;
724  }
725 
726  return 0;
727 }
728 
730 {
731  /* make sure we are noisy about decoders returning invalid cropping data */
732  if (frame->crop_left >= INT_MAX - frame->crop_right ||
733  frame->crop_top >= INT_MAX - frame->crop_bottom ||
734  (frame->crop_left + frame->crop_right) >= frame->width ||
735  (frame->crop_top + frame->crop_bottom) >= frame->height) {
736  av_log(avctx, AV_LOG_WARNING,
737  "Invalid cropping information set by a decoder: "
739  "(frame size %dx%d). This is a bug, please report it\n",
740  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
741  frame->width, frame->height);
742  frame->crop_left = 0;
743  frame->crop_right = 0;
744  frame->crop_top = 0;
745  frame->crop_bottom = 0;
746  return 0;
747  }
748 
749  if (!avctx->apply_cropping)
750  return 0;
751 
754 }
755 
756 // make sure frames returned to the caller are valid
758 {
759  if (!frame->buf[0] || frame->format < 0)
760  goto fail;
761 
762  switch (avctx->codec_type) {
763  case AVMEDIA_TYPE_VIDEO:
764  if (frame->width <= 0 || frame->height <= 0)
765  goto fail;
766  break;
767  case AVMEDIA_TYPE_AUDIO:
768  if (!av_channel_layout_check(&frame->ch_layout) ||
769  frame->sample_rate <= 0)
770  goto fail;
771 
772  break;
773  default: av_assert0(0);
774  }
775 
776  return 0;
777 fail:
778  av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
779  "This is a bug, please report it.\n");
780  return AVERROR_BUG;
781 }
782 
784 {
785  AVCodecInternal *avci = avctx->internal;
786  int ret;
787 
788  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
789  return AVERROR(EINVAL);
790 
791  if (avci->buffer_frame->buf[0]) {
793  } else {
795  if (ret < 0)
796  return ret;
797  }
798 
799  ret = frame_validate(avctx, frame);
800  if (ret < 0)
801  goto fail;
802 
803  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
804  ret = apply_cropping(avctx, frame);
805  if (ret < 0)
806  goto fail;
807  }
808 
809  avctx->frame_num++;
810 
811 #if FF_API_DROPCHANGED
812  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
813 
814  if (avctx->frame_num == 1) {
815  avci->initial_format = frame->format;
816  switch(avctx->codec_type) {
817  case AVMEDIA_TYPE_VIDEO:
818  avci->initial_width = frame->width;
819  avci->initial_height = frame->height;
820  break;
821  case AVMEDIA_TYPE_AUDIO:
822  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
823  avctx->sample_rate;
824  ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
825  if (ret < 0)
826  goto fail;
827  break;
828  }
829  }
830 
831  if (avctx->frame_num > 1) {
832  int changed = avci->initial_format != frame->format;
833 
834  switch(avctx->codec_type) {
835  case AVMEDIA_TYPE_VIDEO:
836  changed |= avci->initial_width != frame->width ||
837  avci->initial_height != frame->height;
838  break;
839  case AVMEDIA_TYPE_AUDIO:
840  changed |= avci->initial_sample_rate != frame->sample_rate ||
841  avci->initial_sample_rate != avctx->sample_rate ||
843  break;
844  }
845 
846  if (changed) {
847  avci->changed_frames_dropped++;
848  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64
849  " drop count: %d \n",
850  avctx->frame_num, frame->pts,
851  avci->changed_frames_dropped);
853  goto fail;
854  }
855  }
856  }
857 #endif
858  return 0;
859 fail:
861  return ret;
862 }
863 
865 {
866  memset(sub, 0, sizeof(*sub));
867  sub->pts = AV_NOPTS_VALUE;
868 }
869 
870 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
871 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
872  const AVPacket *inpkt, AVPacket *buf_pkt)
873 {
874 #if CONFIG_ICONV
875  iconv_t cd = (iconv_t)-1;
876  int ret = 0;
877  char *inb, *outb;
878  size_t inl, outl;
879 #endif
880 
881  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
882  *outpkt = inpkt;
883  return 0;
884  }
885 
886 #if CONFIG_ICONV
887  inb = inpkt->data;
888  inl = inpkt->size;
889 
890  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
891  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
892  return AVERROR(ERANGE);
893  }
894 
895  cd = iconv_open("UTF-8", avctx->sub_charenc);
896  av_assert0(cd != (iconv_t)-1);
897 
898  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
899  if (ret < 0)
900  goto end;
901  ret = av_packet_copy_props(buf_pkt, inpkt);
902  if (ret < 0)
903  goto end;
904  outb = buf_pkt->data;
905  outl = buf_pkt->size;
906 
907  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
908  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
909  outl >= buf_pkt->size || inl != 0) {
910  ret = FFMIN(AVERROR(errno), -1);
911  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
912  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
913  goto end;
914  }
915  buf_pkt->size -= outl;
916  memset(buf_pkt->data + buf_pkt->size, 0, outl);
917  *outpkt = buf_pkt;
918 
919  ret = 0;
920 end:
921  if (ret < 0)
922  av_packet_unref(buf_pkt);
923  if (cd != (iconv_t)-1)
924  iconv_close(cd);
925  return ret;
926 #else
927  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
928  return AVERROR(EINVAL);
929 #endif
930 }
931 
932 static int utf8_check(const uint8_t *str)
933 {
934  const uint8_t *byte;
935  uint32_t codepoint, min;
936 
937  while (*str) {
938  byte = str;
939  GET_UTF8(codepoint, *(byte++), return 0;);
940  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
941  1 << (5 * (byte - str) - 4);
942  if (codepoint < min || codepoint >= 0x110000 ||
943  codepoint == 0xFFFE /* BOM */ ||
944  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
945  return 0;
946  str = byte;
947  }
948  return 1;
949 }
950 
952  int *got_sub_ptr, const AVPacket *avpkt)
953 {
954  int ret = 0;
955 
956  if (!avpkt->data && avpkt->size) {
957  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
958  return AVERROR(EINVAL);
959  }
960  if (!avctx->codec)
961  return AVERROR(EINVAL);
963  av_log(avctx, AV_LOG_ERROR, "Codec not subtitle decoder\n");
964  return AVERROR(EINVAL);
965  }
966 
967  *got_sub_ptr = 0;
969 
970  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
971  AVCodecInternal *avci = avctx->internal;
972  const AVPacket *pkt;
973 
974  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
975  if (ret < 0)
976  return ret;
977 
978  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
979  sub->pts = av_rescale_q(avpkt->pts,
980  avctx->pkt_timebase, AV_TIME_BASE_Q);
981  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
982  if (pkt == avci->buffer_pkt) // did we recode?
984  if (ret < 0) {
985  *got_sub_ptr = 0;
986  avsubtitle_free(sub);
987  return ret;
988  }
989  av_assert1(!sub->num_rects || *got_sub_ptr);
990 
991  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
992  avctx->pkt_timebase.num) {
993  AVRational ms = { 1, 1000 };
994  sub->end_display_time = av_rescale_q(avpkt->duration,
995  avctx->pkt_timebase, ms);
996  }
997 
999  sub->format = 0;
1000  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1001  sub->format = 1;
1002 
1003  for (unsigned i = 0; i < sub->num_rects; i++) {
1005  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1006  av_log(avctx, AV_LOG_ERROR,
1007  "Invalid UTF-8 in decoded subtitles text; "
1008  "maybe missing -sub_charenc option\n");
1009  avsubtitle_free(sub);
1010  *got_sub_ptr = 0;
1011  return AVERROR_INVALIDDATA;
1012  }
1013  }
1014 
1015  if (*got_sub_ptr)
1016  avctx->frame_num++;
1017  }
1018 
1019  return ret;
1020 }
1021 
1023  const enum AVPixelFormat *fmt)
1024 {
1025  const AVPixFmtDescriptor *desc;
1026  const AVCodecHWConfig *config;
1027  int i, n;
1028 
1029  // If a device was supplied when the codec was opened, assume that the
1030  // user wants to use it.
1031  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
1032  AVHWDeviceContext *device_ctx =
1034  for (i = 0;; i++) {
1035  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
1036  if (!config)
1037  break;
1038  if (!(config->methods &
1040  continue;
1041  if (device_ctx->type != config->device_type)
1042  continue;
1043  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1044  if (config->pix_fmt == fmt[n])
1045  return fmt[n];
1046  }
1047  }
1048  }
1049  // No device or other setup, so we have to choose from things which
1050  // don't any other external information.
1051 
1052  // If the last element of the list is a software format, choose it
1053  // (this should be best software format if any exist).
1054  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1055  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1056  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1057  return fmt[n - 1];
1058 
1059  // Finally, traverse the list in order and choose the first entry
1060  // with no external dependencies (if there is no hardware configuration
1061  // information available then this just picks the first entry).
1062  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1063  for (i = 0;; i++) {
1064  config = avcodec_get_hw_config(avctx->codec, i);
1065  if (!config)
1066  break;
1067  if (config->pix_fmt == fmt[n])
1068  break;
1069  }
1070  if (!config) {
1071  // No specific config available, so the decoder must be able
1072  // to handle this format without any additional setup.
1073  return fmt[n];
1074  }
1075  if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1076  // Usable with only internal setup.
1077  return fmt[n];
1078  }
1079  }
1080 
1081  // Nothing is usable, give up.
1082  return AV_PIX_FMT_NONE;
1083 }
1084 
1086  enum AVHWDeviceType dev_type)
1087 {
1088  AVHWDeviceContext *device_ctx;
1089  AVHWFramesContext *frames_ctx;
1090  int ret;
1091 
1092  if (!avctx->hwaccel)
1093  return AVERROR(ENOSYS);
1094 
1095  if (avctx->hw_frames_ctx)
1096  return 0;
1097  if (!avctx->hw_device_ctx) {
1098  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1099  "required for hardware accelerated decoding.\n");
1100  return AVERROR(EINVAL);
1101  }
1102 
1103  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1104  if (device_ctx->type != dev_type) {
1105  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1106  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1107  av_hwdevice_get_type_name(device_ctx->type));
1108  return AVERROR(EINVAL);
1109  }
1110 
1112  avctx->hw_device_ctx,
1113  avctx->hwaccel->pix_fmt,
1114  &avctx->hw_frames_ctx);
1115  if (ret < 0)
1116  return ret;
1117 
1118  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1119 
1120 
1121  if (frames_ctx->initial_pool_size) {
1122  // We guarantee 4 base work surfaces. The function above guarantees 1
1123  // (the absolute minimum), so add the missing count.
1124  frames_ctx->initial_pool_size += 3;
1125  }
1126 
1128  if (ret < 0) {
1129  av_buffer_unref(&avctx->hw_frames_ctx);
1130  return ret;
1131  }
1132 
1133  return 0;
1134 }
1135 
1137  AVBufferRef *device_ref,
1139  AVBufferRef **out_frames_ref)
1140 {
1141  AVBufferRef *frames_ref = NULL;
1142  const AVCodecHWConfigInternal *hw_config;
1143  const FFHWAccel *hwa;
1144  int i, ret;
1145 
1146  for (i = 0;; i++) {
1147  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1148  if (!hw_config)
1149  return AVERROR(ENOENT);
1150  if (hw_config->public.pix_fmt == hw_pix_fmt)
1151  break;
1152  }
1153 
1154  hwa = hw_config->hwaccel;
1155  if (!hwa || !hwa->frame_params)
1156  return AVERROR(ENOENT);
1157 
1158  frames_ref = av_hwframe_ctx_alloc(device_ref);
1159  if (!frames_ref)
1160  return AVERROR(ENOMEM);
1161 
1162  if (!avctx->internal->hwaccel_priv_data) {
1163  avctx->internal->hwaccel_priv_data =
1164  av_mallocz(hwa->priv_data_size);
1165  if (!avctx->internal->hwaccel_priv_data) {
1166  av_buffer_unref(&frames_ref);
1167  return AVERROR(ENOMEM);
1168  }
1169  }
1170 
1171  ret = hwa->frame_params(avctx, frames_ref);
1172  if (ret >= 0) {
1173  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1174 
1175  if (frames_ctx->initial_pool_size) {
1176  // If the user has requested that extra output surfaces be
1177  // available then add them here.
1178  if (avctx->extra_hw_frames > 0)
1179  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1180 
1181  // If frame threading is enabled then an extra surface per thread
1182  // is also required.
1183  if (avctx->active_thread_type & FF_THREAD_FRAME)
1184  frames_ctx->initial_pool_size += avctx->thread_count;
1185  }
1186 
1187  *out_frames_ref = frames_ref;
1188  } else {
1189  av_buffer_unref(&frames_ref);
1190  }
1191  return ret;
1192 }
1193 
1194 static int hwaccel_init(AVCodecContext *avctx,
1195  const FFHWAccel *hwaccel)
1196 {
1197  int err;
1198 
1199  if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1201  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1202  hwaccel->p.name);
1203  return AVERROR_PATCHWELCOME;
1204  }
1205 
1206  if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1207  avctx->internal->hwaccel_priv_data =
1208  av_mallocz(hwaccel->priv_data_size);
1209  if (!avctx->internal->hwaccel_priv_data)
1210  return AVERROR(ENOMEM);
1211  }
1212 
1213  avctx->hwaccel = &hwaccel->p;
1214  if (hwaccel->init) {
1215  err = hwaccel->init(avctx);
1216  if (err < 0) {
1217  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1218  "hwaccel initialisation returned error.\n",
1219  av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1221  avctx->hwaccel = NULL;
1222  return err;
1223  }
1224  }
1225 
1226  return 0;
1227 }
1228 
1230 {
1231  if (FF_HW_HAS_CB(avctx, uninit))
1232  FF_HW_SIMPLE_CALL(avctx, uninit);
1233 
1235 
1236  avctx->hwaccel = NULL;
1237 
1238  av_buffer_unref(&avctx->hw_frames_ctx);
1239 }
1240 
1241 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1242 {
1243  const AVPixFmtDescriptor *desc;
1244  enum AVPixelFormat *choices;
1245  enum AVPixelFormat ret, user_choice;
1246  const AVCodecHWConfigInternal *hw_config;
1247  const AVCodecHWConfig *config;
1248  int i, n, err;
1249 
1250  // Find end of list.
1251  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1252  // Must contain at least one entry.
1253  av_assert0(n >= 1);
1254  // If a software format is available, it must be the last entry.
1255  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1256  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1257  // No software format is available.
1258  } else {
1259  avctx->sw_pix_fmt = fmt[n - 1];
1260  }
1261 
1262  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1263  if (!choices)
1264  return AV_PIX_FMT_NONE;
1265 
1266  for (;;) {
1267  // Remove the previous hwaccel, if there was one.
1268  ff_hwaccel_uninit(avctx);
1269 
1270  user_choice = avctx->get_format(avctx, choices);
1271  if (user_choice == AV_PIX_FMT_NONE) {
1272  // Explicitly chose nothing, give up.
1273  ret = AV_PIX_FMT_NONE;
1274  break;
1275  }
1276 
1277  desc = av_pix_fmt_desc_get(user_choice);
1278  if (!desc) {
1279  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1280  "get_format() callback.\n");
1281  ret = AV_PIX_FMT_NONE;
1282  break;
1283  }
1284  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1285  desc->name);
1286 
1287  for (i = 0; i < n; i++) {
1288  if (choices[i] == user_choice)
1289  break;
1290  }
1291  if (i == n) {
1292  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1293  "%s not in possible list.\n", desc->name);
1294  ret = AV_PIX_FMT_NONE;
1295  break;
1296  }
1297 
1298  if (ffcodec(avctx->codec)->hw_configs) {
1299  for (i = 0;; i++) {
1300  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1301  if (!hw_config)
1302  break;
1303  if (hw_config->public.pix_fmt == user_choice)
1304  break;
1305  }
1306  } else {
1307  hw_config = NULL;
1308  }
1309 
1310  if (!hw_config) {
1311  // No config available, so no extra setup required.
1312  ret = user_choice;
1313  break;
1314  }
1315  config = &hw_config->public;
1316 
1317  if (config->methods &
1319  avctx->hw_frames_ctx) {
1320  const AVHWFramesContext *frames_ctx =
1322  if (frames_ctx->format != user_choice) {
1323  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1324  "does not match the format of the provided frames "
1325  "context.\n", desc->name);
1326  goto try_again;
1327  }
1328  } else if (config->methods &
1330  avctx->hw_device_ctx) {
1331  const AVHWDeviceContext *device_ctx =
1333  if (device_ctx->type != config->device_type) {
1334  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1335  "does not match the type of the provided device "
1336  "context.\n", desc->name);
1337  goto try_again;
1338  }
1339  } else if (config->methods &
1341  // Internal-only setup, no additional configuration.
1342  } else if (config->methods &
1344  // Some ad-hoc configuration we can't see and can't check.
1345  } else {
1346  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1347  "missing configuration.\n", desc->name);
1348  goto try_again;
1349  }
1350  if (hw_config->hwaccel) {
1351  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel %s "
1352  "initialisation.\n", desc->name, hw_config->hwaccel->p.name);
1353  err = hwaccel_init(avctx, hw_config->hwaccel);
1354  if (err < 0)
1355  goto try_again;
1356  }
1357  ret = user_choice;
1358  break;
1359 
1360  try_again:
1361  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1362  "get_format() without it.\n", desc->name);
1363  for (i = 0; i < n; i++) {
1364  if (choices[i] == user_choice)
1365  break;
1366  }
1367  for (; i + 1 < n; i++)
1368  choices[i] = choices[i + 1];
1369  --n;
1370  }
1371 
1372  if (ret < 0)
1373  ff_hwaccel_uninit(avctx);
1374 
1375  av_freep(&choices);
1376  return ret;
1377 }
1378 
1381 {
1382  for (int i = 0; i < avctx->nb_coded_side_data; i++)
1383  if (avctx->coded_side_data[i].type == type)
1384  return &avctx->coded_side_data[i];
1385 
1386  return NULL;
1387 }
1388 
1390 {
1391  size_t size;
1392  const uint8_t *side_metadata;
1393 
1394  AVDictionary **frame_md = &frame->metadata;
1395 
1396  side_metadata = av_packet_get_side_data(avpkt,
1398  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1399 }
1400 
1402  AVFrame *frame, const AVPacket *pkt)
1403 {
1404  static const struct {
1405  enum AVPacketSideDataType packet;
1407  } sd[] = {
1413  };
1414 
1415  frame->pts = pkt->pts;
1416  frame->duration = pkt->duration;
1417 #if FF_API_FRAME_PKT
1419  frame->pkt_pos = pkt->pos;
1420  frame->pkt_size = pkt->size;
1422 #endif
1423 
1424  for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
1425  size_t size;
1426  const uint8_t *packet_sd = av_packet_get_side_data(pkt, ff_sd_global_map[i].packet, &size);
1427  if (packet_sd) {
1428  AVFrameSideData *frame_sd;
1429 
1431  if (!frame_sd)
1432  return AVERROR(ENOMEM);
1433  memcpy(frame_sd->data, packet_sd, size);
1434  }
1435  }
1436  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1437  size_t size;
1438  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1439  if (packet_sd) {
1441  sd[i].frame,
1442  size);
1443  if (!frame_sd)
1444  return AVERROR(ENOMEM);
1445 
1446  memcpy(frame_sd->data, packet_sd, size);
1447  }
1448  }
1450 
1451  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1452  frame->flags |= AV_FRAME_FLAG_DISCARD;
1453  } else {
1454  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1455  }
1456 
1457  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1458  int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1459  if (ret < 0)
1460  return ret;
1461  frame->opaque = pkt->opaque;
1462  }
1463 
1464  return 0;
1465 }
1466 
1468 {
1469  int ret;
1470 
1471  for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
1472  const AVPacketSideData *packet_sd = ff_get_coded_side_data(avctx,
1473  ff_sd_global_map[i].packet);
1474  if (packet_sd) {
1477  packet_sd->size);
1478  if (!frame_sd)
1479  return AVERROR(ENOMEM);
1480 
1481  memcpy(frame_sd->data, packet_sd->data, packet_sd->size);
1482  }
1483  }
1484 
1486  const AVPacket *pkt = avctx->internal->last_pkt_props;
1487 
1489  if (ret < 0)
1490  return ret;
1491 #if FF_API_FRAME_PKT
1493  frame->pkt_size = pkt->stream_index;
1495 #endif
1496  }
1497 
1498  ret = fill_frame_props(avctx, frame);
1499  if (ret < 0)
1500  return ret;
1501 
1502  switch (avctx->codec->type) {
1503  case AVMEDIA_TYPE_VIDEO:
1504  if (frame->width && frame->height &&
1505  av_image_check_sar(frame->width, frame->height,
1506  frame->sample_aspect_ratio) < 0) {
1507  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1508  frame->sample_aspect_ratio.num,
1509  frame->sample_aspect_ratio.den);
1510  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1511  }
1512  break;
1513  }
1514  return 0;
1515 }
1516 
1518 {
1519  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1520  int i;
1521  int num_planes = av_pix_fmt_count_planes(frame->format);
1523  int flags = desc ? desc->flags : 0;
1524  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1525  num_planes = 2;
1526  for (i = 0; i < num_planes; i++) {
1527  av_assert0(frame->data[i]);
1528  }
1529  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1530  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1531  if (frame->data[i])
1532  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1533  frame->data[i] = NULL;
1534  }
1535  }
1536 }
1537 
1538 static void decode_data_free(void *opaque, uint8_t *data)
1539 {
1541 
1542  if (fdd->post_process_opaque_free)
1544 
1545  if (fdd->hwaccel_priv_free)
1546  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1547 
1548  av_freep(&fdd);
1549 }
1550 
1552 {
1553  AVBufferRef *fdd_buf;
1554  FrameDecodeData *fdd;
1555 
1556  av_assert1(!frame->private_ref);
1557  av_buffer_unref(&frame->private_ref);
1558 
1559  fdd = av_mallocz(sizeof(*fdd));
1560  if (!fdd)
1561  return AVERROR(ENOMEM);
1562 
1563  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1565  if (!fdd_buf) {
1566  av_freep(&fdd);
1567  return AVERROR(ENOMEM);
1568  }
1569 
1570  frame->private_ref = fdd_buf;
1571 
1572  return 0;
1573 }
1574 
1576 {
1577  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1578  int override_dimensions = 1;
1579  int ret;
1580 
1582 
1583  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1584  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1585  (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) {
1586  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1587  ret = AVERROR(EINVAL);
1588  goto fail;
1589  }
1590 
1591  if (frame->width <= 0 || frame->height <= 0) {
1592  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1593  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1594  override_dimensions = 0;
1595  }
1596 
1597  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1598  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1599  ret = AVERROR(EINVAL);
1600  goto fail;
1601  }
1602  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1603  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1604  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1605  ret = AVERROR(EINVAL);
1606  goto fail;
1607  }
1608  }
1609  ret = ff_decode_frame_props(avctx, frame);
1610  if (ret < 0)
1611  goto fail;
1612 
1613  if (hwaccel) {
1614  if (hwaccel->alloc_frame) {
1615  ret = hwaccel->alloc_frame(avctx, frame);
1616  goto end;
1617  }
1618  } else
1619  avctx->sw_pix_fmt = avctx->pix_fmt;
1620 
1621  ret = avctx->get_buffer2(avctx, frame, flags);
1622  if (ret < 0)
1623  goto fail;
1624 
1626 
1628  if (ret < 0)
1629  goto fail;
1630 
1631 end:
1632  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1634  frame->width = avctx->width;
1635  frame->height = avctx->height;
1636  }
1637 
1638 fail:
1639  if (ret < 0) {
1640  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1642  }
1643 
1644  return ret;
1645 }
1646 
1648 {
1649  AVFrame *tmp;
1650  int ret;
1651 
1653 
1654  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1655  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1656  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1658  }
1659 
1660  if (!frame->data[0])
1661  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1662 
1664  return ff_decode_frame_props(avctx, frame);
1665 
1666  tmp = av_frame_alloc();
1667  if (!tmp)
1668  return AVERROR(ENOMEM);
1669 
1671 
1673  if (ret < 0) {
1674  av_frame_free(&tmp);
1675  return ret;
1676  }
1677 
1679  av_frame_free(&tmp);
1680 
1681  return 0;
1682 }
1683 
1685 {
1686  int ret = reget_buffer_internal(avctx, frame, flags);
1687  if (ret < 0)
1688  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1689  return ret;
1690 }
1691 
1692 typedef struct ProgressInternal {
1694  struct AVFrame *f;
1696 
1698 {
1699  av_assert1(!!f->f == !!f->progress);
1700  av_assert1(!f->progress || f->progress->f == f->f);
1701 }
1702 
1704 {
1706 
1707  av_assert1(!f->f && !f->progress);
1708 
1709  f->progress = ff_refstruct_pool_get(pool);
1710  if (!f->progress)
1711  return AVERROR(ENOMEM);
1712 
1713  f->f = f->progress->f;
1714  return 0;
1715 }
1716 
1718 {
1719  int ret;
1720 
1721  ret = progress_frame_get(avctx, f);
1722  if (ret < 0)
1723  return ret;
1724 
1725  ret = ff_thread_get_buffer(avctx, f->progress->f, flags);
1726  if (ret < 0) {
1727  f->f = NULL;
1728  ff_refstruct_unref(&f->progress);
1729  return ret;
1730  }
1731  return 0;
1732 }
1733 
1735 {
1736  av_assert1(src->progress && src->f && src->f == src->progress->f);
1737  av_assert1(!dst->f && !dst->progress);
1738  dst->f = src->f;
1739  dst->progress = ff_refstruct_ref(src->progress);
1740 }
1741 
1743 {
1745  f->f = NULL;
1746  ff_refstruct_unref(&f->progress);
1747 }
1748 
1750 {
1751  if (dst == src)
1752  return;
1755  if (src->f)
1756  ff_progress_frame_ref(dst, src);
1757 }
1758 
1760 {
1761  ff_thread_progress_report(&f->progress->progress, n);
1762 }
1763 
1765 {
1766  ff_thread_progress_await(&f->progress->progress, n);
1767 }
1768 
1769 #if !HAVE_THREADS
1771 {
1773 }
1774 #endif /* !HAVE_THREADS */
1775 
1777 {
1778  const AVCodecContext *avctx = opaque.nc;
1779  ProgressInternal *progress = obj;
1780  int ret;
1781 
1783  if (ret < 0)
1784  return ret;
1785 
1786  progress->f = av_frame_alloc();
1787  if (!progress->f)
1788  return AVERROR(ENOMEM);
1789 
1790  return 0;
1791 }
1792 
1793 static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
1794 {
1795  ProgressInternal *progress = obj;
1796 
1797  ff_thread_progress_reset(&progress->progress);
1798  av_frame_unref(progress->f);
1799 }
1800 
1802 {
1803  ProgressInternal *progress = obj;
1804 
1806  av_frame_free(&progress->f);
1807 }
1808 
1810 {
1811  AVCodecInternal *avci = avctx->internal;
1812  DecodeContext *dc = decode_ctx(avci);
1813  int ret = 0;
1814 
1815  dc->initial_pict_type = AV_PICTURE_TYPE_NONE;
1817  dc->intra_only_flag = AV_FRAME_FLAG_KEY;
1818  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
1819  dc->initial_pict_type = AV_PICTURE_TYPE_I;
1820  }
1821 
1822  /* if the decoder init function was already called previously,
1823  * free the already allocated subtitle_header before overwriting it */
1824  av_freep(&avctx->subtitle_header);
1825 
1826  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1827  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1828  avctx->codec->max_lowres);
1829  avctx->lowres = avctx->codec->max_lowres;
1830  }
1831  if (avctx->sub_charenc) {
1832  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1833  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1834  "supported with subtitles codecs\n");
1835  return AVERROR(EINVAL);
1836  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1837  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1838  "subtitles character encoding will be ignored\n",
1839  avctx->codec_descriptor->name);
1841  } else {
1842  /* input character encoding is set for a text based subtitle
1843  * codec at this point */
1846 
1848 #if CONFIG_ICONV
1849  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1850  if (cd == (iconv_t)-1) {
1851  ret = AVERROR(errno);
1852  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1853  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1854  return ret;
1855  }
1856  iconv_close(cd);
1857 #else
1858  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1859  "conversion needs a libavcodec built with iconv support "
1860  "for this codec\n");
1861  return AVERROR(ENOSYS);
1862 #endif
1863  }
1864  }
1865  }
1866 
1867  dc->pts_correction_num_faulty_pts =
1868  dc->pts_correction_num_faulty_dts = 0;
1869  dc->pts_correction_last_pts =
1870  dc->pts_correction_last_dts = INT64_MIN;
1871 
1872  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1874  av_log(avctx, AV_LOG_WARNING,
1875  "gray decoding requested but not enabled at configuration time\n");
1876  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1878  }
1879 
1880  if (avctx->nb_side_data_prefer_packet == 1 &&
1881  avctx->side_data_prefer_packet[0] == -1)
1882  dc->side_data_pref_mask = ~0ULL;
1883  else {
1884  for (unsigned i = 0; i < avctx->nb_side_data_prefer_packet; i++) {
1885  int val = avctx->side_data_prefer_packet[i];
1886 
1887  if (val < 0 || val >= AV_PKT_DATA_NB) {
1888  av_log(avctx, AV_LOG_ERROR, "Invalid side data type: %d\n", val);
1889  return AVERROR(EINVAL);
1890  }
1891 
1892  for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
1893  if (ff_sd_global_map[j].packet == val) {
1894  val = ff_sd_global_map[j].frame;
1895 
1896  // this code will need to be changed when we have more than
1897  // 64 frame side data types
1898  if (val >= 64) {
1899  av_log(avctx, AV_LOG_ERROR, "Side data type too big\n");
1900  return AVERROR_BUG;
1901  }
1902 
1903  dc->side_data_pref_mask |= 1ULL << val;
1904  }
1905  }
1906  }
1907  }
1908 
1909  avci->in_pkt = av_packet_alloc();
1910  avci->last_pkt_props = av_packet_alloc();
1911  if (!avci->in_pkt || !avci->last_pkt_props)
1912  return AVERROR(ENOMEM);
1913 
1915  avci->progress_frame_pool =
1921  if (!avci->progress_frame_pool)
1922  return AVERROR(ENOMEM);
1923  }
1924  ret = decode_bsfs_init(avctx);
1925  if (ret < 0)
1926  return ret;
1927 
1928 #if FF_API_DROPCHANGED
1929  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED)
1930  av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n");
1931 #endif
1932 
1933  return 0;
1934 }
1935 
1936 /**
1937  * Check side data preference and clear existing side data from frame
1938  * if needed.
1939  *
1940  * @retval 0 side data of this type can be added to frame
1941  * @retval 1 side data of this type should not be added to frame
1942  */
1943 static int side_data_pref(const AVCodecContext *avctx, AVFrameSideData ***sd,
1944  int *nb_sd, enum AVFrameSideDataType type)
1945 {
1946  DecodeContext *dc = decode_ctx(avctx->internal);
1947 
1948  // Note: could be skipped for `type` without corresponding packet sd
1949  if (av_frame_side_data_get(*sd, *nb_sd, type)) {
1950  if (dc->side_data_pref_mask & (1ULL << type))
1951  return 1;
1952  av_frame_side_data_remove(sd, nb_sd, type);
1953  }
1954 
1955  return 0;
1956 }
1957 
1958 
1960  enum AVFrameSideDataType type, size_t size,
1961  AVFrameSideData **psd)
1962 {
1963  AVFrameSideData *sd;
1964 
1965  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data, type)) {
1966  if (psd)
1967  *psd = NULL;
1968  return 0;
1969  }
1970 
1972  if (psd)
1973  *psd = sd;
1974 
1975  return sd ? 0 : AVERROR(ENOMEM);
1976 }
1977 
1979  AVFrameSideData ***sd, int *nb_sd,
1981  AVBufferRef **buf)
1982 {
1983  int ret = 0;
1984 
1985  if (side_data_pref(avctx, sd, nb_sd, type))
1986  goto finish;
1987 
1988  if (!av_frame_side_data_add(sd, nb_sd, type, buf, 0))
1989  ret = AVERROR(ENOMEM);
1990 
1991 finish:
1993 
1994  return ret;
1995 }
1996 
1999  AVBufferRef **buf, AVFrameSideData **psd)
2000 {
2002  &frame->side_data, &frame->nb_side_data,
2003  type, buf);
2004 }
2005 
2007  AVFrameSideData ***sd, int *nb_sd,
2008  struct AVMasteringDisplayMetadata **mdm)
2009 {
2010  AVBufferRef *buf;
2011  size_t size;
2012 
2014  *mdm = NULL;
2015  return 0;
2016  }
2017 
2019  if (!*mdm)
2020  return AVERROR(ENOMEM);
2021 
2022  buf = av_buffer_create((uint8_t *)*mdm, size, NULL, NULL, 0);
2023  if (!buf) {
2024  av_freep(mdm);
2025  return AVERROR(ENOMEM);
2026  }
2027 
2029  &buf, 0)) {
2030  *mdm = NULL;
2031  av_buffer_unref(&buf);
2032  return AVERROR(ENOMEM);
2033  }
2034 
2035  return 0;
2036 }
2037 
2040 {
2041  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2043  *mdm = NULL;
2044  return 0;
2045  }
2046 
2048  return *mdm ? 0 : AVERROR(ENOMEM);
2049 }
2050 
2052  AVFrameSideData ***sd, int *nb_sd,
2053  AVContentLightMetadata **clm)
2054 {
2055  AVBufferRef *buf;
2056  size_t size;
2057 
2058  if (side_data_pref(avctx, sd, nb_sd, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL)) {
2059  *clm = NULL;
2060  return 0;
2061  }
2062 
2064  if (!*clm)
2065  return AVERROR(ENOMEM);
2066 
2067  buf = av_buffer_create((uint8_t *)*clm, size, NULL, NULL, 0);
2068  if (!buf) {
2069  av_freep(clm);
2070  return AVERROR(ENOMEM);
2071  }
2072 
2074  &buf, 0)) {
2075  *clm = NULL;
2076  av_buffer_unref(&buf);
2077  return AVERROR(ENOMEM);
2078  }
2079 
2080  return 0;
2081 }
2082 
2084  AVContentLightMetadata **clm)
2085 {
2086  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2088  *clm = NULL;
2089  return 0;
2090  }
2091 
2093  return *clm ? 0 : AVERROR(ENOMEM);
2094 }
2095 
2096 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2097 {
2098  size_t size;
2099  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2100 
2101  if (pal && size == AVPALETTE_SIZE) {
2102  memcpy(dst, pal, AVPALETTE_SIZE);
2103  return 1;
2104  } else if (pal) {
2105  av_log(logctx, AV_LOG_ERROR,
2106  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
2107  }
2108  return 0;
2109 }
2110 
2111 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
2112 {
2113  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
2114 
2115  if (!hwaccel || !hwaccel->frame_priv_data_size)
2116  return 0;
2117 
2118  av_assert0(!*hwaccel_picture_private);
2119 
2120  if (hwaccel->free_frame_priv) {
2121  AVHWFramesContext *frames_ctx;
2122 
2123  if (!avctx->hw_frames_ctx)
2124  return AVERROR(EINVAL);
2125 
2126  frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
2127  *hwaccel_picture_private = ff_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
2128  frames_ctx->device_ctx,
2129  hwaccel->free_frame_priv);
2130  } else {
2131  *hwaccel_picture_private = ff_refstruct_allocz(hwaccel->frame_priv_data_size);
2132  }
2133 
2134  if (!*hwaccel_picture_private)
2135  return AVERROR(ENOMEM);
2136 
2137  return 0;
2138 }
2139 
2141 {
2142  AVCodecInternal *avci = avctx->internal;
2143  DecodeContext *dc = decode_ctx(avci);
2144 
2146  av_packet_unref(avci->in_pkt);
2147 
2148  dc->pts_correction_last_pts =
2149  dc->pts_correction_last_dts = INT64_MIN;
2150 
2151  av_bsf_flush(avci->bsf);
2152 
2153  dc->nb_draining_errors = 0;
2154  dc->draining_started = 0;
2155 }
2156 
2158 {
2159  return av_mallocz(sizeof(DecodeContext));
2160 }
ff_get_coded_side_data
const AVPacketSideData * ff_get_coded_side_data(const AVCodecContext *avctx, enum AVPacketSideDataType type)
Get side data of the given type from a decoding context.
Definition: decode.c:1379
DecodeContext::intra_only_flag
int intra_only_flag
This is set to AV_FRAME_FLAG_KEY for decoders of intra-only formats (those whose codec descriptor has...
Definition: decode.c:65
AVSubtitle
Definition: avcodec.h:2228
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:142
hwconfig.h
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1759
av_samples_copy
int av_samples_copy(uint8_t *const *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
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1427
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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:999
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:209
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
hwaccel_init
static int hwaccel_init(AVCodecContext *avctx, const FFHWAccel *hwaccel)
Definition: decode.c:1194
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:237
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
progress_frame_pool_reset_cb
static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
Definition: decode.c:1793
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
ff_thread_progress_report
void ff_thread_progress_report(ThreadProgress *pro, int n)
This function is a no-op in no-op mode; otherwise it notifies other threads that a certain level of p...
Definition: threadprogress.c:53
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
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
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2233
threadprogress.h
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:787
ff_icc_profile_read_primaries
int ff_icc_profile_read_primaries(FFIccContext *s, cmsHPROFILE profile, AVColorPrimariesDesc *out_primaries)
Read the color primaries and white point coefficients encoded by an ICC profile, and return the raw v...
Definition: fflcms2.c:255
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf, AVFrameSideData **psd)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:1997
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:580
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1241
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:729
ThreadProgress
ThreadProgress is an API to easily notify other threads about progress of any kind as long as it can ...
Definition: threadprogress.h:43
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
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:795
AVColorPrimariesDesc
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition: csp.h:78
DecodeContext::initial_pict_type
enum AVPictureType initial_pict_type
This is set to AV_PICTURE_TYPE_I for intra only video decoders and to AV_PICTURE_TYPE_NONE for other ...
Definition: decode.c:72
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
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:2129
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
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:582
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
AVPictureType
AVPictureType
Definition: avutil.h:277
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:118
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
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:220
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1862
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
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:397
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1916
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2232
av_unused
#define av_unused
Definition: attributes.h:131
decode_simple_receive_frame
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:592
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:522
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:33
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
DecodeContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: decode.c:84
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:371
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
FFHWAccel::frame_params
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
Definition: hwaccel_internal.h:144
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:520
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1717
data
const char data[16]
Definition: mxf.c:148
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:288
FFCodec
Definition: codec_internal.h:126
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1892
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:597
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:52
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:538
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
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:1880
AVDictionary
Definition: dict.c:34
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:555
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1022
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:693
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:587
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:396
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:94
decode_ctx
static DecodeContext * decode_ctx(AVCodecInternal *avci)
Definition: decode.c:94
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:52
FF_SUB_CHARENC_MODE_AUTOMATIC
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:1879
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:1062
DecodeContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: decode.c:83
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1229
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
decode_get_packet
static int decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: decode.c:210
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:207
AVPacketSideData::size
size_t size
Definition: packet.h:373
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3005
AVCodecInternal::progress_frame_pool
struct FFRefStructPool * progress_frame_pool
Definition: internal.h:64
DecodeContext::nb_draining_errors
int nb_draining_errors
Definition: decode.c:75
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:373
FFHWAccel
Definition: hwaccel_internal.h:34
bsf.h
guess_correct_pts
static int64_t guess_correct_pts(DecodeContext *dc, 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:272
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:556
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:46
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
fail
#define fail()
Definition: checkasm.h:184
ff_icc_context_init
int ff_icc_context_init(FFIccContext *s, void *avctx)
Initializes an FFIccContext.
Definition: fflcms2.c:30
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1583
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
FFCodec::cb
union FFCodec::@90 cb
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:1878
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FrameDecodeData::post_process_opaque_free
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h:46
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_decode_frame_props_from_pkt
int ff_decode_frame_props_from_pkt(const AVCodecContext *avctx, AVFrame *frame, const AVPacket *pkt)
Set various frame properties from the provided packet.
Definition: decode.c:1401
pts
static int64_t pts
Definition: transcode_aac.c:644
add_metadata_from_side_data
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1389
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1978
AVRational::num
int num
Numerator.
Definition: rational.h:59
progressframe.h
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
refstruct.h
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2225
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:393
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
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:1222
FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR
#define FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR
If this flag is set and both init_cb and free_entry_cb callbacks are provided, then free_cb will be c...
Definition: refstruct.h:213
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:473
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:951
ff_decode_content_light_new_ext
int ff_decode_content_light_new_ext(const AVCodecContext *avctx, AVFrameSideData ***sd, int *nb_sd, AVContentLightMetadata **clm)
Same as ff_decode_content_light_new, but taking a AVFrameSideData array directly instead of an AVFram...
Definition: decode.c:2051
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:244
avassert.h
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:68
progress_frame_get
static int progress_frame_get(AVCodecContext *avctx, ProgressFrame *f)
Definition: decode.c:1703
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:69
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:253
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_decode_receive_frame
int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
Definition: decode.c:783
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
ff_progress_frame_ref
void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src)
Set dst->f to src->f and make dst a co-owner of src->f.
Definition: decode.c:1734
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:598
AVCodecContext::side_data_prefer_packet
int * side_data_prefer_packet
Decoding only.
Definition: avcodec.h:2061
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:331
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2111
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:864
FrameDecodeData::post_process_opaque
void * post_process_opaque
Definition: decode.h:45
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1517
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:133
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:190
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
FFHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: hwaccel_internal.h:112
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_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:425
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:986
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_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:315
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:372
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1742
decode.h
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
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:343
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2234
av_csp_primaries_id_from_desc
enum AVColorPrimaries av_csp_primaries_id_from_desc(const AVColorPrimariesDesc *prm)
Detects which enum AVColorPrimaries constant corresponds to the given complete gamut description.
Definition: csp.c:110
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1935
ProgressFrame::progress
struct ProgressInternal * progress
Definition: progressframe.h:75
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:112
FFRefStructPool
FFRefStructPool is an API for a thread-safe pool of objects managed via the RefStruct API.
Definition: refstruct.c:183
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:545
ProgressInternal
Definition: decode.c:1692
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCodecHWConfigInternal::hwaccel
const struct FFHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
Definition: hwconfig.h:35
check_progress_consistency
static void check_progress_consistency(const ProgressFrame *f)
Definition: decode.c:1697
av_content_light_metadata_alloc
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
Definition: mastering_display_metadata.c:58
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:192
discard_samples
static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:298
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1538
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:1085
ff_decode_mastering_display_new
int ff_decode_mastering_display_new(const AVCodecContext *avctx, AVFrame *frame, AVMasteringDisplayMetadata **mdm)
Wrapper around av_mastering_display_metadata_create_side_data(), which rejects side data overridden b...
Definition: decode.c:2038
DecodeContext::draining_started
int draining_started
The caller has submitted a NULL packet on input.
Definition: decode.c:80
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:139
AVCodecContext::sub_charenc
char * sub_charenc
Character encoding of the input subtitles file.
Definition: avcodec.h:1869
ff_decode_internal_alloc
AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:2157
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:388
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:65
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:149
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:932
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_decode_flush_buffers
void ff_decode_flush_buffers(AVCodecContext *avctx)
Definition: decode.c:2140
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1962
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
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
hwaccel_internal.h
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1917
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
av_frame_side_data_remove
void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type from an array.
Definition: frame.c:941
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:111
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:374
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
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:103
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
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
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:141
DecodeContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: decode.c:85
AV_CODEC_FLAG2_ICC_PROFILES
#define AV_CODEC_FLAG2_ICC_PROFILES
Generate/parse ICC profiles on encode/decode, as appropriate for the type of file.
Definition: avcodec.h:398
ff_icc_profile_detect_transfer
int ff_icc_profile_detect_transfer(FFIccContext *s, cmsHPROFILE profile, enum AVColorTransferCharacteristic *out_trc)
Attempt detecting the transfer characteristic that best approximates the transfer function encoded by...
Definition: fflcms2.c:302
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: packet.c:435
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:135
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:177
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:870
AVPACKET_IS_EMPTY
#define AVPACKET_IS_EMPTY(pkt)
Definition: packet_internal.h:26
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
ff_sd_global_map
const SideDataMap ff_sd_global_map[]
A map between packet and frame side data types.
Definition: avcodec.c:57
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:83
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AV_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:337
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1855
f
f
Definition: af_crystalizer.c:121
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:509
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
SideDataMap::packet
enum AVPacketSideDataType packet
Definition: avcodec_internal.h:35
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_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:521
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:492
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
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
Video decoding only.
Definition: avcodec.h:1520
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:44
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:123
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:999
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:296
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:122
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:77
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:140
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:77
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
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:60
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
frame_validate
static int frame_validate(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:757
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:1959
ff_frame_new_side_data_from_buf_ext
int ff_frame_new_side_data_from_buf_ext(const AVCodecContext *avctx, AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf)
Same as ff_frame_new_side_data_from_buf, but taking a AVFrameSideData array directly instead of an AV...
Definition: decode.c:1978
side_data_pref
static int side_data_pref(const AVCodecContext *avctx, AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type)
Check side data preference and clear existing side data from frame if needed.
Definition: decode.c:1943
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:305
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:645
fill_frame_props
static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:559
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2231
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: packet.c:347
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:1013
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:519
ProgressInternal::progress
ThreadProgress progress
Definition: decode.c:1693
av_content_light_metadata_create_side_data
AVContentLightMetadata * av_content_light_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVContentLightMetadata and add it to the frame.
Definition: mastering_display_metadata.c:68
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
SideDataMap::frame
enum AVFrameSideDataType frame
Definition: avcodec_internal.h:36
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:526
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
ff_progress_frame_await
void ff_progress_frame_await(const ProgressFrame *f, int n)
Wait for earlier decoding threads to finish reference frames.
Definition: decode.c:1764
AVCodecInternal
Definition: internal.h:49
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:260
DecodeContext::side_data_pref_mask
uint64_t side_data_pref_mask
DTS of the last frame.
Definition: decode.c:91
FF_THREAD_NO_FRAME_THREADING
@ FF_THREAD_NO_FRAME_THREADING
Definition: thread.h:90
AVCodecContext::nb_side_data_prefer_packet
unsigned nb_side_data_prefer_packet
Number of entries in side_data_prefer_packet.
Definition: avcodec.h:2065
detect_colorspace
static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: decode.c:553
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:804
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1594
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
av_mastering_display_metadata_alloc_size
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc_size(size_t *size)
Allocate an AVMasteringDisplayMetadata structure and set its fields to default values.
Definition: mastering_display_metadata.c:33
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2095
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:169
emms.h
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:696
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:135
extract_packet_props
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
Definition: decode.c:160
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: packet.c:390
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2229
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:513
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:141
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1647
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:608
internal.h
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:76
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1809
ff_thread_progress_init
av_cold int ff_thread_progress_init(ThreadProgress *pro, int init_mode)
Initialize a ThreadProgress.
Definition: threadprogress.c:33
DecodeContext::avci
AVCodecInternal avci
Definition: decode.c:58
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:633
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
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:1497
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
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:49
profile
int profile
Definition: mxfenc.c:2227
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:618
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:396
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
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:1475
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:200
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1877
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2031
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:1136
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:1684
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:72
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
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:134
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:108
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:778
ProgressFrame::f
struct AVFrame * f
Definition: progressframe.h:74
ff_thread_sync_ref
enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
Allows to synchronize objects whose lifetime is the whole decoding process among all frame threads.
Definition: decode.c:1770
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
ff_decode_content_light_new
int ff_decode_content_light_new(const AVCodecContext *avctx, AVFrame *frame, AVContentLightMetadata **clm)
Wrapper around av_content_light_metadata_create_side_data(), which rejects side data overridden by th...
Definition: decode.c:2083
ff_thread_progress_destroy
av_cold void ff_thread_progress_destroy(ThreadProgress *pro)
Destroy a ThreadProgress.
Definition: threadprogress.c:44
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
ff_progress_frame_replace
void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...
Definition: decode.c:1749
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
apply_param_change
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:99
progress_frame_pool_init_cb
static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj)
Definition: decode.c:1776
progress_frame_pool_free_entry_cb
static av_cold void progress_frame_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj)
Definition: decode.c:1801
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:1467
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:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1602
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, const AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:871
channel_layout.h
av_mastering_display_metadata_create_side_data
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
Definition: mastering_display_metadata.c:45
avcodec_internal.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ff_refstruct_pool_alloc_ext
static FFRefStructPool * ff_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(FFRefStructOpaque opaque, void *obj), void(*reset_cb)(FFRefStructOpaque opaque, void *obj), void(*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void(*free_cb)(FFRefStructOpaque opaque))
A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:258
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:258
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
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:1927
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:76
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
FF_CODEC_CB_TYPE_RECEIVE_FRAME
@ FF_CODEC_CB_TYPE_RECEIVE_FRAME
Definition: codec_internal.h:114
ProgressInternal::f
struct AVFrame * f
Definition: decode.c:1694
ff_thread_progress_reset
static void ff_thread_progress_reset(ThreadProgress *pro)
Reset the ThreadProgress.progress counter; must only be called if the ThreadProgress is not in use in...
Definition: threadprogress.h:72
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:142
AVPacket::stream_index
int stream_index
Definition: packet.h:522
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:838
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:134
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:118
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:444
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:128
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:251
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:187
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
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:629
desc
const char * desc
Definition: libsvtav1.c:79
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:526
ff_decode_mastering_display_new_ext
int ff_decode_mastering_display_new_ext(const AVCodecContext *avctx, AVFrameSideData ***sd, int *nb_sd, struct AVMasteringDisplayMetadata **mdm)
Same as ff_decode_mastering_display_new, but taking a AVFrameSideData array directly instead of an AV...
Definition: decode.c:2006
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:239
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:406
ff_icc_profile_sanitize
int ff_icc_profile_sanitize(FFIccContext *s, cmsHPROFILE profile)
Sanitize an ICC profile to try and fix badly broken values.
Definition: fflcms2.c:213
mastering_display_metadata.h
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1551
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:143
ThreadingStatus
ThreadingStatus
Definition: thread.h:87
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
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:384
ProgressFrame
The ProgressFrame structure.
Definition: progressframe.h:73
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:497
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:540
DecodeContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Definition: decode.c:82
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1143
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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:302
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:334
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:664
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
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:2096
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:30
decode_bsfs_init
static int decode_bsfs_init(AVCodecContext *avctx)
Definition: decode.c:175
codec_desc.h
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
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:322
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2116
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
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:642
DecodeContext
Definition: decode.c:57
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **pbuf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: frame.c:846
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: decode.h:128
ff_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:532
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:2885
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:1881
min
float min
Definition: vorbis_enc_data.h:429