FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 <stdbool.h>
23 #include <string.h>
24 
25 #include "config.h"
26 
27 #if CONFIG_ICONV
28 # include <iconv.h>
29 #endif
30 
31 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/emms.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/internal.h"
40 #include "libavutil/mem.h"
41 #include "libavutil/stereo3d.h"
42 
43 #include "avcodec.h"
44 #include "avcodec_internal.h"
45 #include "bytestream.h"
46 #include "bsf.h"
47 #include "codec_desc.h"
48 #include "codec_internal.h"
49 #include "decode.h"
50 #include "hwaccel_internal.h"
51 #include "hwconfig.h"
52 #include "internal.h"
53 #include "lcevcdec.h"
54 #include "packet_internal.h"
55 #include "progressframe.h"
56 #include "libavutil/refstruct.h"
57 #include "thread.h"
58 #include "threadprogress.h"
59 
60 typedef struct DecodeContext {
62 
63  /**
64  * This is set to AV_FRAME_FLAG_KEY for decoders of intra-only formats
65  * (those whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set)
66  * to set the flag generically.
67  */
69 
70  /**
71  * This is set to AV_PICTURE_TYPE_I for intra only video decoders
72  * and to AV_PICTURE_TYPE_NONE for other decoders. It is used to set
73  * the AVFrame's pict_type before the decoder receives it.
74  */
76 
77  /* to prevent infinite loop on errors when draining */
79 
80  /**
81  * The caller has submitted a NULL packet on input.
82  */
84 
85  int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
86  int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
87  int64_t pts_correction_last_pts; /// PTS of the last frame
88  int64_t pts_correction_last_dts; /// DTS of the last frame
89 
90  /**
91  * Bitmask indicating for which side data types we prefer user-supplied
92  * (global or attached to packets) side data over bytestream.
93  */
95 
98  int width;
99  int height;
100 } DecodeContext;
101 
103 {
104  return (DecodeContext *)avci;
105 }
106 
107 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
108 {
109  int ret;
110  size_t size;
111  const uint8_t *data;
112  uint32_t flags;
113  int64_t val;
114 
116  if (!data)
117  return 0;
118 
119  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
120  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
121  "changes, but PARAM_CHANGE side data was sent to it.\n");
122  ret = AVERROR(EINVAL);
123  goto fail2;
124  }
125 
126  if (size < 4)
127  goto fail;
128 
129  flags = bytestream_get_le32(&data);
130  size -= 4;
131 
133  if (size < 4)
134  goto fail;
135  val = bytestream_get_le32(&data);
136  if (val <= 0 || val > INT_MAX) {
137  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
139  goto fail2;
140  }
141  avctx->sample_rate = val;
142  size -= 4;
143  }
145  if (size < 8)
146  goto fail;
147  avctx->width = bytestream_get_le32(&data);
148  avctx->height = bytestream_get_le32(&data);
149  size -= 8;
150  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
151  if (ret < 0)
152  goto fail2;
153  }
154 
155  return 0;
156 fail:
157  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
159 fail2:
160  if (ret < 0) {
161  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
162  if (avctx->err_recognition & AV_EF_EXPLODE)
163  return ret;
164  }
165  return 0;
166 }
167 
169 {
170  int ret = 0;
171 
173  if (pkt) {
175  }
176  return ret;
177 }
178 
180 {
181  AVCodecInternal *avci = avctx->internal;
182  const FFCodec *const codec = ffcodec(avctx->codec);
183  int ret;
184 
185  if (avci->bsf)
186  return 0;
187 
188  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
189  if (ret < 0) {
190  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
191  if (ret != AVERROR(ENOMEM))
192  ret = AVERROR_BUG;
193  goto fail;
194  }
195 
196  /* We do not currently have an API for passing the input timebase into decoders,
197  * but no filters used here should actually need it.
198  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
199  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
201  if (ret < 0)
202  goto fail;
203 
204  ret = av_bsf_init(avci->bsf);
205  if (ret < 0)
206  goto fail;
207 
208  return 0;
209 fail:
210  av_bsf_free(&avci->bsf);
211  return ret;
212 }
213 
214 #if !HAVE_THREADS
215 #define ff_thread_get_packet(avctx, pkt) (AVERROR_BUG)
216 #define ff_thread_receive_frame(avctx, frame) (AVERROR_BUG)
217 #endif
218 
220 {
221  AVCodecInternal *avci = avctx->internal;
222  int ret;
223 
224  ret = av_bsf_receive_packet(avci->bsf, pkt);
225  if (ret < 0)
226  return ret;
227 
230  if (ret < 0)
231  goto finish;
232  }
233 
234  ret = apply_param_change(avctx, pkt);
235  if (ret < 0)
236  goto finish;
237 
238  return 0;
239 finish:
241  return ret;
242 }
243 
245 {
246  AVCodecInternal *avci = avctx->internal;
247  DecodeContext *dc = decode_ctx(avci);
248 
249  if (avci->draining)
250  return AVERROR_EOF;
251 
252  /* If we are a worker thread, get the next packet from the threading
253  * context. Otherwise we are the main (user-facing) context, so we get the
254  * next packet from the input filterchain.
255  */
256  if (avctx->internal->is_frame_mt)
257  return ff_thread_get_packet(avctx, pkt);
258 
259  while (1) {
260  int ret = decode_get_packet(avctx, pkt);
261  if (ret == AVERROR(EAGAIN) &&
262  (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
263  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
264  if (ret >= 0)
265  continue;
266 
268  }
269 
270  if (ret == AVERROR_EOF)
271  avci->draining = 1;
272  return ret;
273  }
274 }
275 
276 /**
277  * Attempt to guess proper monotonic timestamps for decoded video frames
278  * which might have incorrect times. Input timestamps may wrap around, in
279  * which case the output will as well.
280  *
281  * @param pts the pts field of the decoded AVPacket, as passed through
282  * AVFrame.pts
283  * @param dts the dts field of the decoded AVPacket
284  * @return one of the input values, may be AV_NOPTS_VALUE
285  */
287  int64_t reordered_pts, int64_t dts)
288 {
290 
291  if (dts != AV_NOPTS_VALUE) {
292  dc->pts_correction_num_faulty_dts += dts <= dc->pts_correction_last_dts;
293  dc->pts_correction_last_dts = dts;
294  } else if (reordered_pts != AV_NOPTS_VALUE)
295  dc->pts_correction_last_dts = reordered_pts;
296 
297  if (reordered_pts != AV_NOPTS_VALUE) {
298  dc->pts_correction_num_faulty_pts += reordered_pts <= dc->pts_correction_last_pts;
299  dc->pts_correction_last_pts = reordered_pts;
300  } else if(dts != AV_NOPTS_VALUE)
301  dc->pts_correction_last_pts = dts;
302 
303  if ((dc->pts_correction_num_faulty_pts<=dc->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
304  && reordered_pts != AV_NOPTS_VALUE)
305  pts = reordered_pts;
306  else
307  pts = dts;
308 
309  return pts;
310 }
311 
312 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
313 {
314  AVCodecInternal *avci = avctx->internal;
315  AVFrameSideData *side;
316  uint32_t discard_padding = 0;
317  uint8_t skip_reason = 0;
318  uint8_t discard_reason = 0;
319 
321  if (side && side->size >= 10) {
322  avci->skip_samples = AV_RL32(side->data);
323  avci->skip_samples = FFMAX(0, avci->skip_samples);
324  discard_padding = AV_RL32(side->data + 4);
325  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
326  avci->skip_samples, (int)discard_padding);
327  skip_reason = AV_RL8(side->data + 8);
328  discard_reason = AV_RL8(side->data + 9);
329  }
330 
331  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
332  if (!side && (avci->skip_samples || discard_padding))
334  if (side && (avci->skip_samples || discard_padding)) {
335  AV_WL32(side->data, avci->skip_samples);
336  AV_WL32(side->data + 4, discard_padding);
337  AV_WL8(side->data + 8, skip_reason);
338  AV_WL8(side->data + 9, discard_reason);
339  avci->skip_samples = 0;
340  }
341  return 0;
342  }
344 
345  if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
346  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
347  *discarded_samples += frame->nb_samples;
348  return AVERROR(EAGAIN);
349  }
350 
351  if (avci->skip_samples > 0) {
352  if (frame->nb_samples <= avci->skip_samples){
353  *discarded_samples += frame->nb_samples;
354  avci->skip_samples -= frame->nb_samples;
355  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
356  avci->skip_samples);
357  return AVERROR(EAGAIN);
358  } else {
359  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
360  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
361  if (avctx->pkt_timebase.num && avctx->sample_rate) {
362  int64_t diff_ts = av_rescale_q(avci->skip_samples,
363  (AVRational){1, avctx->sample_rate},
364  avctx->pkt_timebase);
365  if (frame->pts != AV_NOPTS_VALUE)
366  frame->pts += diff_ts;
367  if (frame->pkt_dts != AV_NOPTS_VALUE)
368  frame->pkt_dts += diff_ts;
369  if (frame->duration >= diff_ts)
370  frame->duration -= diff_ts;
371  } else
372  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
373 
374  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
375  avci->skip_samples, frame->nb_samples);
376  *discarded_samples += avci->skip_samples;
377  frame->nb_samples -= avci->skip_samples;
378  avci->skip_samples = 0;
379  }
380  }
381 
382  if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
383  if (discard_padding == frame->nb_samples) {
384  *discarded_samples += frame->nb_samples;
385  return AVERROR(EAGAIN);
386  } else {
387  if (avctx->pkt_timebase.num && avctx->sample_rate) {
388  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
389  (AVRational){1, avctx->sample_rate},
390  avctx->pkt_timebase);
391  frame->duration = diff_ts;
392  } else
393  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
394 
395  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
396  (int)discard_padding, frame->nb_samples);
397  frame->nb_samples -= discard_padding;
398  }
399  }
400 
401  return 0;
402 }
403 
404 /*
405  * The core of the receive_frame_wrapper for the decoders implementing
406  * the simple API. Certain decoders might consume partial packets without
407  * returning any output, so this function needs to be called in a loop until it
408  * returns EAGAIN.
409  **/
410 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
411 {
412  AVCodecInternal *avci = avctx->internal;
413  DecodeContext *dc = decode_ctx(avci);
414  AVPacket *const pkt = avci->in_pkt;
415  const FFCodec *const codec = ffcodec(avctx->codec);
416  int got_frame, consumed;
417  int ret;
418 
419  if (!pkt->data && !avci->draining) {
421  ret = ff_decode_get_packet(avctx, pkt);
422  if (ret < 0 && ret != AVERROR_EOF)
423  return ret;
424  }
425 
426  // Some codecs (at least wma lossless) will crash when feeding drain packets
427  // after EOF was signaled.
428  if (avci->draining_done)
429  return AVERROR_EOF;
430 
431  if (!pkt->data &&
433  return AVERROR_EOF;
434 
435  got_frame = 0;
436 
437  frame->pict_type = dc->initial_pict_type;
438  frame->flags |= dc->intra_only_flag;
439  consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
440 
442  frame->pkt_dts = pkt->dts;
443  emms_c();
444 
445  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
446  ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
447  ? AVERROR(EAGAIN)
448  : 0;
449  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
450  ret = !got_frame ? AVERROR(EAGAIN)
451  : discard_samples(avctx, frame, discarded_samples);
452  } else
453  av_assert0(0);
454 
455  if (ret == AVERROR(EAGAIN))
457 
458  // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
459  // code later will add AVERROR(EAGAIN) to a pointer
460  av_assert0(consumed != AVERROR(EAGAIN));
461  if (consumed < 0)
462  ret = consumed;
463  if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
464  consumed = pkt->size;
465 
466  if (!ret)
467  av_assert0(frame->buf[0]);
468  if (ret == AVERROR(EAGAIN))
469  ret = 0;
470 
471  /* do not stop draining when got_frame != 0 or ret < 0 */
472  if (avci->draining && !got_frame) {
473  if (ret < 0) {
474  /* prevent infinite loop if a decoder wrongly always return error on draining */
475  /* reasonable nb_errors_max = maximum b frames + thread count */
476  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
477  avctx->thread_count : 1);
478 
479  if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
480  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
481  "Stop draining and force EOF.\n");
482  avci->draining_done = 1;
483  ret = AVERROR_BUG;
484  }
485  } else {
486  avci->draining_done = 1;
487  }
488  }
489 
490  if (consumed >= pkt->size || ret < 0) {
492  } else {
493  pkt->data += consumed;
494  pkt->size -= consumed;
500  }
501  }
502 
503  return ret;
504 }
505 
506 #if CONFIG_LCMS2
507 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
508 {
509  AVCodecInternal *avci = avctx->internal;
511  AVColorPrimariesDesc coeffs;
512  enum AVColorPrimaries prim;
513  cmsHPROFILE profile;
514  AVFrameSideData *sd;
515  int ret;
516  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
517  return 0;
518 
520  if (!sd || !sd->size)
521  return 0;
522 
523  if (!avci->icc.avctx) {
524  ret = ff_icc_context_init(&avci->icc, avctx);
525  if (ret < 0)
526  return ret;
527  }
528 
529  profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
530  if (!profile)
531  return AVERROR_INVALIDDATA;
532 
533  ret = ff_icc_profile_sanitize(&avci->icc, profile);
534  if (!ret)
535  ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
536  if (!ret)
537  ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
538  cmsCloseProfile(profile);
539  if (ret < 0)
540  return ret;
541 
542  prim = av_csp_primaries_id_from_desc(&coeffs);
543  if (prim != AVCOL_PRI_UNSPECIFIED)
544  frame->color_primaries = prim;
545  if (trc != AVCOL_TRC_UNSPECIFIED)
546  frame->color_trc = trc;
547  return 0;
548 }
549 #else /* !CONFIG_LCMS2 */
551 {
552  return 0;
553 }
554 #endif
555 
556 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
557 {
558  int ret;
559 
560  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
561  frame->color_primaries = avctx->color_primaries;
562  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
563  frame->color_trc = avctx->color_trc;
564  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
565  frame->colorspace = avctx->colorspace;
566  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
567  frame->color_range = avctx->color_range;
568  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
569  frame->chroma_location = avctx->chroma_sample_location;
570 
571  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
572  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
573  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
574  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
575  if (frame->format == AV_SAMPLE_FMT_NONE)
576  frame->format = avctx->sample_fmt;
577  if (!frame->ch_layout.nb_channels) {
578  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
579  if (ret < 0)
580  return ret;
581  }
582  if (!frame->sample_rate)
583  frame->sample_rate = avctx->sample_rate;
584  }
585 
586  return 0;
587 }
588 
590 {
591  int ret;
592  int64_t discarded_samples = 0;
593 
594  while (!frame->buf[0]) {
595  if (discarded_samples > avctx->max_samples)
596  return AVERROR(EAGAIN);
597  ret = decode_simple_internal(avctx, frame, &discarded_samples);
598  if (ret < 0)
599  return ret;
600  }
601 
602  return 0;
603 }
604 
606 {
607  AVCodecInternal *avci = avctx->internal;
608  DecodeContext *dc = decode_ctx(avci);
609  const FFCodec *const codec = ffcodec(avctx->codec);
610  int ret;
611 
612  av_assert0(!frame->buf[0]);
613 
614  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
615  while (1) {
616  frame->pict_type = dc->initial_pict_type;
617  frame->flags |= dc->intra_only_flag;
618  ret = codec->cb.receive_frame(avctx, frame);
619  emms_c();
620  if (!ret) {
621  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
622  int64_t discarded_samples = 0;
623  ret = discard_samples(avctx, frame, &discarded_samples);
624  }
625  if (ret == AVERROR(EAGAIN) || (frame->flags & AV_FRAME_FLAG_DISCARD)) {
627  continue;
628  }
629  }
630  break;
631  }
632  } else
634 
635  if (ret == AVERROR_EOF)
636  avci->draining_done = 1;
637 
638  return ret;
639 }
640 
642 {
643  AVCodecInternal *avci = avctx->internal;
644  DecodeContext *dc = decode_ctx(avci);
645  int ret, ok;
646 
647  if (avctx->active_thread_type & FF_THREAD_FRAME)
649  else
651 
652  /* preserve ret */
653  ok = detect_colorspace(avctx, frame);
654  if (ok < 0) {
656  return ok;
657  }
658 
659  if (!ret) {
660  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
661  if (!frame->width)
662  frame->width = avctx->width;
663  if (!frame->height)
664  frame->height = avctx->height;
665  }
666 
667  ret = fill_frame_props(avctx, frame);
668  if (ret < 0) {
670  return ret;
671  }
672 
673  frame->best_effort_timestamp = guess_correct_pts(dc,
674  frame->pts,
675  frame->pkt_dts);
676 
677  /* the only case where decode data is not set should be decoders
678  * that do not call ff_get_buffer() */
679  av_assert0(frame->private_ref ||
680  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
681 
682  if (frame->private_ref) {
683  FrameDecodeData *fdd = frame->private_ref;
684 
685  if (fdd->post_process) {
686  ret = fdd->post_process(avctx, frame);
687  if (ret < 0) {
689  return ret;
690  }
691  }
692  }
693  }
694 
695  /* free the per-frame decode data */
696  av_refstruct_unref(&frame->private_ref);
697 
698  return ret;
699 }
700 
702 {
703  AVCodecInternal *avci = avctx->internal;
704  DecodeContext *dc = decode_ctx(avci);
705  int ret;
706 
707  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
708  return AVERROR(EINVAL);
709 
710  if (dc->draining_started)
711  return AVERROR_EOF;
712 
713  if (avpkt && !avpkt->size && avpkt->data)
714  return AVERROR(EINVAL);
715 
716  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
717  if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
718  return AVERROR(EAGAIN);
719  ret = av_packet_ref(avci->buffer_pkt, avpkt);
720  if (ret < 0)
721  return ret;
722  } else
723  dc->draining_started = 1;
724 
725  if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
727  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
728  return ret;
729  }
730 
731  return 0;
732 }
733 
735 {
736  /* make sure we are noisy about decoders returning invalid cropping data */
737  if (frame->crop_left >= INT_MAX - frame->crop_right ||
738  frame->crop_top >= INT_MAX - frame->crop_bottom ||
739  (frame->crop_left + frame->crop_right) >= frame->width ||
740  (frame->crop_top + frame->crop_bottom) >= frame->height) {
741  av_log(avctx, AV_LOG_WARNING,
742  "Invalid cropping information set by a decoder: "
744  "(frame size %dx%d). This is a bug, please report it\n",
745  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
746  frame->width, frame->height);
747  frame->crop_left = 0;
748  frame->crop_right = 0;
749  frame->crop_top = 0;
750  frame->crop_bottom = 0;
751  return 0;
752  }
753 
754  if (!avctx->apply_cropping)
755  return 0;
756 
759 }
760 
761 // make sure frames returned to the caller are valid
763 {
764  if (!frame->buf[0] || frame->format < 0)
765  goto fail;
766 
767  switch (avctx->codec_type) {
768  case AVMEDIA_TYPE_VIDEO:
769  if (frame->width <= 0 || frame->height <= 0)
770  goto fail;
771  break;
772  case AVMEDIA_TYPE_AUDIO:
773  if (!av_channel_layout_check(&frame->ch_layout) ||
774  frame->sample_rate <= 0)
775  goto fail;
776 
777  break;
778  default: av_assert0(0);
779  }
780 
781  return 0;
782 fail:
783  av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
784  "This is a bug, please report it.\n");
785  return AVERROR_BUG;
786 }
787 
789 {
790  AVCodecInternal *avci = avctx->internal;
791  int ret;
792 
793  if (avci->buffer_frame->buf[0]) {
795  } else {
797  if (ret < 0)
798  return ret;
799  }
800 
801  ret = frame_validate(avctx, frame);
802  if (ret < 0)
803  goto fail;
804 
805  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
806  ret = apply_cropping(avctx, frame);
807  if (ret < 0)
808  goto fail;
809  }
810 
811  avctx->frame_num++;
812 
813  return 0;
814 fail:
816  return ret;
817 }
818 
820 {
821  memset(sub, 0, sizeof(*sub));
822  sub->pts = AV_NOPTS_VALUE;
823 }
824 
825 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
826 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
827  const AVPacket *inpkt, AVPacket *buf_pkt)
828 {
829 #if CONFIG_ICONV
830  iconv_t cd = (iconv_t)-1;
831  int ret = 0;
832  char *inb, *outb;
833  size_t inl, outl;
834 #endif
835 
836  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
837  *outpkt = inpkt;
838  return 0;
839  }
840 
841 #if CONFIG_ICONV
842  inb = inpkt->data;
843  inl = inpkt->size;
844 
845  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
846  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
847  return AVERROR(ERANGE);
848  }
849 
850  cd = iconv_open("UTF-8", avctx->sub_charenc);
851  av_assert0(cd != (iconv_t)-1);
852 
853  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
854  if (ret < 0)
855  goto end;
856  ret = av_packet_copy_props(buf_pkt, inpkt);
857  if (ret < 0)
858  goto end;
859  outb = buf_pkt->data;
860  outl = buf_pkt->size;
861 
862  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
863  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
864  outl >= buf_pkt->size || inl != 0) {
865  ret = FFMIN(AVERROR(errno), -1);
866  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
867  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
868  goto end;
869  }
870  buf_pkt->size -= outl;
871  memset(buf_pkt->data + buf_pkt->size, 0, outl);
872  *outpkt = buf_pkt;
873 
874  ret = 0;
875 end:
876  if (ret < 0)
877  av_packet_unref(buf_pkt);
878  if (cd != (iconv_t)-1)
879  iconv_close(cd);
880  return ret;
881 #else
882  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
883  return AVERROR(EINVAL);
884 #endif
885 }
886 
887 static int utf8_check(const uint8_t *str)
888 {
889  const uint8_t *byte;
890  uint32_t codepoint, min;
891 
892  while (*str) {
893  byte = str;
894  GET_UTF8(codepoint, *(byte++), return 0;);
895  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
896  1 << (5 * (byte - str) - 4);
897  if (codepoint < min || codepoint >= 0x110000 ||
898  codepoint == 0xFFFE /* BOM */ ||
899  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
900  return 0;
901  str = byte;
902  }
903  return 1;
904 }
905 
907  int *got_sub_ptr, const AVPacket *avpkt)
908 {
909  int ret = 0;
910 
911  if (!avpkt->data && avpkt->size) {
912  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
913  return AVERROR(EINVAL);
914  }
915  if (!avctx->codec)
916  return AVERROR(EINVAL);
918  av_log(avctx, AV_LOG_ERROR, "Codec not subtitle decoder\n");
919  return AVERROR(EINVAL);
920  }
921 
922  *got_sub_ptr = 0;
924 
925  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
926  AVCodecInternal *avci = avctx->internal;
927  const AVPacket *pkt;
928 
929  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
930  if (ret < 0)
931  return ret;
932 
933  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
934  sub->pts = av_rescale_q(avpkt->pts,
935  avctx->pkt_timebase, AV_TIME_BASE_Q);
936  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
937  if (pkt == avci->buffer_pkt) // did we recode?
939  if (ret < 0) {
940  *got_sub_ptr = 0;
941  avsubtitle_free(sub);
942  return ret;
943  }
944  av_assert1(!sub->num_rects || *got_sub_ptr);
945 
946  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
947  avctx->pkt_timebase.num) {
948  AVRational ms = { 1, 1000 };
949  sub->end_display_time = av_rescale_q(avpkt->duration,
950  avctx->pkt_timebase, ms);
951  }
952 
954  sub->format = 0;
955  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
956  sub->format = 1;
957 
958  for (unsigned i = 0; i < sub->num_rects; i++) {
960  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
961  av_log(avctx, AV_LOG_ERROR,
962  "Invalid UTF-8 in decoded subtitles text; "
963  "maybe missing -sub_charenc option\n");
964  avsubtitle_free(sub);
965  *got_sub_ptr = 0;
966  return AVERROR_INVALIDDATA;
967  }
968  }
969 
970  if (*got_sub_ptr)
971  avctx->frame_num++;
972  }
973 
974  return ret;
975 }
976 
978  const enum AVPixelFormat *fmt)
979 {
980  const AVPixFmtDescriptor *desc;
981  const AVCodecHWConfig *config;
982  int i, n;
983 
984  // If a device was supplied when the codec was opened, assume that the
985  // user wants to use it.
986  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
987  AVHWDeviceContext *device_ctx =
989  for (i = 0;; i++) {
990  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
991  if (!config)
992  break;
993  if (!(config->methods &
995  continue;
996  if (device_ctx->type != config->device_type)
997  continue;
998  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
999  if (config->pix_fmt == fmt[n])
1000  return fmt[n];
1001  }
1002  }
1003  }
1004  // No device or other setup, so we have to choose from things which
1005  // don't any other external information.
1006 
1007  // If the last element of the list is a software format, choose it
1008  // (this should be best software format if any exist).
1009  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1010  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1011  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1012  return fmt[n - 1];
1013 
1014  // Finally, traverse the list in order and choose the first entry
1015  // with no external dependencies (if there is no hardware configuration
1016  // information available then this just picks the first entry).
1017  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1018  for (i = 0;; i++) {
1019  config = avcodec_get_hw_config(avctx->codec, i);
1020  if (!config)
1021  break;
1022  if (config->pix_fmt == fmt[n])
1023  break;
1024  }
1025  if (!config) {
1026  // No specific config available, so the decoder must be able
1027  // to handle this format without any additional setup.
1028  return fmt[n];
1029  }
1030  if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1031  // Usable with only internal setup.
1032  return fmt[n];
1033  }
1034  }
1035 
1036  // Nothing is usable, give up.
1037  return AV_PIX_FMT_NONE;
1038 }
1039 
1041  enum AVHWDeviceType dev_type)
1042 {
1043  AVHWDeviceContext *device_ctx;
1044  AVHWFramesContext *frames_ctx;
1045  int ret;
1046 
1047  if (!avctx->hwaccel)
1048  return AVERROR(ENOSYS);
1049 
1050  if (avctx->hw_frames_ctx)
1051  return 0;
1052  if (!avctx->hw_device_ctx) {
1053  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1054  "required for hardware accelerated decoding.\n");
1055  return AVERROR(EINVAL);
1056  }
1057 
1058  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1059  if (device_ctx->type != dev_type) {
1060  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1061  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1062  av_hwdevice_get_type_name(device_ctx->type));
1063  return AVERROR(EINVAL);
1064  }
1065 
1067  avctx->hw_device_ctx,
1068  avctx->hwaccel->pix_fmt,
1069  &avctx->hw_frames_ctx);
1070  if (ret < 0)
1071  return ret;
1072 
1073  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1074 
1075 
1076  if (frames_ctx->initial_pool_size) {
1077  // We guarantee 4 base work surfaces. The function above guarantees 1
1078  // (the absolute minimum), so add the missing count.
1079  frames_ctx->initial_pool_size += 3;
1080  }
1081 
1083  if (ret < 0) {
1084  av_buffer_unref(&avctx->hw_frames_ctx);
1085  return ret;
1086  }
1087 
1088  return 0;
1089 }
1090 
1092  AVBufferRef *device_ref,
1094  AVBufferRef **out_frames_ref)
1095 {
1096  AVBufferRef *frames_ref = NULL;
1097  const AVCodecHWConfigInternal *hw_config;
1098  const FFHWAccel *hwa;
1099  int i, ret;
1100  bool clean_priv_data = false;
1101 
1102  for (i = 0;; i++) {
1103  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1104  if (!hw_config)
1105  return AVERROR(ENOENT);
1106  if (hw_config->public.pix_fmt == hw_pix_fmt)
1107  break;
1108  }
1109 
1110  hwa = hw_config->hwaccel;
1111  if (!hwa || !hwa->frame_params)
1112  return AVERROR(ENOENT);
1113 
1114  frames_ref = av_hwframe_ctx_alloc(device_ref);
1115  if (!frames_ref)
1116  return AVERROR(ENOMEM);
1117 
1118  if (!avctx->internal->hwaccel_priv_data) {
1119  avctx->internal->hwaccel_priv_data =
1120  av_mallocz(hwa->priv_data_size);
1121  if (!avctx->internal->hwaccel_priv_data) {
1122  av_buffer_unref(&frames_ref);
1123  return AVERROR(ENOMEM);
1124  }
1125  clean_priv_data = true;
1126  }
1127 
1128  ret = hwa->frame_params(avctx, frames_ref);
1129  if (ret >= 0) {
1130  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1131 
1132  if (frames_ctx->initial_pool_size) {
1133  // If the user has requested that extra output surfaces be
1134  // available then add them here.
1135  if (avctx->extra_hw_frames > 0)
1136  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1137 
1138  // If frame threading is enabled then an extra surface per thread
1139  // is also required.
1140  if (avctx->active_thread_type & FF_THREAD_FRAME)
1141  frames_ctx->initial_pool_size += avctx->thread_count;
1142  }
1143 
1144  *out_frames_ref = frames_ref;
1145  } else {
1146  if (clean_priv_data)
1148  av_buffer_unref(&frames_ref);
1149  }
1150  return ret;
1151 }
1152 
1153 static int hwaccel_init(AVCodecContext *avctx,
1154  const FFHWAccel *hwaccel)
1155 {
1156  int err;
1157 
1158  if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1160  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1161  hwaccel->p.name);
1162  return AVERROR_PATCHWELCOME;
1163  }
1164 
1165  if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1166  avctx->internal->hwaccel_priv_data =
1167  av_mallocz(hwaccel->priv_data_size);
1168  if (!avctx->internal->hwaccel_priv_data)
1169  return AVERROR(ENOMEM);
1170  }
1171 
1172  avctx->hwaccel = &hwaccel->p;
1173  if (hwaccel->init) {
1174  err = hwaccel->init(avctx);
1175  if (err < 0) {
1176  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1177  "hwaccel initialisation returned error.\n",
1178  av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1180  avctx->hwaccel = NULL;
1181  return err;
1182  }
1183  }
1184 
1185  return 0;
1186 }
1187 
1189 {
1190  if (FF_HW_HAS_CB(avctx, uninit))
1191  FF_HW_SIMPLE_CALL(avctx, uninit);
1192 
1194 
1195  avctx->hwaccel = NULL;
1196 
1197  av_buffer_unref(&avctx->hw_frames_ctx);
1198 }
1199 
1200 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1201 {
1202  const AVPixFmtDescriptor *desc;
1203  enum AVPixelFormat *choices;
1204  enum AVPixelFormat ret, user_choice;
1205  const AVCodecHWConfigInternal *hw_config;
1206  const AVCodecHWConfig *config;
1207  int i, n, err;
1208 
1209  // Find end of list.
1210  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1211  // Must contain at least one entry.
1212  av_assert0(n >= 1);
1213  // If a software format is available, it must be the last entry.
1214  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1215  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1216  // No software format is available.
1217  } else {
1218  avctx->sw_pix_fmt = fmt[n - 1];
1219  }
1220 
1221  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1222  if (!choices)
1223  return AV_PIX_FMT_NONE;
1224 
1225  for (;;) {
1226  // Remove the previous hwaccel, if there was one.
1227  ff_hwaccel_uninit(avctx);
1228 
1229  user_choice = avctx->get_format(avctx, choices);
1230  if (user_choice == AV_PIX_FMT_NONE) {
1231  // Explicitly chose nothing, give up.
1232  ret = AV_PIX_FMT_NONE;
1233  break;
1234  }
1235 
1236  desc = av_pix_fmt_desc_get(user_choice);
1237  if (!desc) {
1238  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1239  "get_format() callback.\n");
1240  ret = AV_PIX_FMT_NONE;
1241  break;
1242  }
1243  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1244  desc->name);
1245 
1246  for (i = 0; i < n; i++) {
1247  if (choices[i] == user_choice)
1248  break;
1249  }
1250  if (i == n) {
1251  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1252  "%s not in possible list.\n", desc->name);
1253  ret = AV_PIX_FMT_NONE;
1254  break;
1255  }
1256 
1257  if (ffcodec(avctx->codec)->hw_configs) {
1258  for (i = 0;; i++) {
1259  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1260  if (!hw_config)
1261  break;
1262  if (hw_config->public.pix_fmt == user_choice)
1263  break;
1264  }
1265  } else {
1266  hw_config = NULL;
1267  }
1268 
1269  if (!hw_config) {
1270  // No config available, so no extra setup required.
1271  ret = user_choice;
1272  break;
1273  }
1274  config = &hw_config->public;
1275 
1276  if (config->methods &
1278  avctx->hw_frames_ctx) {
1279  const AVHWFramesContext *frames_ctx =
1281  if (frames_ctx->format != user_choice) {
1282  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1283  "does not match the format of the provided frames "
1284  "context.\n", desc->name);
1285  goto try_again;
1286  }
1287  } else if (config->methods &
1289  avctx->hw_device_ctx) {
1290  const AVHWDeviceContext *device_ctx =
1292  if (device_ctx->type != config->device_type) {
1293  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1294  "does not match the type of the provided device "
1295  "context.\n", desc->name);
1296  goto try_again;
1297  }
1298  } else if (config->methods &
1300  // Internal-only setup, no additional configuration.
1301  } else if (config->methods &
1303  // Some ad-hoc configuration we can't see and can't check.
1304  } else {
1305  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1306  "missing configuration.\n", desc->name);
1307  goto try_again;
1308  }
1309  if (hw_config->hwaccel) {
1310  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel %s "
1311  "initialisation.\n", desc->name, hw_config->hwaccel->p.name);
1312  err = hwaccel_init(avctx, hw_config->hwaccel);
1313  if (err < 0)
1314  goto try_again;
1315  }
1316  ret = user_choice;
1317  break;
1318 
1319  try_again:
1320  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1321  "get_format() without it.\n", desc->name);
1322  for (i = 0; i < n; i++) {
1323  if (choices[i] == user_choice)
1324  break;
1325  }
1326  for (; i + 1 < n; i++)
1327  choices[i] = choices[i + 1];
1328  --n;
1329  }
1330 
1331  if (ret < 0)
1332  ff_hwaccel_uninit(avctx);
1333 
1334  av_freep(&choices);
1335  return ret;
1336 }
1337 
1338 static const AVPacketSideData*
1341 {
1342  for (int i = 0; i < nb_sd; i++)
1343  if (sd[i].type == type)
1344  return &sd[i];
1345 
1346  return NULL;
1347 }
1348 
1351 {
1353 }
1354 
1356  const AVPacketSideData *sd_pkt)
1357 {
1358  const AVStereo3D *src;
1359  AVStereo3D *dst;
1360  int ret;
1361 
1362  ret = av_buffer_make_writable(&sd_frame->buf);
1363  if (ret < 0)
1364  return ret;
1365  sd_frame->data = sd_frame->buf->data;
1366 
1367  dst = ( AVStereo3D*)sd_frame->data;
1368  src = (const AVStereo3D*)sd_pkt->data;
1369 
1370  if (dst->type == AV_STEREO3D_UNSPEC)
1371  dst->type = src->type;
1372 
1373  if (dst->view == AV_STEREO3D_VIEW_UNSPEC)
1374  dst->view = src->view;
1375 
1376  if (dst->primary_eye == AV_PRIMARY_EYE_NONE)
1377  dst->primary_eye = src->primary_eye;
1378 
1379  if (!dst->baseline)
1380  dst->baseline = src->baseline;
1381 
1382  if (!dst->horizontal_disparity_adjustment.num)
1383  dst->horizontal_disparity_adjustment = src->horizontal_disparity_adjustment;
1384 
1385  if (!dst->horizontal_field_of_view.num)
1386  dst->horizontal_field_of_view = src->horizontal_field_of_view;
1387 
1388  return 0;
1389 }
1390 
1392  const AVPacketSideData *sd_src, int nb_sd_src,
1393  const SideDataMap *map)
1394 
1395 {
1396  for (int i = 0; map[i].packet < AV_PKT_DATA_NB; i++) {
1397  const enum AVPacketSideDataType type_pkt = map[i].packet;
1398  const enum AVFrameSideDataType type_frame = map[i].frame;
1399  const AVPacketSideData *sd_pkt;
1400  AVFrameSideData *sd_frame;
1401 
1402  sd_pkt = packet_side_data_get(sd_src, nb_sd_src, type_pkt);
1403  if (!sd_pkt)
1404  continue;
1405 
1406  sd_frame = av_frame_get_side_data(dst, type_frame);
1407  if (sd_frame) {
1408  if (type_frame == AV_FRAME_DATA_STEREO3D) {
1409  int ret = side_data_stereo3d_merge(sd_frame, sd_pkt);
1410  if (ret < 0)
1411  return ret;
1412  }
1413 
1414  continue;
1415  }
1416 
1417  sd_frame = av_frame_new_side_data(dst, type_frame, sd_pkt->size);
1418  if (!sd_frame)
1419  return AVERROR(ENOMEM);
1420 
1421  memcpy(sd_frame->data, sd_pkt->data, sd_pkt->size);
1422  }
1423 
1424  return 0;
1425 }
1426 
1428 {
1429  size_t size;
1430  const uint8_t *side_metadata;
1431 
1432  AVDictionary **frame_md = &frame->metadata;
1433 
1434  side_metadata = av_packet_get_side_data(avpkt,
1436  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1437 }
1438 
1440  AVFrame *frame, const AVPacket *pkt)
1441 {
1442  static const SideDataMap sd[] = {
1449  { AV_PKT_DATA_NB }
1450  };
1451 
1452  int ret = 0;
1453 
1454  frame->pts = pkt->pts;
1455  frame->duration = pkt->duration;
1456 
1458  if (ret < 0)
1459  return ret;
1460 
1462  if (ret < 0)
1463  return ret;
1464 
1466 
1467  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1468  frame->flags |= AV_FRAME_FLAG_DISCARD;
1469  }
1470 
1471  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1472  int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1473  if (ret < 0)
1474  return ret;
1475  frame->opaque = pkt->opaque;
1476  }
1477 
1478  return 0;
1479 }
1480 
1482 {
1483  int ret;
1484 
1487  if (ret < 0)
1488  return ret;
1489 
1490  for (int i = 0; i < avctx->nb_decoded_side_data; i++) {
1491  const AVFrameSideData *src = avctx->decoded_side_data[i];
1492  if (av_frame_get_side_data(frame, src->type))
1493  continue;
1494  ret = av_frame_side_data_clone(&frame->side_data, &frame->nb_side_data, src, 0);
1495  if (ret < 0)
1496  return ret;
1497  }
1498 
1500  const AVPacket *pkt = avctx->internal->last_pkt_props;
1501 
1503  if (ret < 0)
1504  return ret;
1505  }
1506 
1507  ret = fill_frame_props(avctx, frame);
1508  if (ret < 0)
1509  return ret;
1510 
1511  switch (avctx->codec->type) {
1512  case AVMEDIA_TYPE_VIDEO:
1513  if (frame->width && frame->height &&
1514  av_image_check_sar(frame->width, frame->height,
1515  frame->sample_aspect_ratio) < 0) {
1516  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1517  frame->sample_aspect_ratio.num,
1518  frame->sample_aspect_ratio.den);
1519  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1520  }
1521  break;
1522  }
1523  return 0;
1524 }
1525 
1527 {
1528  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1529  int i;
1530  int num_planes = av_pix_fmt_count_planes(frame->format);
1532  int flags = desc ? desc->flags : 0;
1533  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1534  num_planes = 2;
1535  for (i = 0; i < num_planes; i++) {
1536  av_assert0(frame->data[i]);
1537  }
1538  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1539  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1540  if (frame->data[i])
1541  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1542  frame->data[i] = NULL;
1543  }
1544  }
1545 }
1546 
1547 static void decode_data_free(AVRefStructOpaque unused, void *obj)
1548 {
1549  FrameDecodeData *fdd = obj;
1550 
1551  if (fdd->post_process_opaque_free)
1553 
1554  if (fdd->hwaccel_priv_free)
1555  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1556 }
1557 
1559 {
1560  FrameDecodeData *fdd;
1561 
1562  av_assert1(!frame->private_ref);
1563  av_refstruct_unref(&frame->private_ref);
1564 
1565  fdd = av_refstruct_alloc_ext(sizeof(*fdd), 0, NULL, decode_data_free);
1566  if (!fdd)
1567  return AVERROR(ENOMEM);
1568 
1569  frame->private_ref = fdd;
1570 
1571  return 0;
1572 }
1573 
1575 {
1576  AVCodecInternal *avci = avctx->internal;
1577  DecodeContext *dc = decode_ctx(avci);
1578 
1579  dc->lcevc_frame = dc->lcevc && avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1581 
1582  if (dc->lcevc_frame) {
1583  dc->width = frame->width;
1584  dc->height = frame->height;
1585  frame->width = frame->width * 2 / FFMAX(frame->sample_aspect_ratio.den, 1);
1586  frame->height = frame->height * 2 / FFMAX(frame->sample_aspect_ratio.num, 1);
1587  }
1588 }
1589 
1591 {
1592  AVCodecInternal *avci = avctx->internal;
1593  DecodeContext *dc = decode_ctx(avci);
1594 
1595  if (dc->lcevc_frame) {
1596  FrameDecodeData *fdd = frame->private_ref;
1597 
1598  fdd->post_process_opaque = av_refstruct_ref(dc->lcevc);
1601 
1602  frame->width = dc->width;
1603  frame->height = dc->height;
1604  }
1605  dc->lcevc_frame = 0;
1606 }
1607 
1609 {
1610  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1611  int override_dimensions = 1;
1612  int ret;
1613 
1615 
1616  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1617  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1618  (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) {
1619  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1620  ret = AVERROR(EINVAL);
1621  goto fail;
1622  }
1623 
1624  if (frame->width <= 0 || frame->height <= 0) {
1625  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1626  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1627  override_dimensions = 0;
1628  }
1629 
1630  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1631  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1632  ret = AVERROR(EINVAL);
1633  goto fail;
1634  }
1635  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1636  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1637  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1638  ret = AVERROR(EINVAL);
1639  goto fail;
1640  }
1641  }
1642  ret = ff_decode_frame_props(avctx, frame);
1643  if (ret < 0)
1644  goto fail;
1645 
1646  if (hwaccel) {
1647  if (hwaccel->alloc_frame) {
1648  ret = hwaccel->alloc_frame(avctx, frame);
1649  goto end;
1650  }
1651  } else {
1652  avctx->sw_pix_fmt = avctx->pix_fmt;
1653  update_frame_props(avctx, frame);
1654  }
1655 
1656  ret = avctx->get_buffer2(avctx, frame, flags);
1657  if (ret < 0)
1658  goto fail;
1659 
1661 
1663  if (ret < 0)
1664  goto fail;
1665 
1667 
1668 end:
1669  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1671  frame->width = avctx->width;
1672  frame->height = avctx->height;
1673  }
1674 
1675 fail:
1676  if (ret < 0) {
1677  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1679  }
1680 
1681  return ret;
1682 }
1683 
1685 {
1686  AVFrame *tmp;
1687  int ret;
1688 
1690 
1691  // make sure the discard flag does not persist
1692  frame->flags &= ~AV_FRAME_FLAG_DISCARD;
1693 
1694  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1695  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1696  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1698  }
1699 
1700  if (!frame->data[0])
1701  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1702 
1703  av_frame_side_data_free(&frame->side_data, &frame->nb_side_data);
1704 
1706  return ff_decode_frame_props(avctx, frame);
1707 
1708  tmp = av_frame_alloc();
1709  if (!tmp)
1710  return AVERROR(ENOMEM);
1711 
1713 
1715  if (ret < 0) {
1716  av_frame_free(&tmp);
1717  return ret;
1718  }
1719 
1721  av_frame_free(&tmp);
1722 
1723  return 0;
1724 }
1725 
1727 {
1728  int ret = reget_buffer_internal(avctx, frame, flags);
1729  if (ret < 0)
1730  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1731  return ret;
1732 }
1733 
1734 typedef struct ProgressInternal {
1736  struct AVFrame *f;
1738 
1740 {
1741  av_assert1(!!f->f == !!f->progress);
1742  av_assert1(!f->progress || f->progress->f == f->f);
1743 }
1744 
1746 {
1748 
1749  av_assert1(!f->f && !f->progress);
1750 
1751  f->progress = av_refstruct_pool_get(pool);
1752  if (!f->progress)
1753  return AVERROR(ENOMEM);
1754 
1755  f->f = f->progress->f;
1756  return 0;
1757 }
1758 
1760 {
1761  int ret;
1762 
1764  if (!f->f) {
1765  ret = ff_progress_frame_alloc(avctx, f);
1766  if (ret < 0)
1767  return ret;
1768  }
1769 
1770  ret = ff_thread_get_buffer(avctx, f->progress->f, flags);
1771  if (ret < 0) {
1772  f->f = NULL;
1773  av_refstruct_unref(&f->progress);
1774  return ret;
1775  }
1776  return 0;
1777 }
1778 
1780 {
1781  av_assert1(src->progress && src->f && src->f == src->progress->f);
1782  av_assert1(!dst->f && !dst->progress);
1783  dst->f = src->f;
1784  dst->progress = av_refstruct_ref(src->progress);
1785 }
1786 
1788 {
1790  f->f = NULL;
1791  av_refstruct_unref(&f->progress);
1792 }
1793 
1795 {
1796  if (dst == src)
1797  return;
1800  if (src->f)
1802 }
1803 
1805 {
1806  ff_thread_progress_report(&f->progress->progress, n);
1807 }
1808 
1810 {
1811  ff_thread_progress_await(&f->progress->progress, n);
1812 }
1813 
1814 #if !HAVE_THREADS
1816 {
1818 }
1819 #endif /* !HAVE_THREADS */
1820 
1822 {
1823  const AVCodecContext *avctx = opaque.nc;
1824  ProgressInternal *progress = obj;
1825  int ret;
1826 
1828  if (ret < 0)
1829  return ret;
1830 
1831  progress->f = av_frame_alloc();
1832  if (!progress->f)
1833  return AVERROR(ENOMEM);
1834 
1835  return 0;
1836 }
1837 
1838 static void progress_frame_pool_reset_cb(AVRefStructOpaque unused, void *obj)
1839 {
1840  ProgressInternal *progress = obj;
1841 
1842  ff_thread_progress_reset(&progress->progress);
1843  av_frame_unref(progress->f);
1844 }
1845 
1847 {
1848  ProgressInternal *progress = obj;
1849 
1851  av_frame_free(&progress->f);
1852 }
1853 
1855 {
1856  AVCodecInternal *avci = avctx->internal;
1857  DecodeContext *dc = decode_ctx(avci);
1858  int ret = 0;
1859 
1860  dc->initial_pict_type = AV_PICTURE_TYPE_NONE;
1862  dc->intra_only_flag = AV_FRAME_FLAG_KEY;
1863  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
1864  dc->initial_pict_type = AV_PICTURE_TYPE_I;
1865  }
1866 
1867  /* if the decoder init function was already called previously,
1868  * free the already allocated subtitle_header before overwriting it */
1869  av_freep(&avctx->subtitle_header);
1870 
1871  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1872  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1873  avctx->codec->max_lowres);
1874  avctx->lowres = avctx->codec->max_lowres;
1875  }
1876  if (avctx->sub_charenc) {
1877  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1878  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1879  "supported with subtitles codecs\n");
1880  return AVERROR(EINVAL);
1881  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1882  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1883  "subtitles character encoding will be ignored\n",
1884  avctx->codec_descriptor->name);
1886  } else {
1887  /* input character encoding is set for a text based subtitle
1888  * codec at this point */
1891 
1893 #if CONFIG_ICONV
1894  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1895  if (cd == (iconv_t)-1) {
1896  ret = AVERROR(errno);
1897  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1898  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1899  return ret;
1900  }
1901  iconv_close(cd);
1902 #else
1903  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1904  "conversion needs a libavcodec built with iconv support "
1905  "for this codec\n");
1906  return AVERROR(ENOSYS);
1907 #endif
1908  }
1909  }
1910  }
1911 
1912  dc->pts_correction_num_faulty_pts =
1913  dc->pts_correction_num_faulty_dts = 0;
1914  dc->pts_correction_last_pts =
1915  dc->pts_correction_last_dts = INT64_MIN;
1916 
1917  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1919  av_log(avctx, AV_LOG_WARNING,
1920  "gray decoding requested but not enabled at configuration time\n");
1921  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1923  }
1924 
1925  if (avctx->nb_side_data_prefer_packet == 1 &&
1926  avctx->side_data_prefer_packet[0] == -1)
1927  dc->side_data_pref_mask = ~0ULL;
1928  else {
1929  for (unsigned i = 0; i < avctx->nb_side_data_prefer_packet; i++) {
1930  int val = avctx->side_data_prefer_packet[i];
1931 
1932  if (val < 0 || val >= AV_PKT_DATA_NB) {
1933  av_log(avctx, AV_LOG_ERROR, "Invalid side data type: %d\n", val);
1934  return AVERROR(EINVAL);
1935  }
1936 
1937  for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
1938  if (ff_sd_global_map[j].packet == val) {
1939  val = ff_sd_global_map[j].frame;
1940 
1941  // this code will need to be changed when we have more than
1942  // 64 frame side data types
1943  if (val >= 64) {
1944  av_log(avctx, AV_LOG_ERROR, "Side data type too big\n");
1945  return AVERROR_BUG;
1946  }
1947 
1948  dc->side_data_pref_mask |= 1ULL << val;
1949  }
1950  }
1951  }
1952  }
1953 
1954  avci->in_pkt = av_packet_alloc();
1955  avci->last_pkt_props = av_packet_alloc();
1956  if (!avci->in_pkt || !avci->last_pkt_props)
1957  return AVERROR(ENOMEM);
1958 
1960  avci->progress_frame_pool =
1966  if (!avci->progress_frame_pool)
1967  return AVERROR(ENOMEM);
1968  }
1969  ret = decode_bsfs_init(avctx);
1970  if (ret < 0)
1971  return ret;
1972 
1974  ret = ff_lcevc_alloc(&dc->lcevc);
1975  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
1976  return ret;
1977  }
1978 
1979  return 0;
1980 }
1981 
1982 /**
1983  * Check side data preference and clear existing side data from frame
1984  * if needed.
1985  *
1986  * @retval 0 side data of this type can be added to frame
1987  * @retval 1 side data of this type should not be added to frame
1988  */
1989 static int side_data_pref(const AVCodecContext *avctx, AVFrameSideData ***sd,
1990  int *nb_sd, enum AVFrameSideDataType type)
1991 {
1992  DecodeContext *dc = decode_ctx(avctx->internal);
1993 
1994  // Note: could be skipped for `type` without corresponding packet sd
1995  if (av_frame_side_data_get(*sd, *nb_sd, type)) {
1996  if (dc->side_data_pref_mask & (1ULL << type))
1997  return 1;
1998  av_frame_side_data_remove(sd, nb_sd, type);
1999  }
2000 
2001  return 0;
2002 }
2003 
2004 
2006  enum AVFrameSideDataType type, size_t size,
2007  AVFrameSideData **psd)
2008 {
2009  AVFrameSideData *sd;
2010 
2011  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data, type)) {
2012  if (psd)
2013  *psd = NULL;
2014  return 0;
2015  }
2016 
2018  if (psd)
2019  *psd = sd;
2020 
2021  return sd ? 0 : AVERROR(ENOMEM);
2022 }
2023 
2025  AVFrameSideData ***sd, int *nb_sd,
2027  AVBufferRef **buf)
2028 {
2029  int ret = 0;
2030 
2031  if (side_data_pref(avctx, sd, nb_sd, type))
2032  goto finish;
2033 
2034  if (!av_frame_side_data_add(sd, nb_sd, type, buf, 0))
2035  ret = AVERROR(ENOMEM);
2036 
2037 finish:
2039 
2040  return ret;
2041 }
2042 
2045  AVBufferRef **buf)
2046 {
2048  &frame->side_data, &frame->nb_side_data,
2049  type, buf);
2050 }
2051 
2053  AVFrameSideData ***sd, int *nb_sd,
2054  struct AVMasteringDisplayMetadata **mdm)
2055 {
2056  AVBufferRef *buf;
2057  size_t size;
2058 
2060  *mdm = NULL;
2061  return 0;
2062  }
2063 
2065  if (!*mdm)
2066  return AVERROR(ENOMEM);
2067 
2068  buf = av_buffer_create((uint8_t *)*mdm, size, NULL, NULL, 0);
2069  if (!buf) {
2070  av_freep(mdm);
2071  return AVERROR(ENOMEM);
2072  }
2073 
2075  &buf, 0)) {
2076  *mdm = NULL;
2077  av_buffer_unref(&buf);
2078  return AVERROR(ENOMEM);
2079  }
2080 
2081  return 0;
2082 }
2083 
2086 {
2087  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2089  *mdm = NULL;
2090  return 0;
2091  }
2092 
2094  return *mdm ? 0 : AVERROR(ENOMEM);
2095 }
2096 
2098  AVFrameSideData ***sd, int *nb_sd,
2099  AVContentLightMetadata **clm)
2100 {
2101  AVBufferRef *buf;
2102  size_t size;
2103 
2104  if (side_data_pref(avctx, sd, nb_sd, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL)) {
2105  *clm = NULL;
2106  return 0;
2107  }
2108 
2110  if (!*clm)
2111  return AVERROR(ENOMEM);
2112 
2113  buf = av_buffer_create((uint8_t *)*clm, size, NULL, NULL, 0);
2114  if (!buf) {
2115  av_freep(clm);
2116  return AVERROR(ENOMEM);
2117  }
2118 
2120  &buf, 0)) {
2121  *clm = NULL;
2122  av_buffer_unref(&buf);
2123  return AVERROR(ENOMEM);
2124  }
2125 
2126  return 0;
2127 }
2128 
2130  AVContentLightMetadata **clm)
2131 {
2132  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2134  *clm = NULL;
2135  return 0;
2136  }
2137 
2139  return *clm ? 0 : AVERROR(ENOMEM);
2140 }
2141 
2142 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2143 {
2144  size_t size;
2145  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2146 
2147  if (pal && size == AVPALETTE_SIZE) {
2148  memcpy(dst, pal, AVPALETTE_SIZE);
2149  return 1;
2150  } else if (pal) {
2151  av_log(logctx, AV_LOG_ERROR,
2152  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
2153  }
2154  return 0;
2155 }
2156 
2157 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
2158 {
2159  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
2160 
2161  if (!hwaccel || !hwaccel->frame_priv_data_size)
2162  return 0;
2163 
2164  av_assert0(!*hwaccel_picture_private);
2165 
2166  if (hwaccel->free_frame_priv) {
2167  AVHWFramesContext *frames_ctx;
2168 
2169  if (!avctx->hw_frames_ctx)
2170  return AVERROR(EINVAL);
2171 
2172  frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
2173  *hwaccel_picture_private = av_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
2174  frames_ctx->device_ctx,
2175  hwaccel->free_frame_priv);
2176  } else {
2177  *hwaccel_picture_private = av_refstruct_allocz(hwaccel->frame_priv_data_size);
2178  }
2179 
2180  if (!*hwaccel_picture_private)
2181  return AVERROR(ENOMEM);
2182 
2183  return 0;
2184 }
2185 
2187 {
2188  AVCodecInternal *avci = avctx->internal;
2189  DecodeContext *dc = decode_ctx(avci);
2190 
2192  av_packet_unref(avci->in_pkt);
2193 
2194  dc->pts_correction_last_pts =
2195  dc->pts_correction_last_dts = INT64_MIN;
2196 
2197  if (avci->bsf)
2198  av_bsf_flush(avci->bsf);
2199 
2200  dc->nb_draining_errors = 0;
2201  dc->draining_started = 0;
2202 }
2203 
2205 {
2206  return av_mallocz(sizeof(DecodeContext));
2207 }
2208 
2210 {
2211  const DecodeContext *src_dc = decode_ctx(src->internal);
2212  DecodeContext *dst_dc = decode_ctx(dst->internal);
2213 
2214  av_refstruct_replace(&dst_dc->lcevc, src_dc->lcevc);
2215 }
2216 
2218 {
2219  AVCodecInternal *avci = avctx->internal;
2220  DecodeContext *dc = decode_ctx(avci);
2221 
2222  av_refstruct_unref(&dc->lcevc);
2223 }
lcevcdec.h
flags
const SwsFlags flags[]
Definition: swscale.c:61
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:1349
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:68
AVSubtitle
Definition: avcodec.h:2081
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:1804
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:430
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1408
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:213
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:1153
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
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:244
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
Frame::width
int width
Definition: ffplay.c:159
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
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:2086
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:764
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
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:662
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:644
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:1930
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1200
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:734
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:1027
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:661
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:649
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:75
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3341
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ff_lcevc_alloc
int ff_lcevc_alloc(FFLCEVCContext **plcevc)
Definition: lcevcdec.c:306
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:1982
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AVRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
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:597
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:198
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:125
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1401
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:209
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1707
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:395
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1769
int64_t
long long int64_t
Definition: coverity.c:34
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2085
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:589
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:63
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:548
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:326
DecodeContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: decode.c:87
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFrameSideData::buf
AVBufferRef * buf
Definition: frame.h:270
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:655
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:386
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:191
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:146
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:252
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:535
FFLCEVCContext
Definition: lcevcdec.h:31
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:647
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:1759
data
const char data[16]
Definition: mxf.c:149
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:127
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1745
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:612
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:176
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:553
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:1725
AVDictionary
Definition: dict.c:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:619
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:977
av_frame_side_data_clone
int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *src, unsigned int flags)
Add a new side data entry to an array based on existing side data, taking a reference towards the con...
Definition: side_data.c:246
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:700
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
ff_thread_receive_frame
#define ff_thread_receive_frame(avctx, frame)
Definition: decode.c:216
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:394
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:91
decode_ctx
static DecodeContext * decode_ctx(AVCodecInternal *avci)
Definition: decode.c:102
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:1724
AV_STEREO3D_VIEW_UNSPEC
@ AV_STEREO3D_VIEW_UNSPEC
Content is unspecified.
Definition: stereo3d.h:168
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
AV_STEREO3D_UNSPEC
@ AV_STEREO3D_UNSPEC
Video is stereoscopic but the packing is unspecified.
Definition: stereo3d.h:143
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:762
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:318
DecodeContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: decode.c:86
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1188
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:219
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:192
AVPacketSideData::size
size_t size
Definition: packet.h:388
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3381
DecodeContext::nb_draining_errors
int nb_draining_errors
Definition: decode.c:78
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:279
finish
static void finish(void)
Definition: movenc.c:374
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:286
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
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:571
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:46
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1042
fail
#define fail()
Definition: checkasm.h:193
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:1564
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
ff_lcevc_process
int ff_lcevc_process(void *logctx, AVFrame *frame)
Definition: lcevcdec.c:279
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:1723
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FrameDecodeData::post_process_opaque_free
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h: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:1439
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:311
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:1427
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:610
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1831
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:2078
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
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)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2043
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:327
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
av_refstruct_allocz
static void * av_refstruct_allocz(size_t size)
Equivalent to av_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:51
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:1203
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:488
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:906
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:2097
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
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:648
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:209
AVFrameSideData::size
size_t size
Definition: frame.h:268
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:788
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
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:1779
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:613
AVCodecContext::side_data_prefer_packet
int * side_data_prefer_packet
Decoding only.
Definition: avcodec.h:1914
stereo3d.h
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:2157
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:819
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:99
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1526
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:144
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:60
FFHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: hwaccel_internal.h:114
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:1931
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:411
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:1048
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_refstruct_alloc_ext
static void * av_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(AVRefStructOpaque opaque, void *obj))
A wrapper around av_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:387
AVRefStructPool
AVRefStructPool is an API for a thread-safe pool of objects managed via the RefStruct API.
Definition: refstruct.c:183
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:1787
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:339
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2087
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:1788
AV_PKT_DATA_LCEVC
@ AV_PKT_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: packet.h:346
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:116
progress_frame_pool_init_cb
static av_cold int progress_frame_pool_init_cb(AVRefStructOpaque opaque, void *obj)
Definition: decode.c:1821
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:560
ProgressInternal
Definition: decode.c:1734
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:622
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:1739
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:72
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:196
discard_samples
static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:312
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:1040
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:2084
DecodeContext::draining_started
int draining_started
The caller has submitted a NULL packet on input.
Definition: decode.c:83
ff_thread_get_packet
#define ff_thread_get_packet(avctx, pkt)
Definition: decode.c:215
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
AVCodecContext::sub_charenc
char * sub_charenc
Character encoding of the input subtitles file.
Definition: avcodec.h:1714
ff_decode_internal_alloc
AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:2204
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:368
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
AVCodecInternal::progress_frame_pool
struct AVRefStructPool * progress_frame_pool
Definition: internal.h:71
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:64
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:887
update_frame_props
static void update_frame_props(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1574
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:2186
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1815
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:672
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:185
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:1770
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:466
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: side_data.c:100
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:112
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_lcevc_unref
void ff_lcevc_unref(void *opaque)
Definition: lcevcdec.c:318
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
av_refstruct_pool_alloc_ext
static AVRefStructPool * av_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(AVRefStructOpaque opaque, void *obj), void(*reset_cb)(AVRefStructOpaque opaque, void *obj), void(*free_entry_cb)(AVRefStructOpaque opaque, void *obj), void(*free_cb)(AVRefStructOpaque opaque))
A wrapper around av_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:258
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
av_refstruct_pool_get
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
AV_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR
#define AV_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
DecodeContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: decode.c:88
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:378
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_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:298
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:438
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:146
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:179
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:825
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:58
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:716
AV_CODEC_EXPORT_DATA_ENHANCEMENTS
#define AV_CODEC_EXPORT_DATA_ENHANCEMENTS
Decoding only.
Definition: avcodec.h:406
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:90
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:356
progress_frame_pool_free_entry_cb
static av_cold void progress_frame_pool_free_entry_cb(AVRefStructOpaque opaque, void *obj)
Definition: decode.c:1846
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:85
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1700
f
f
Definition: af_crystalizer.c:122
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:495
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1608
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:302
AVPacket::size
int size
Definition: packet.h:536
ff_progress_frame_alloc
int ff_progress_frame_alloc(AVCodecContext *avctx, ProgressFrame *f)
This function allocates ProgressFrame.f May be called before ff_progress_frame_get_buffer() in the ca...
Definition: decode.c:1745
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:1501
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:130
decode_data_free
static void decode_data_free(AVRefStructOpaque unused, void *obj)
Definition: decode.c:1547
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:713
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:424
ff_codec_is_decoder
static int ff_codec_is_decoder(const AVCodec *avcodec)
Internal version of av_codec_is_decoder().
Definition: codec_internal.h:303
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::bsf
struct AVBSFContext * bsf
Definition: internal.h:84
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1034
AV_FRAME_DATA_LCEVC
@ AV_FRAME_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: frame.h:236
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:545
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:762
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:2005
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:2024
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:1989
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
DecodeContext::height
int height
Definition: decode.c:99
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:284
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:537
fill_frame_props
static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:556
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:770
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
av_buffer_make_writable
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
Definition: buffer.c:165
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2084
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:350
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:727
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:534
av_refstruct_ref
void * av_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
ProgressInternal::progress
ThreadProgress progress
Definition: decode.c:1735
AV_PRIMARY_EYE_NONE
@ AV_PRIMARY_EYE_NONE
Neither eye.
Definition: stereo3d.h:178
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:82
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:541
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:64
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:1809
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:264
DecodeContext::side_data_pref_mask
uint64_t side_data_pref_mask
DTS of the last frame.
Definition: decode.c:94
FF_THREAD_NO_FRAME_THREADING
@ FF_THREAD_NO_FRAME_THREADING
Definition: thread.h:63
packet_side_data_get
static const AVPacketSideData * packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Definition: decode.c:1339
AVCodecContext::nb_side_data_prefer_packet
unsigned nb_side_data_prefer_packet
Number of entries in side_data_prefer_packet.
Definition: avcodec.h:1918
detect_colorspace
static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: decode.c:550
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1575
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
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:44
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:1948
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:169
emms.h
AVCodecInternal::is_frame_mt
int is_frame_mt
This field is set to 1 when frame threading is being used and the parent AVCodecContext of this AVCod...
Definition: internal.h:61
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:701
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:136
extract_packet_props
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
Definition: decode.c:168
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:393
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:2082
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:528
av_frame_side_data_free
void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
Free all side data entries and their contents, then zeroes out the values which the pointers are poin...
Definition: side_data.c:131
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1684
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:253
attach_post_process_data
static void attach_post_process_data(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1590
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:641
internal.h
ff_decode_receive_frame_internal
int ff_decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Do the actual decoding and obtain a decoded frame from the decoder, if available.
Definition: decode.c:605
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:83
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:1854
ff_thread_progress_init
av_cold int ff_thread_progress_init(ThreadProgress *pro, int init_mode)
Initialize a ThreadProgress.
Definition: threadprogress.c:33
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
DecodeContext::avci
AVCodecInternal avci
Definition: decode.c:61
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:525
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:978
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:498
DecodeContext::lcevc
FFLCEVCContext * lcevc
Definition: decode.c:96
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:1478
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:679
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:2250
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:676
AVCodecContext::height
int height
Definition: avcodec.h:595
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:410
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:634
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:1456
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:204
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1722
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:116
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1884
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:1091
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:1726
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:73
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:135
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1360
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:783
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:1815
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:2129
ff_thread_progress_destroy
av_cold void ff_thread_progress_destroy(ThreadProgress *pro)
Destroy a ThreadProgress.
Definition: threadprogress.c:44
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:546
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:1794
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:107
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:1481
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:431
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1583
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, const AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:826
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:58
avcodec_internal.h
av_refstruct_replace
void av_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:168
side_data_stereo3d_merge
static int side_data_stereo3d_merge(AVFrameSideData *sd_frame, const AVPacketSideData *sd_pkt)
Definition: decode.c:1355
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:1780
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:115
ProgressInternal::f
struct AVFrame * f
Definition: decode.c:1736
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:154
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:836
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:145
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:103
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:449
AVCodecInternal::draining
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition: internal.h:139
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:255
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:610
progress_frame_pool_reset_cb
static void progress_frame_pool_reset_cb(AVRefStructOpaque unused, void *obj)
Definition: decode.c:1838
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:188
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:439
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:2052
side_data_map
static int side_data_map(AVFrame *dst, const AVPacketSideData *sd_src, int nb_sd_src, const SideDataMap *map)
Definition: decode.c:1391
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:239
ff_decode_internal_uninit
void ff_decode_internal_uninit(AVCodecContext *avctx)
Definition: decode.c:2217
DecodeContext::width
int width
Definition: decode.c:98
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:386
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:1558
ThreadingStatus
ThreadingStatus
Definition: thread.h:60
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:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
DecodeContext::lcevc_frame
int lcevc_frame
Definition: decode.c:97
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:364
ProgressFrame
The ProgressFrame structure.
Definition: progressframe.h:73
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
SideDataMap
Definition: avcodec_internal.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:512
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FFCodec::cb
union FFCodec::@92 cb
DecodeContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Definition: decode.c:85
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:1127
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:595
bytestream.h
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
imgutils.h
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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:330
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:641
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:2142
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:179
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
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:1969
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:619
DecodeContext
Definition: decode.c:60
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: side_data.c:221
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: decode.h:128
src
#define src
Definition: vp8dsp.c:248
ff_decode_internal_sync
void ff_decode_internal_sync(AVCodecContext *dst, const AVCodecContext *src)
Definition: decode.c:2209
Frame::height
int height
Definition: ffplay.c:160
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:547
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:3261
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:1726
min
float min
Definition: vorbis_enc_data.h:429