FFmpeg
decode.c
Go to the documentation of this file.
1 /*
2  * generic decoding-related code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 #include <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 "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 #if FF_API_FRAME_PKT
176  if (!ret)
177  avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props().
178 #endif
179  }
180  return ret;
181 }
182 
184 {
185  AVCodecInternal *avci = avctx->internal;
186  const FFCodec *const codec = ffcodec(avctx->codec);
187  int ret;
188 
189  if (avci->bsf)
190  return 0;
191 
192  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
193  if (ret < 0) {
194  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
195  if (ret != AVERROR(ENOMEM))
196  ret = AVERROR_BUG;
197  goto fail;
198  }
199 
200  /* We do not currently have an API for passing the input timebase into decoders,
201  * but no filters used here should actually need it.
202  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
203  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
205  if (ret < 0)
206  goto fail;
207 
208  ret = av_bsf_init(avci->bsf);
209  if (ret < 0)
210  goto fail;
211 
212  return 0;
213 fail:
214  av_bsf_free(&avci->bsf);
215  return ret;
216 }
217 
218 #if !HAVE_THREADS
219 #define ff_thread_get_packet(avctx, pkt) (AVERROR_BUG)
220 #define ff_thread_receive_frame(avctx, frame) (AVERROR_BUG)
221 #endif
222 
224 {
225  AVCodecInternal *avci = avctx->internal;
226  int ret;
227 
228  ret = av_bsf_receive_packet(avci->bsf, pkt);
229  if (ret < 0)
230  return ret;
231 
234  if (ret < 0)
235  goto finish;
236  }
237 
238  ret = apply_param_change(avctx, pkt);
239  if (ret < 0)
240  goto finish;
241 
242  return 0;
243 finish:
245  return ret;
246 }
247 
249 {
250  AVCodecInternal *avci = avctx->internal;
251  DecodeContext *dc = decode_ctx(avci);
252 
253  if (avci->draining)
254  return AVERROR_EOF;
255 
256  /* If we are a worker thread, get the next packet from the threading
257  * context. Otherwise we are the main (user-facing) context, so we get the
258  * next packet from the input filterchain.
259  */
260  if (avctx->internal->is_frame_mt)
261  return ff_thread_get_packet(avctx, pkt);
262 
263  while (1) {
264  int ret = decode_get_packet(avctx, pkt);
265  if (ret == AVERROR(EAGAIN) &&
266  (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
267  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
268  if (ret >= 0)
269  continue;
270 
272  }
273 
274  if (ret == AVERROR_EOF)
275  avci->draining = 1;
276  return ret;
277  }
278 }
279 
280 /**
281  * Attempt to guess proper monotonic timestamps for decoded video frames
282  * which might have incorrect times. Input timestamps may wrap around, in
283  * which case the output will as well.
284  *
285  * @param pts the pts field of the decoded AVPacket, as passed through
286  * AVFrame.pts
287  * @param dts the dts field of the decoded AVPacket
288  * @return one of the input values, may be AV_NOPTS_VALUE
289  */
291  int64_t reordered_pts, int64_t dts)
292 {
294 
295  if (dts != AV_NOPTS_VALUE) {
296  dc->pts_correction_num_faulty_dts += dts <= dc->pts_correction_last_dts;
297  dc->pts_correction_last_dts = dts;
298  } else if (reordered_pts != AV_NOPTS_VALUE)
299  dc->pts_correction_last_dts = reordered_pts;
300 
301  if (reordered_pts != AV_NOPTS_VALUE) {
302  dc->pts_correction_num_faulty_pts += reordered_pts <= dc->pts_correction_last_pts;
303  dc->pts_correction_last_pts = reordered_pts;
304  } else if(dts != AV_NOPTS_VALUE)
305  dc->pts_correction_last_pts = dts;
306 
307  if ((dc->pts_correction_num_faulty_pts<=dc->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
308  && reordered_pts != AV_NOPTS_VALUE)
309  pts = reordered_pts;
310  else
311  pts = dts;
312 
313  return pts;
314 }
315 
316 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
317 {
318  AVCodecInternal *avci = avctx->internal;
319  AVFrameSideData *side;
320  uint32_t discard_padding = 0;
321  uint8_t skip_reason = 0;
322  uint8_t discard_reason = 0;
323 
325  if (side && side->size >= 10) {
326  avci->skip_samples = AV_RL32(side->data);
327  avci->skip_samples = FFMAX(0, avci->skip_samples);
328  discard_padding = AV_RL32(side->data + 4);
329  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
330  avci->skip_samples, (int)discard_padding);
331  skip_reason = AV_RL8(side->data + 8);
332  discard_reason = AV_RL8(side->data + 9);
333  }
334 
335  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
336  if (!side && (avci->skip_samples || discard_padding))
338  if (side && (avci->skip_samples || discard_padding)) {
339  AV_WL32(side->data, avci->skip_samples);
340  AV_WL32(side->data + 4, discard_padding);
341  AV_WL8(side->data + 8, skip_reason);
342  AV_WL8(side->data + 9, discard_reason);
343  avci->skip_samples = 0;
344  }
345  return 0;
346  }
348 
349  if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
350  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
351  *discarded_samples += frame->nb_samples;
352  return AVERROR(EAGAIN);
353  }
354 
355  if (avci->skip_samples > 0) {
356  if (frame->nb_samples <= avci->skip_samples){
357  *discarded_samples += frame->nb_samples;
358  avci->skip_samples -= frame->nb_samples;
359  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
360  avci->skip_samples);
361  return AVERROR(EAGAIN);
362  } else {
363  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
364  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
365  if (avctx->pkt_timebase.num && avctx->sample_rate) {
366  int64_t diff_ts = av_rescale_q(avci->skip_samples,
367  (AVRational){1, avctx->sample_rate},
368  avctx->pkt_timebase);
369  if (frame->pts != AV_NOPTS_VALUE)
370  frame->pts += diff_ts;
371  if (frame->pkt_dts != AV_NOPTS_VALUE)
372  frame->pkt_dts += diff_ts;
373  if (frame->duration >= diff_ts)
374  frame->duration -= diff_ts;
375  } else
376  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
377 
378  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
379  avci->skip_samples, frame->nb_samples);
380  *discarded_samples += avci->skip_samples;
381  frame->nb_samples -= avci->skip_samples;
382  avci->skip_samples = 0;
383  }
384  }
385 
386  if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
387  if (discard_padding == frame->nb_samples) {
388  *discarded_samples += frame->nb_samples;
389  return AVERROR(EAGAIN);
390  } else {
391  if (avctx->pkt_timebase.num && avctx->sample_rate) {
392  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
393  (AVRational){1, avctx->sample_rate},
394  avctx->pkt_timebase);
395  frame->duration = diff_ts;
396  } else
397  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
398 
399  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
400  (int)discard_padding, frame->nb_samples);
401  frame->nb_samples -= discard_padding;
402  }
403  }
404 
405  return 0;
406 }
407 
408 /*
409  * The core of the receive_frame_wrapper for the decoders implementing
410  * the simple API. Certain decoders might consume partial packets without
411  * returning any output, so this function needs to be called in a loop until it
412  * returns EAGAIN.
413  **/
414 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
415 {
416  AVCodecInternal *avci = avctx->internal;
417  DecodeContext *dc = decode_ctx(avci);
418  AVPacket *const pkt = avci->in_pkt;
419  const FFCodec *const codec = ffcodec(avctx->codec);
420  int got_frame, consumed;
421  int ret;
422 
423  if (!pkt->data && !avci->draining) {
425  ret = ff_decode_get_packet(avctx, pkt);
426  if (ret < 0 && ret != AVERROR_EOF)
427  return ret;
428  }
429 
430  // Some codecs (at least wma lossless) will crash when feeding drain packets
431  // after EOF was signaled.
432  if (avci->draining_done)
433  return AVERROR_EOF;
434 
435  if (!pkt->data &&
437  return AVERROR_EOF;
438 
439  got_frame = 0;
440 
441  frame->pict_type = dc->initial_pict_type;
442  frame->flags |= dc->intra_only_flag;
443  consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
444 
446  frame->pkt_dts = pkt->dts;
447  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
448 #if FF_API_FRAME_PKT
450  if(!avctx->has_b_frames)
451  frame->pkt_pos = pkt->pos;
453 #endif
454  }
455  emms_c();
456 
457  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
458  ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
459  ? AVERROR(EAGAIN)
460  : 0;
461  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
462  ret = !got_frame ? AVERROR(EAGAIN)
463  : discard_samples(avctx, frame, discarded_samples);
464  } else
465  av_assert0(0);
466 
467  if (ret == AVERROR(EAGAIN))
469 
470  // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
471  // code later will add AVERROR(EAGAIN) to a pointer
472  av_assert0(consumed != AVERROR(EAGAIN));
473  if (consumed < 0)
474  ret = consumed;
475  if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
476  consumed = pkt->size;
477 
478  if (!ret)
479  av_assert0(frame->buf[0]);
480  if (ret == AVERROR(EAGAIN))
481  ret = 0;
482 
483  /* do not stop draining when got_frame != 0 or ret < 0 */
484  if (avci->draining && !got_frame) {
485  if (ret < 0) {
486  /* prevent infinite loop if a decoder wrongly always return error on draining */
487  /* reasonable nb_errors_max = maximum b frames + thread count */
488  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
489  avctx->thread_count : 1);
490 
491  if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
492  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
493  "Stop draining and force EOF.\n");
494  avci->draining_done = 1;
495  ret = AVERROR_BUG;
496  }
497  } else {
498  avci->draining_done = 1;
499  }
500  }
501 
502  if (consumed >= pkt->size || ret < 0) {
504  } else {
505  pkt->data += consumed;
506  pkt->size -= consumed;
510 #if FF_API_FRAME_PKT
511  // See extract_packet_props() comment.
512  avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed;
513 #endif
516  }
517  }
518 
519  return ret;
520 }
521 
522 #if CONFIG_LCMS2
523 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
524 {
525  AVCodecInternal *avci = avctx->internal;
527  AVColorPrimariesDesc coeffs;
528  enum AVColorPrimaries prim;
529  cmsHPROFILE profile;
530  AVFrameSideData *sd;
531  int ret;
532  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
533  return 0;
534 
536  if (!sd || !sd->size)
537  return 0;
538 
539  if (!avci->icc.avctx) {
540  ret = ff_icc_context_init(&avci->icc, avctx);
541  if (ret < 0)
542  return ret;
543  }
544 
545  profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
546  if (!profile)
547  return AVERROR_INVALIDDATA;
548 
549  ret = ff_icc_profile_sanitize(&avci->icc, profile);
550  if (!ret)
551  ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
552  if (!ret)
553  ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
554  cmsCloseProfile(profile);
555  if (ret < 0)
556  return ret;
557 
558  prim = av_csp_primaries_id_from_desc(&coeffs);
559  if (prim != AVCOL_PRI_UNSPECIFIED)
560  frame->color_primaries = prim;
561  if (trc != AVCOL_TRC_UNSPECIFIED)
562  frame->color_trc = trc;
563  return 0;
564 }
565 #else /* !CONFIG_LCMS2 */
567 {
568  return 0;
569 }
570 #endif
571 
572 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
573 {
574  int ret;
575 
576  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
577  frame->color_primaries = avctx->color_primaries;
578  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
579  frame->color_trc = avctx->color_trc;
580  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
581  frame->colorspace = avctx->colorspace;
582  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
583  frame->color_range = avctx->color_range;
584  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
585  frame->chroma_location = avctx->chroma_sample_location;
586 
587  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
588  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
589  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
590  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
591  if (frame->format == AV_SAMPLE_FMT_NONE)
592  frame->format = avctx->sample_fmt;
593  if (!frame->ch_layout.nb_channels) {
594  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
595  if (ret < 0)
596  return ret;
597  }
598  if (!frame->sample_rate)
599  frame->sample_rate = avctx->sample_rate;
600  }
601 
602  return 0;
603 }
604 
606 {
607  int ret;
608  int64_t discarded_samples = 0;
609 
610  while (!frame->buf[0]) {
611  if (discarded_samples > avctx->max_samples)
612  return AVERROR(EAGAIN);
613  ret = decode_simple_internal(avctx, frame, &discarded_samples);
614  if (ret < 0)
615  return ret;
616  }
617 
618  return 0;
619 }
620 
622 {
623  AVCodecInternal *avci = avctx->internal;
624  DecodeContext *dc = decode_ctx(avci);
625  const FFCodec *const codec = ffcodec(avctx->codec);
626  int ret;
627 
628  av_assert0(!frame->buf[0]);
629 
630  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
631  while (1) {
632  frame->pict_type = dc->initial_pict_type;
633  frame->flags |= dc->intra_only_flag;
634  ret = codec->cb.receive_frame(avctx, frame);
635  emms_c();
636  if (!ret) {
637  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
638  int64_t discarded_samples = 0;
639  ret = discard_samples(avctx, frame, &discarded_samples);
640  }
641  if (ret == AVERROR(EAGAIN) || (frame->flags & AV_FRAME_FLAG_DISCARD)) {
643  continue;
644  }
645  }
646  break;
647  }
648  } else
650 
651  if (ret == AVERROR_EOF)
652  avci->draining_done = 1;
653 
654  return ret;
655 }
656 
658 {
659  AVCodecInternal *avci = avctx->internal;
660  DecodeContext *dc = decode_ctx(avci);
661  int ret, ok;
662 
663  if (avctx->active_thread_type & FF_THREAD_FRAME)
665  else
667 
668  /* preserve ret */
669  ok = detect_colorspace(avctx, frame);
670  if (ok < 0) {
672  return ok;
673  }
674 
675  if (!ret) {
676  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
677  if (!frame->width)
678  frame->width = avctx->width;
679  if (!frame->height)
680  frame->height = avctx->height;
681  }
682 
683  ret = fill_frame_props(avctx, frame);
684  if (ret < 0) {
686  return ret;
687  }
688 
689 #if FF_API_FRAME_KEY
691  frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY);
693 #endif
694 #if FF_API_INTERLACED_FRAME
696  frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED);
697  frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
699 #endif
700  frame->best_effort_timestamp = guess_correct_pts(dc,
701  frame->pts,
702  frame->pkt_dts);
703 
704  /* the only case where decode data is not set should be decoders
705  * that do not call ff_get_buffer() */
706  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
707  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
708 
709  if (frame->private_ref) {
710  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
711 
712  if (fdd->post_process) {
713  ret = fdd->post_process(avctx, frame);
714  if (ret < 0) {
716  return ret;
717  }
718  }
719  }
720  }
721 
722  /* free the per-frame decode data */
723  av_buffer_unref(&frame->private_ref);
724 
725  return ret;
726 }
727 
729 {
730  AVCodecInternal *avci = avctx->internal;
731  DecodeContext *dc = decode_ctx(avci);
732  int ret;
733 
734  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
735  return AVERROR(EINVAL);
736 
737  if (dc->draining_started)
738  return AVERROR_EOF;
739 
740  if (avpkt && !avpkt->size && avpkt->data)
741  return AVERROR(EINVAL);
742 
743  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
744  if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
745  return AVERROR(EAGAIN);
746  ret = av_packet_ref(avci->buffer_pkt, avpkt);
747  if (ret < 0)
748  return ret;
749  } else
750  dc->draining_started = 1;
751 
752  if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
754  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
755  return ret;
756  }
757 
758  return 0;
759 }
760 
762 {
763  /* make sure we are noisy about decoders returning invalid cropping data */
764  if (frame->crop_left >= INT_MAX - frame->crop_right ||
765  frame->crop_top >= INT_MAX - frame->crop_bottom ||
766  (frame->crop_left + frame->crop_right) >= frame->width ||
767  (frame->crop_top + frame->crop_bottom) >= frame->height) {
768  av_log(avctx, AV_LOG_WARNING,
769  "Invalid cropping information set by a decoder: "
771  "(frame size %dx%d). This is a bug, please report it\n",
772  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
773  frame->width, frame->height);
774  frame->crop_left = 0;
775  frame->crop_right = 0;
776  frame->crop_top = 0;
777  frame->crop_bottom = 0;
778  return 0;
779  }
780 
781  if (!avctx->apply_cropping)
782  return 0;
783 
786 }
787 
788 // make sure frames returned to the caller are valid
790 {
791  if (!frame->buf[0] || frame->format < 0)
792  goto fail;
793 
794  switch (avctx->codec_type) {
795  case AVMEDIA_TYPE_VIDEO:
796  if (frame->width <= 0 || frame->height <= 0)
797  goto fail;
798  break;
799  case AVMEDIA_TYPE_AUDIO:
800  if (!av_channel_layout_check(&frame->ch_layout) ||
801  frame->sample_rate <= 0)
802  goto fail;
803 
804  break;
805  default: av_assert0(0);
806  }
807 
808  return 0;
809 fail:
810  av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
811  "This is a bug, please report it.\n");
812  return AVERROR_BUG;
813 }
814 
816 {
817  AVCodecInternal *avci = avctx->internal;
818  int ret;
819 
820  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
821  return AVERROR(EINVAL);
822 
823  if (avci->buffer_frame->buf[0]) {
825  } else {
827  if (ret < 0)
828  return ret;
829  }
830 
831  ret = frame_validate(avctx, frame);
832  if (ret < 0)
833  goto fail;
834 
835  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
836  ret = apply_cropping(avctx, frame);
837  if (ret < 0)
838  goto fail;
839  }
840 
841  avctx->frame_num++;
842 
843 #if FF_API_DROPCHANGED
844  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
845 
846  if (avctx->frame_num == 1) {
847  avci->initial_format = frame->format;
848  switch(avctx->codec_type) {
849  case AVMEDIA_TYPE_VIDEO:
850  avci->initial_width = frame->width;
851  avci->initial_height = frame->height;
852  break;
853  case AVMEDIA_TYPE_AUDIO:
854  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
855  avctx->sample_rate;
856  ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
857  if (ret < 0)
858  goto fail;
859  break;
860  }
861  }
862 
863  if (avctx->frame_num > 1) {
864  int changed = avci->initial_format != frame->format;
865 
866  switch(avctx->codec_type) {
867  case AVMEDIA_TYPE_VIDEO:
868  changed |= avci->initial_width != frame->width ||
869  avci->initial_height != frame->height;
870  break;
871  case AVMEDIA_TYPE_AUDIO:
872  changed |= avci->initial_sample_rate != frame->sample_rate ||
873  avci->initial_sample_rate != avctx->sample_rate ||
875  break;
876  }
877 
878  if (changed) {
879  avci->changed_frames_dropped++;
880  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64
881  " drop count: %d \n",
882  avctx->frame_num, frame->pts,
883  avci->changed_frames_dropped);
885  goto fail;
886  }
887  }
888  }
889 #endif
890  return 0;
891 fail:
893  return ret;
894 }
895 
897 {
898  memset(sub, 0, sizeof(*sub));
899  sub->pts = AV_NOPTS_VALUE;
900 }
901 
902 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
903 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
904  const AVPacket *inpkt, AVPacket *buf_pkt)
905 {
906 #if CONFIG_ICONV
907  iconv_t cd = (iconv_t)-1;
908  int ret = 0;
909  char *inb, *outb;
910  size_t inl, outl;
911 #endif
912 
913  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
914  *outpkt = inpkt;
915  return 0;
916  }
917 
918 #if CONFIG_ICONV
919  inb = inpkt->data;
920  inl = inpkt->size;
921 
922  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
923  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
924  return AVERROR(ERANGE);
925  }
926 
927  cd = iconv_open("UTF-8", avctx->sub_charenc);
928  av_assert0(cd != (iconv_t)-1);
929 
930  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
931  if (ret < 0)
932  goto end;
933  ret = av_packet_copy_props(buf_pkt, inpkt);
934  if (ret < 0)
935  goto end;
936  outb = buf_pkt->data;
937  outl = buf_pkt->size;
938 
939  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
940  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
941  outl >= buf_pkt->size || inl != 0) {
942  ret = FFMIN(AVERROR(errno), -1);
943  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
944  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
945  goto end;
946  }
947  buf_pkt->size -= outl;
948  memset(buf_pkt->data + buf_pkt->size, 0, outl);
949  *outpkt = buf_pkt;
950 
951  ret = 0;
952 end:
953  if (ret < 0)
954  av_packet_unref(buf_pkt);
955  if (cd != (iconv_t)-1)
956  iconv_close(cd);
957  return ret;
958 #else
959  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
960  return AVERROR(EINVAL);
961 #endif
962 }
963 
964 static int utf8_check(const uint8_t *str)
965 {
966  const uint8_t *byte;
967  uint32_t codepoint, min;
968 
969  while (*str) {
970  byte = str;
971  GET_UTF8(codepoint, *(byte++), return 0;);
972  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
973  1 << (5 * (byte - str) - 4);
974  if (codepoint < min || codepoint >= 0x110000 ||
975  codepoint == 0xFFFE /* BOM */ ||
976  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
977  return 0;
978  str = byte;
979  }
980  return 1;
981 }
982 
984  int *got_sub_ptr, const AVPacket *avpkt)
985 {
986  int ret = 0;
987 
988  if (!avpkt->data && avpkt->size) {
989  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
990  return AVERROR(EINVAL);
991  }
992  if (!avctx->codec)
993  return AVERROR(EINVAL);
995  av_log(avctx, AV_LOG_ERROR, "Codec not subtitle decoder\n");
996  return AVERROR(EINVAL);
997  }
998 
999  *got_sub_ptr = 0;
1000  get_subtitle_defaults(sub);
1001 
1002  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
1003  AVCodecInternal *avci = avctx->internal;
1004  const AVPacket *pkt;
1005 
1006  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
1007  if (ret < 0)
1008  return ret;
1009 
1010  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
1011  sub->pts = av_rescale_q(avpkt->pts,
1012  avctx->pkt_timebase, AV_TIME_BASE_Q);
1013  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
1014  if (pkt == avci->buffer_pkt) // did we recode?
1015  av_packet_unref(avci->buffer_pkt);
1016  if (ret < 0) {
1017  *got_sub_ptr = 0;
1018  avsubtitle_free(sub);
1019  return ret;
1020  }
1021  av_assert1(!sub->num_rects || *got_sub_ptr);
1022 
1023  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1024  avctx->pkt_timebase.num) {
1025  AVRational ms = { 1, 1000 };
1026  sub->end_display_time = av_rescale_q(avpkt->duration,
1027  avctx->pkt_timebase, ms);
1028  }
1029 
1031  sub->format = 0;
1032  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1033  sub->format = 1;
1034 
1035  for (unsigned i = 0; i < sub->num_rects; i++) {
1037  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1038  av_log(avctx, AV_LOG_ERROR,
1039  "Invalid UTF-8 in decoded subtitles text; "
1040  "maybe missing -sub_charenc option\n");
1041  avsubtitle_free(sub);
1042  *got_sub_ptr = 0;
1043  return AVERROR_INVALIDDATA;
1044  }
1045  }
1046 
1047  if (*got_sub_ptr)
1048  avctx->frame_num++;
1049  }
1050 
1051  return ret;
1052 }
1053 
1055  const enum AVPixelFormat *fmt)
1056 {
1057  const AVPixFmtDescriptor *desc;
1058  const AVCodecHWConfig *config;
1059  int i, n;
1060 
1061  // If a device was supplied when the codec was opened, assume that the
1062  // user wants to use it.
1063  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
1064  AVHWDeviceContext *device_ctx =
1066  for (i = 0;; i++) {
1067  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
1068  if (!config)
1069  break;
1070  if (!(config->methods &
1072  continue;
1073  if (device_ctx->type != config->device_type)
1074  continue;
1075  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1076  if (config->pix_fmt == fmt[n])
1077  return fmt[n];
1078  }
1079  }
1080  }
1081  // No device or other setup, so we have to choose from things which
1082  // don't any other external information.
1083 
1084  // If the last element of the list is a software format, choose it
1085  // (this should be best software format if any exist).
1086  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1087  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1088  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1089  return fmt[n - 1];
1090 
1091  // Finally, traverse the list in order and choose the first entry
1092  // with no external dependencies (if there is no hardware configuration
1093  // information available then this just picks the first entry).
1094  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1095  for (i = 0;; i++) {
1096  config = avcodec_get_hw_config(avctx->codec, i);
1097  if (!config)
1098  break;
1099  if (config->pix_fmt == fmt[n])
1100  break;
1101  }
1102  if (!config) {
1103  // No specific config available, so the decoder must be able
1104  // to handle this format without any additional setup.
1105  return fmt[n];
1106  }
1107  if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1108  // Usable with only internal setup.
1109  return fmt[n];
1110  }
1111  }
1112 
1113  // Nothing is usable, give up.
1114  return AV_PIX_FMT_NONE;
1115 }
1116 
1118  enum AVHWDeviceType dev_type)
1119 {
1120  AVHWDeviceContext *device_ctx;
1121  AVHWFramesContext *frames_ctx;
1122  int ret;
1123 
1124  if (!avctx->hwaccel)
1125  return AVERROR(ENOSYS);
1126 
1127  if (avctx->hw_frames_ctx)
1128  return 0;
1129  if (!avctx->hw_device_ctx) {
1130  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1131  "required for hardware accelerated decoding.\n");
1132  return AVERROR(EINVAL);
1133  }
1134 
1135  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1136  if (device_ctx->type != dev_type) {
1137  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1138  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1139  av_hwdevice_get_type_name(device_ctx->type));
1140  return AVERROR(EINVAL);
1141  }
1142 
1144  avctx->hw_device_ctx,
1145  avctx->hwaccel->pix_fmt,
1146  &avctx->hw_frames_ctx);
1147  if (ret < 0)
1148  return ret;
1149 
1150  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1151 
1152 
1153  if (frames_ctx->initial_pool_size) {
1154  // We guarantee 4 base work surfaces. The function above guarantees 1
1155  // (the absolute minimum), so add the missing count.
1156  frames_ctx->initial_pool_size += 3;
1157  }
1158 
1160  if (ret < 0) {
1161  av_buffer_unref(&avctx->hw_frames_ctx);
1162  return ret;
1163  }
1164 
1165  return 0;
1166 }
1167 
1169  AVBufferRef *device_ref,
1171  AVBufferRef **out_frames_ref)
1172 {
1173  AVBufferRef *frames_ref = NULL;
1174  const AVCodecHWConfigInternal *hw_config;
1175  const FFHWAccel *hwa;
1176  int i, ret;
1177  bool clean_priv_data = false;
1178 
1179  for (i = 0;; i++) {
1180  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1181  if (!hw_config)
1182  return AVERROR(ENOENT);
1183  if (hw_config->public.pix_fmt == hw_pix_fmt)
1184  break;
1185  }
1186 
1187  hwa = hw_config->hwaccel;
1188  if (!hwa || !hwa->frame_params)
1189  return AVERROR(ENOENT);
1190 
1191  frames_ref = av_hwframe_ctx_alloc(device_ref);
1192  if (!frames_ref)
1193  return AVERROR(ENOMEM);
1194 
1195  if (!avctx->internal->hwaccel_priv_data) {
1196  avctx->internal->hwaccel_priv_data =
1197  av_mallocz(hwa->priv_data_size);
1198  if (!avctx->internal->hwaccel_priv_data) {
1199  av_buffer_unref(&frames_ref);
1200  return AVERROR(ENOMEM);
1201  }
1202  clean_priv_data = true;
1203  }
1204 
1205  ret = hwa->frame_params(avctx, frames_ref);
1206  if (ret >= 0) {
1207  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1208 
1209  if (frames_ctx->initial_pool_size) {
1210  // If the user has requested that extra output surfaces be
1211  // available then add them here.
1212  if (avctx->extra_hw_frames > 0)
1213  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1214 
1215  // If frame threading is enabled then an extra surface per thread
1216  // is also required.
1217  if (avctx->active_thread_type & FF_THREAD_FRAME)
1218  frames_ctx->initial_pool_size += avctx->thread_count;
1219  }
1220 
1221  *out_frames_ref = frames_ref;
1222  } else {
1223  if (clean_priv_data)
1225  av_buffer_unref(&frames_ref);
1226  }
1227  return ret;
1228 }
1229 
1230 static int hwaccel_init(AVCodecContext *avctx,
1231  const FFHWAccel *hwaccel)
1232 {
1233  int err;
1234 
1235  if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1237  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1238  hwaccel->p.name);
1239  return AVERROR_PATCHWELCOME;
1240  }
1241 
1242  if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1243  avctx->internal->hwaccel_priv_data =
1244  av_mallocz(hwaccel->priv_data_size);
1245  if (!avctx->internal->hwaccel_priv_data)
1246  return AVERROR(ENOMEM);
1247  }
1248 
1249  avctx->hwaccel = &hwaccel->p;
1250  if (hwaccel->init) {
1251  err = hwaccel->init(avctx);
1252  if (err < 0) {
1253  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1254  "hwaccel initialisation returned error.\n",
1255  av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1257  avctx->hwaccel = NULL;
1258  return err;
1259  }
1260  }
1261 
1262  return 0;
1263 }
1264 
1266 {
1267  if (FF_HW_HAS_CB(avctx, uninit))
1268  FF_HW_SIMPLE_CALL(avctx, uninit);
1269 
1271 
1272  avctx->hwaccel = NULL;
1273 
1274  av_buffer_unref(&avctx->hw_frames_ctx);
1275 }
1276 
1277 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1278 {
1279  const AVPixFmtDescriptor *desc;
1280  enum AVPixelFormat *choices;
1281  enum AVPixelFormat ret, user_choice;
1282  const AVCodecHWConfigInternal *hw_config;
1283  const AVCodecHWConfig *config;
1284  int i, n, err;
1285 
1286  // Find end of list.
1287  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1288  // Must contain at least one entry.
1289  av_assert0(n >= 1);
1290  // If a software format is available, it must be the last entry.
1291  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1292  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1293  // No software format is available.
1294  } else {
1295  avctx->sw_pix_fmt = fmt[n - 1];
1296  }
1297 
1298  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1299  if (!choices)
1300  return AV_PIX_FMT_NONE;
1301 
1302  for (;;) {
1303  // Remove the previous hwaccel, if there was one.
1304  ff_hwaccel_uninit(avctx);
1305 
1306  user_choice = avctx->get_format(avctx, choices);
1307  if (user_choice == AV_PIX_FMT_NONE) {
1308  // Explicitly chose nothing, give up.
1309  ret = AV_PIX_FMT_NONE;
1310  break;
1311  }
1312 
1313  desc = av_pix_fmt_desc_get(user_choice);
1314  if (!desc) {
1315  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1316  "get_format() callback.\n");
1317  ret = AV_PIX_FMT_NONE;
1318  break;
1319  }
1320  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1321  desc->name);
1322 
1323  for (i = 0; i < n; i++) {
1324  if (choices[i] == user_choice)
1325  break;
1326  }
1327  if (i == n) {
1328  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1329  "%s not in possible list.\n", desc->name);
1330  ret = AV_PIX_FMT_NONE;
1331  break;
1332  }
1333 
1334  if (ffcodec(avctx->codec)->hw_configs) {
1335  for (i = 0;; i++) {
1336  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1337  if (!hw_config)
1338  break;
1339  if (hw_config->public.pix_fmt == user_choice)
1340  break;
1341  }
1342  } else {
1343  hw_config = NULL;
1344  }
1345 
1346  if (!hw_config) {
1347  // No config available, so no extra setup required.
1348  ret = user_choice;
1349  break;
1350  }
1351  config = &hw_config->public;
1352 
1353  if (config->methods &
1355  avctx->hw_frames_ctx) {
1356  const AVHWFramesContext *frames_ctx =
1358  if (frames_ctx->format != user_choice) {
1359  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1360  "does not match the format of the provided frames "
1361  "context.\n", desc->name);
1362  goto try_again;
1363  }
1364  } else if (config->methods &
1366  avctx->hw_device_ctx) {
1367  const AVHWDeviceContext *device_ctx =
1369  if (device_ctx->type != config->device_type) {
1370  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1371  "does not match the type of the provided device "
1372  "context.\n", desc->name);
1373  goto try_again;
1374  }
1375  } else if (config->methods &
1377  // Internal-only setup, no additional configuration.
1378  } else if (config->methods &
1380  // Some ad-hoc configuration we can't see and can't check.
1381  } else {
1382  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1383  "missing configuration.\n", desc->name);
1384  goto try_again;
1385  }
1386  if (hw_config->hwaccel) {
1387  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel %s "
1388  "initialisation.\n", desc->name, hw_config->hwaccel->p.name);
1389  err = hwaccel_init(avctx, hw_config->hwaccel);
1390  if (err < 0)
1391  goto try_again;
1392  }
1393  ret = user_choice;
1394  break;
1395 
1396  try_again:
1397  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1398  "get_format() without it.\n", desc->name);
1399  for (i = 0; i < n; i++) {
1400  if (choices[i] == user_choice)
1401  break;
1402  }
1403  for (; i + 1 < n; i++)
1404  choices[i] = choices[i + 1];
1405  --n;
1406  }
1407 
1408  if (ret < 0)
1409  ff_hwaccel_uninit(avctx);
1410 
1411  av_freep(&choices);
1412  return ret;
1413 }
1414 
1415 static const AVPacketSideData*
1418 {
1419  for (int i = 0; i < nb_sd; i++)
1420  if (sd[i].type == type)
1421  return &sd[i];
1422 
1423  return NULL;
1424 }
1425 
1428 {
1430 }
1431 
1433  const AVPacketSideData *sd_pkt)
1434 {
1435  const AVStereo3D *src;
1436  AVStereo3D *dst;
1437  int ret;
1438 
1439  ret = av_buffer_make_writable(&sd_frame->buf);
1440  if (ret < 0)
1441  return ret;
1442  sd_frame->data = sd_frame->buf->data;
1443 
1444  dst = ( AVStereo3D*)sd_frame->data;
1445  src = (const AVStereo3D*)sd_pkt->data;
1446 
1447  if (dst->type == AV_STEREO3D_UNSPEC)
1448  dst->type = src->type;
1449 
1450  if (dst->view == AV_STEREO3D_VIEW_UNSPEC)
1451  dst->view = src->view;
1452 
1453  if (dst->primary_eye == AV_PRIMARY_EYE_NONE)
1454  dst->primary_eye = src->primary_eye;
1455 
1456  if (!dst->baseline)
1457  dst->baseline = src->baseline;
1458 
1459  if (!dst->horizontal_disparity_adjustment.num)
1460  dst->horizontal_disparity_adjustment = src->horizontal_disparity_adjustment;
1461 
1462  if (!dst->horizontal_field_of_view.num)
1463  dst->horizontal_field_of_view = src->horizontal_field_of_view;
1464 
1465  return 0;
1466 }
1467 
1469  const AVPacketSideData *sd_src, int nb_sd_src,
1470  const SideDataMap *map)
1471 
1472 {
1473  for (int i = 0; map[i].packet < AV_PKT_DATA_NB; i++) {
1474  const enum AVPacketSideDataType type_pkt = map[i].packet;
1475  const enum AVFrameSideDataType type_frame = map[i].frame;
1476  const AVPacketSideData *sd_pkt;
1477  AVFrameSideData *sd_frame;
1478 
1479  sd_pkt = packet_side_data_get(sd_src, nb_sd_src, type_pkt);
1480  if (!sd_pkt)
1481  continue;
1482 
1483  sd_frame = av_frame_get_side_data(dst, type_frame);
1484  if (sd_frame) {
1485  if (type_frame == AV_FRAME_DATA_STEREO3D) {
1486  int ret = side_data_stereo3d_merge(sd_frame, sd_pkt);
1487  if (ret < 0)
1488  return ret;
1489  }
1490 
1491  continue;
1492  }
1493 
1494  sd_frame = av_frame_new_side_data(dst, type_frame, sd_pkt->size);
1495  if (!sd_frame)
1496  return AVERROR(ENOMEM);
1497 
1498  memcpy(sd_frame->data, sd_pkt->data, sd_pkt->size);
1499  }
1500 
1501  return 0;
1502 }
1503 
1505 {
1506  size_t size;
1507  const uint8_t *side_metadata;
1508 
1509  AVDictionary **frame_md = &frame->metadata;
1510 
1511  side_metadata = av_packet_get_side_data(avpkt,
1513  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1514 }
1515 
1517  AVFrame *frame, const AVPacket *pkt)
1518 {
1519  static const SideDataMap sd[] = {
1526  { AV_PKT_DATA_NB }
1527  };
1528 
1529  int ret = 0;
1530 
1531  frame->pts = pkt->pts;
1532  frame->duration = pkt->duration;
1533 #if FF_API_FRAME_PKT
1535  frame->pkt_pos = pkt->pos;
1536  frame->pkt_size = pkt->size;
1538 #endif
1539 
1541  if (ret < 0)
1542  return ret;
1543 
1545  if (ret < 0)
1546  return ret;
1547 
1549 
1550  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1551  frame->flags |= AV_FRAME_FLAG_DISCARD;
1552  }
1553 
1554  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1555  int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1556  if (ret < 0)
1557  return ret;
1558  frame->opaque = pkt->opaque;
1559  }
1560 
1561  return 0;
1562 }
1563 
1565 {
1566  int ret;
1567 
1570  if (ret < 0)
1571  return ret;
1572 
1574  const AVPacket *pkt = avctx->internal->last_pkt_props;
1575 
1577  if (ret < 0)
1578  return ret;
1579 #if FF_API_FRAME_PKT
1581  frame->pkt_size = pkt->stream_index;
1583 #endif
1584  }
1585 
1586  ret = fill_frame_props(avctx, frame);
1587  if (ret < 0)
1588  return ret;
1589 
1590  switch (avctx->codec->type) {
1591  case AVMEDIA_TYPE_VIDEO:
1592  if (frame->width && frame->height &&
1593  av_image_check_sar(frame->width, frame->height,
1594  frame->sample_aspect_ratio) < 0) {
1595  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1596  frame->sample_aspect_ratio.num,
1597  frame->sample_aspect_ratio.den);
1598  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1599  }
1600  break;
1601  }
1602  return 0;
1603 }
1604 
1606 {
1607  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1608  int i;
1609  int num_planes = av_pix_fmt_count_planes(frame->format);
1611  int flags = desc ? desc->flags : 0;
1612  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1613  num_planes = 2;
1614  for (i = 0; i < num_planes; i++) {
1615  av_assert0(frame->data[i]);
1616  }
1617  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1618  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1619  if (frame->data[i])
1620  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1621  frame->data[i] = NULL;
1622  }
1623  }
1624 }
1625 
1626 static void decode_data_free(void *opaque, uint8_t *data)
1627 {
1629 
1630  if (fdd->post_process_opaque_free)
1632 
1633  if (fdd->hwaccel_priv_free)
1634  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1635 
1636  av_freep(&fdd);
1637 }
1638 
1640 {
1641  AVBufferRef *fdd_buf;
1642  FrameDecodeData *fdd;
1643 
1644  av_assert1(!frame->private_ref);
1645  av_buffer_unref(&frame->private_ref);
1646 
1647  fdd = av_mallocz(sizeof(*fdd));
1648  if (!fdd)
1649  return AVERROR(ENOMEM);
1650 
1651  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1653  if (!fdd_buf) {
1654  av_freep(&fdd);
1655  return AVERROR(ENOMEM);
1656  }
1657 
1658  frame->private_ref = fdd_buf;
1659 
1660  return 0;
1661 }
1662 
1664 {
1665  AVCodecInternal *avci = avctx->internal;
1666  DecodeContext *dc = decode_ctx(avci);
1667 
1668  dc->lcevc_frame = dc->lcevc && avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1670 
1671  if (dc->lcevc_frame) {
1672  dc->width = frame->width;
1673  dc->height = frame->height;
1674  frame->width = frame->width * 2 / FFMAX(frame->sample_aspect_ratio.den, 1);
1675  frame->height = frame->height * 2 / FFMAX(frame->sample_aspect_ratio.num, 1);
1676  }
1677 }
1678 
1680 {
1681  AVCodecInternal *avci = avctx->internal;
1682  DecodeContext *dc = decode_ctx(avci);
1683 
1684  if (dc->lcevc_frame) {
1685  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
1686 
1687  fdd->post_process_opaque = ff_refstruct_ref(dc->lcevc);
1690 
1691  frame->width = dc->width;
1692  frame->height = dc->height;
1693  }
1694  dc->lcevc_frame = 0;
1695 }
1696 
1698 {
1699  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1700  int override_dimensions = 1;
1701  int ret;
1702 
1704 
1705  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1706  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1707  (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) {
1708  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1709  ret = AVERROR(EINVAL);
1710  goto fail;
1711  }
1712 
1713  if (frame->width <= 0 || frame->height <= 0) {
1714  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1715  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1716  override_dimensions = 0;
1717  }
1718 
1719  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1720  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1721  ret = AVERROR(EINVAL);
1722  goto fail;
1723  }
1724  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1725  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1726  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1727  ret = AVERROR(EINVAL);
1728  goto fail;
1729  }
1730  }
1731  ret = ff_decode_frame_props(avctx, frame);
1732  if (ret < 0)
1733  goto fail;
1734 
1735  if (hwaccel) {
1736  if (hwaccel->alloc_frame) {
1737  ret = hwaccel->alloc_frame(avctx, frame);
1738  goto end;
1739  }
1740  } else {
1741  avctx->sw_pix_fmt = avctx->pix_fmt;
1742  update_frame_props(avctx, frame);
1743  }
1744 
1745  ret = avctx->get_buffer2(avctx, frame, flags);
1746  if (ret < 0)
1747  goto fail;
1748 
1750 
1752  if (ret < 0)
1753  goto fail;
1754 
1756 
1757 end:
1758  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1760  frame->width = avctx->width;
1761  frame->height = avctx->height;
1762  }
1763 
1764 fail:
1765  if (ret < 0) {
1766  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1768  }
1769 
1770  return ret;
1771 }
1772 
1774 {
1775  AVFrame *tmp;
1776  int ret;
1777 
1779 
1780  // make sure the discard flag does not persist
1781  frame->flags &= ~AV_FRAME_FLAG_DISCARD;
1782 
1783  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1784  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1785  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1787  }
1788 
1789  if (!frame->data[0])
1790  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1791 
1792  av_frame_side_data_free(&frame->side_data, &frame->nb_side_data);
1793 
1795  return ff_decode_frame_props(avctx, frame);
1796 
1797  tmp = av_frame_alloc();
1798  if (!tmp)
1799  return AVERROR(ENOMEM);
1800 
1802 
1804  if (ret < 0) {
1805  av_frame_free(&tmp);
1806  return ret;
1807  }
1808 
1810  av_frame_free(&tmp);
1811 
1812  return 0;
1813 }
1814 
1816 {
1817  int ret = reget_buffer_internal(avctx, frame, flags);
1818  if (ret < 0)
1819  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1820  return ret;
1821 }
1822 
1823 typedef struct ProgressInternal {
1825  struct AVFrame *f;
1827 
1829 {
1830  av_assert1(!!f->f == !!f->progress);
1831  av_assert1(!f->progress || f->progress->f == f->f);
1832 }
1833 
1835 {
1837 
1838  av_assert1(!f->f && !f->progress);
1839 
1840  f->progress = ff_refstruct_pool_get(pool);
1841  if (!f->progress)
1842  return AVERROR(ENOMEM);
1843 
1844  f->f = f->progress->f;
1845  return 0;
1846 }
1847 
1849 {
1850  int ret;
1851 
1853  if (!f->f) {
1854  ret = ff_progress_frame_alloc(avctx, f);
1855  if (ret < 0)
1856  return ret;
1857  }
1858 
1859  ret = ff_thread_get_buffer(avctx, f->progress->f, flags);
1860  if (ret < 0) {
1861  f->f = NULL;
1862  ff_refstruct_unref(&f->progress);
1863  return ret;
1864  }
1865  return 0;
1866 }
1867 
1869 {
1870  av_assert1(src->progress && src->f && src->f == src->progress->f);
1871  av_assert1(!dst->f && !dst->progress);
1872  dst->f = src->f;
1873  dst->progress = ff_refstruct_ref(src->progress);
1874 }
1875 
1877 {
1879  f->f = NULL;
1880  ff_refstruct_unref(&f->progress);
1881 }
1882 
1884 {
1885  if (dst == src)
1886  return;
1889  if (src->f)
1891 }
1892 
1894 {
1895  ff_thread_progress_report(&f->progress->progress, n);
1896 }
1897 
1899 {
1900  ff_thread_progress_await(&f->progress->progress, n);
1901 }
1902 
1903 #if !HAVE_THREADS
1905 {
1907 }
1908 #endif /* !HAVE_THREADS */
1909 
1911 {
1912  const AVCodecContext *avctx = opaque.nc;
1913  ProgressInternal *progress = obj;
1914  int ret;
1915 
1917  if (ret < 0)
1918  return ret;
1919 
1920  progress->f = av_frame_alloc();
1921  if (!progress->f)
1922  return AVERROR(ENOMEM);
1923 
1924  return 0;
1925 }
1926 
1927 static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
1928 {
1929  ProgressInternal *progress = obj;
1930 
1931  ff_thread_progress_reset(&progress->progress);
1932  av_frame_unref(progress->f);
1933 }
1934 
1936 {
1937  ProgressInternal *progress = obj;
1938 
1940  av_frame_free(&progress->f);
1941 }
1942 
1944 {
1945  AVCodecInternal *avci = avctx->internal;
1946  DecodeContext *dc = decode_ctx(avci);
1947  int ret = 0;
1948 
1949  dc->initial_pict_type = AV_PICTURE_TYPE_NONE;
1951  dc->intra_only_flag = AV_FRAME_FLAG_KEY;
1952  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
1953  dc->initial_pict_type = AV_PICTURE_TYPE_I;
1954  }
1955 
1956  /* if the decoder init function was already called previously,
1957  * free the already allocated subtitle_header before overwriting it */
1958  av_freep(&avctx->subtitle_header);
1959 
1960  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1961  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1962  avctx->codec->max_lowres);
1963  avctx->lowres = avctx->codec->max_lowres;
1964  }
1965  if (avctx->sub_charenc) {
1966  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1967  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1968  "supported with subtitles codecs\n");
1969  return AVERROR(EINVAL);
1970  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1971  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1972  "subtitles character encoding will be ignored\n",
1973  avctx->codec_descriptor->name);
1975  } else {
1976  /* input character encoding is set for a text based subtitle
1977  * codec at this point */
1980 
1982 #if CONFIG_ICONV
1983  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1984  if (cd == (iconv_t)-1) {
1985  ret = AVERROR(errno);
1986  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1987  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1988  return ret;
1989  }
1990  iconv_close(cd);
1991 #else
1992  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1993  "conversion needs a libavcodec built with iconv support "
1994  "for this codec\n");
1995  return AVERROR(ENOSYS);
1996 #endif
1997  }
1998  }
1999  }
2000 
2001  dc->pts_correction_num_faulty_pts =
2002  dc->pts_correction_num_faulty_dts = 0;
2003  dc->pts_correction_last_pts =
2004  dc->pts_correction_last_dts = INT64_MIN;
2005 
2006  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
2008  av_log(avctx, AV_LOG_WARNING,
2009  "gray decoding requested but not enabled at configuration time\n");
2010  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
2012  }
2013 
2014  if (avctx->nb_side_data_prefer_packet == 1 &&
2015  avctx->side_data_prefer_packet[0] == -1)
2016  dc->side_data_pref_mask = ~0ULL;
2017  else {
2018  for (unsigned i = 0; i < avctx->nb_side_data_prefer_packet; i++) {
2019  int val = avctx->side_data_prefer_packet[i];
2020 
2021  if (val < 0 || val >= AV_PKT_DATA_NB) {
2022  av_log(avctx, AV_LOG_ERROR, "Invalid side data type: %d\n", val);
2023  return AVERROR(EINVAL);
2024  }
2025 
2026  for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
2027  if (ff_sd_global_map[j].packet == val) {
2028  val = ff_sd_global_map[j].frame;
2029 
2030  // this code will need to be changed when we have more than
2031  // 64 frame side data types
2032  if (val >= 64) {
2033  av_log(avctx, AV_LOG_ERROR, "Side data type too big\n");
2034  return AVERROR_BUG;
2035  }
2036 
2037  dc->side_data_pref_mask |= 1ULL << val;
2038  }
2039  }
2040  }
2041  }
2042 
2043  avci->in_pkt = av_packet_alloc();
2044  avci->last_pkt_props = av_packet_alloc();
2045  if (!avci->in_pkt || !avci->last_pkt_props)
2046  return AVERROR(ENOMEM);
2047 
2049  avci->progress_frame_pool =
2055  if (!avci->progress_frame_pool)
2056  return AVERROR(ENOMEM);
2057  }
2058  ret = decode_bsfs_init(avctx);
2059  if (ret < 0)
2060  return ret;
2061 
2063  ret = ff_lcevc_alloc(&dc->lcevc);
2064  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
2065  return ret;
2066  }
2067 
2068 #if FF_API_DROPCHANGED
2069  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED)
2070  av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n");
2071 #endif
2072 
2073  return 0;
2074 }
2075 
2076 /**
2077  * Check side data preference and clear existing side data from frame
2078  * if needed.
2079  *
2080  * @retval 0 side data of this type can be added to frame
2081  * @retval 1 side data of this type should not be added to frame
2082  */
2083 static int side_data_pref(const AVCodecContext *avctx, AVFrameSideData ***sd,
2084  int *nb_sd, enum AVFrameSideDataType type)
2085 {
2086  DecodeContext *dc = decode_ctx(avctx->internal);
2087 
2088  // Note: could be skipped for `type` without corresponding packet sd
2089  if (av_frame_side_data_get(*sd, *nb_sd, type)) {
2090  if (dc->side_data_pref_mask & (1ULL << type))
2091  return 1;
2092  av_frame_side_data_remove(sd, nb_sd, type);
2093  }
2094 
2095  return 0;
2096 }
2097 
2098 
2100  enum AVFrameSideDataType type, size_t size,
2101  AVFrameSideData **psd)
2102 {
2103  AVFrameSideData *sd;
2104 
2105  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data, type)) {
2106  if (psd)
2107  *psd = NULL;
2108  return 0;
2109  }
2110 
2112  if (psd)
2113  *psd = sd;
2114 
2115  return sd ? 0 : AVERROR(ENOMEM);
2116 }
2117 
2119  AVFrameSideData ***sd, int *nb_sd,
2121  AVBufferRef **buf)
2122 {
2123  int ret = 0;
2124 
2125  if (side_data_pref(avctx, sd, nb_sd, type))
2126  goto finish;
2127 
2128  if (!av_frame_side_data_add(sd, nb_sd, type, buf, 0))
2129  ret = AVERROR(ENOMEM);
2130 
2131 finish:
2133 
2134  return ret;
2135 }
2136 
2139  AVBufferRef **buf)
2140 {
2142  &frame->side_data, &frame->nb_side_data,
2143  type, buf);
2144 }
2145 
2147  AVFrameSideData ***sd, int *nb_sd,
2148  struct AVMasteringDisplayMetadata **mdm)
2149 {
2150  AVBufferRef *buf;
2151  size_t size;
2152 
2154  *mdm = NULL;
2155  return 0;
2156  }
2157 
2159  if (!*mdm)
2160  return AVERROR(ENOMEM);
2161 
2162  buf = av_buffer_create((uint8_t *)*mdm, size, NULL, NULL, 0);
2163  if (!buf) {
2164  av_freep(mdm);
2165  return AVERROR(ENOMEM);
2166  }
2167 
2169  &buf, 0)) {
2170  *mdm = NULL;
2171  av_buffer_unref(&buf);
2172  return AVERROR(ENOMEM);
2173  }
2174 
2175  return 0;
2176 }
2177 
2180 {
2181  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2183  *mdm = NULL;
2184  return 0;
2185  }
2186 
2188  return *mdm ? 0 : AVERROR(ENOMEM);
2189 }
2190 
2192  AVFrameSideData ***sd, int *nb_sd,
2193  AVContentLightMetadata **clm)
2194 {
2195  AVBufferRef *buf;
2196  size_t size;
2197 
2198  if (side_data_pref(avctx, sd, nb_sd, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL)) {
2199  *clm = NULL;
2200  return 0;
2201  }
2202 
2204  if (!*clm)
2205  return AVERROR(ENOMEM);
2206 
2207  buf = av_buffer_create((uint8_t *)*clm, size, NULL, NULL, 0);
2208  if (!buf) {
2209  av_freep(clm);
2210  return AVERROR(ENOMEM);
2211  }
2212 
2214  &buf, 0)) {
2215  *clm = NULL;
2216  av_buffer_unref(&buf);
2217  return AVERROR(ENOMEM);
2218  }
2219 
2220  return 0;
2221 }
2222 
2224  AVContentLightMetadata **clm)
2225 {
2226  if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2228  *clm = NULL;
2229  return 0;
2230  }
2231 
2233  return *clm ? 0 : AVERROR(ENOMEM);
2234 }
2235 
2236 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2237 {
2238  size_t size;
2239  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2240 
2241  if (pal && size == AVPALETTE_SIZE) {
2242  memcpy(dst, pal, AVPALETTE_SIZE);
2243  return 1;
2244  } else if (pal) {
2245  av_log(logctx, AV_LOG_ERROR,
2246  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
2247  }
2248  return 0;
2249 }
2250 
2251 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
2252 {
2253  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
2254 
2255  if (!hwaccel || !hwaccel->frame_priv_data_size)
2256  return 0;
2257 
2258  av_assert0(!*hwaccel_picture_private);
2259 
2260  if (hwaccel->free_frame_priv) {
2261  AVHWFramesContext *frames_ctx;
2262 
2263  if (!avctx->hw_frames_ctx)
2264  return AVERROR(EINVAL);
2265 
2266  frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
2267  *hwaccel_picture_private = ff_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
2268  frames_ctx->device_ctx,
2269  hwaccel->free_frame_priv);
2270  } else {
2271  *hwaccel_picture_private = ff_refstruct_allocz(hwaccel->frame_priv_data_size);
2272  }
2273 
2274  if (!*hwaccel_picture_private)
2275  return AVERROR(ENOMEM);
2276 
2277  return 0;
2278 }
2279 
2281 {
2282  AVCodecInternal *avci = avctx->internal;
2283  DecodeContext *dc = decode_ctx(avci);
2284 
2286  av_packet_unref(avci->in_pkt);
2287 
2288  dc->pts_correction_last_pts =
2289  dc->pts_correction_last_dts = INT64_MIN;
2290 
2291  if (avci->bsf)
2292  av_bsf_flush(avci->bsf);
2293 
2294  dc->nb_draining_errors = 0;
2295  dc->draining_started = 0;
2296 }
2297 
2299 {
2300  return av_mallocz(sizeof(DecodeContext));
2301 }
2302 
2304 {
2305  const DecodeContext *src_dc = decode_ctx(src->internal);
2306  DecodeContext *dst_dc = decode_ctx(dst->internal);
2307 
2308  ff_refstruct_replace(&dst_dc->lcevc, src_dc->lcevc);
2309 }
2310 
2312 {
2313  AVCodecInternal *avci = avctx->internal;
2314  DecodeContext *dc = decode_ctx(avci);
2315 
2316  ff_refstruct_unref(&dc->lcevc);
2317 }
lcevcdec.h
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:1426
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:2238
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:153
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:1893
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:429
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1437
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:208
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:1230
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:248
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
progress_frame_pool_reset_cb
static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
Definition: decode.c:1927
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
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2243
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:793
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:691
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:611
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1277
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:761
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:1056
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:963
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:811
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:3170
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:304
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:2139
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:601
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
AVPictureType
AVPictureType
Definition: avutil.h:277
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:125
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1430
AV_CODEC_FLAG_UNALIGNED
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e....
Definition: avcodec.h:220
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1872
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:1926
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
int64_t
long long int64_t
Definition: coverity.c:34
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2242
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:605
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:162
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:537
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:33
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
DecodeContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: decode.c:87
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
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:684
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
FFHWAccel::frame_params
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
Definition: hwaccel_internal.h:144
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
FFLCEVCContext
Definition: lcevcdec.h:32
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
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:1848
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:1902
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:616
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:52
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
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:1890
AVDictionary
Definition: dict.c:34
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:586
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1054
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:708
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:327
ff_thread_receive_frame
#define ff_thread_receive_frame(avctx, frame)
Definition: decode.c:220
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:602
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:94
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:1889
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:1078
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:333
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:1265
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
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:223
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:207
AVPacketSideData::size
size_t size
Definition: packet.h:392
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3210
AVCodecInternal::progress_frame_pool
struct FFRefStructPool * progress_frame_pool
Definition: internal.h:71
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:299
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:290
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
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:575
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:46
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
fail
#define fail()
Definition: checkasm.h:189
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:1593
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
AV_FRAME_CROP_UNALIGNED
@ AV_FRAME_CROP_UNALIGNED
Apply the maximum possible cropping, even if it requires setting the AVFrame.data[] entries to unalig...
Definition: frame.h:1015
ff_lcevc_process
int ff_lcevc_process(void *logctx, AVFrame *frame)
Definition: lcevcdec.c:277
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:1888
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
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:1516
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:326
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:1504
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1988
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:2235
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:2137
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:342
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
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:1232
FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR
#define FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR
If this flag is set and both init_cb and free_entry_cb callbacks are provided, then free_cb will be c...
Definition: refstruct.h:213
GET_UTF8
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h: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:983
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:2191
AV_CODEC_FLAG_DROPCHANGED
#define AV_CODEC_FLAG_DROPCHANGED
Don't output frames whose parameters differ from first decoded frame in stream.
Definition: avcodec.h:244
avassert.h
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:69
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
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:815
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:729
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:1868
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:617
AVCodecContext::side_data_prefer_packet
int * side_data_prefer_packet
Decoding only.
Definition: avcodec.h:2071
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:2251
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:896
FrameDecodeData::post_process_opaque
void * post_process_opaque
Definition: decode.h:45
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1605
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:112
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:431
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:1049
AVERROR_INPUT_CHANGED
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
Definition: error.h:75
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
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:1876
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:354
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2244
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:1945
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:112
FFRefStructPool
FFRefStructPool is an API for a thread-safe pool of objects managed via the RefStruct API.
Definition: refstruct.c:183
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
ProgressInternal
Definition: decode.c:1823
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
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:1828
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:191
discard_samples
static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:316
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1626
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:1117
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:2178
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:219
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecInternal::changed_frames_dropped
int changed_frames_dropped
Definition: internal.h:150
AVCodecContext::sub_charenc
char * sub_charenc
Character encoding of the input subtitles file.
Definition: avcodec.h:1879
ff_decode_internal_alloc
AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:2298
AV_CODEC_FLAG2_SKIP_MANUAL
#define AV_CODEC_FLAG2_SKIP_MANUAL
Do not skip samples and export skip information as frame side data.
Definition: avcodec.h:388
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:65
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:149
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:964
update_frame_props
static void update_frame_props(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1663
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:2280
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1972
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
hwaccel_internal.h
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1927
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
av_frame_side_data_remove
void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type from an array.
Definition: frame.c:957
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:316
AV_CODEC_PROP_BITMAP_SUB
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: codec_desc.h:103
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
AVCodecInternal::initial_height
int initial_height
Definition: internal.h:152
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:398
ff_icc_profile_detect_transfer
int ff_icc_profile_detect_transfer(FFIccContext *s, cmsHPROFILE profile, enum AVColorTransferCharacteristic *out_trc)
Attempt detecting the transfer characteristic that best approximates the transfer function encoded by...
Definition: fflcms2.c:302
AV_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:313
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:437
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:177
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:902
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:683
AV_CODEC_EXPORT_DATA_ENHANCEMENTS
#define AV_CODEC_EXPORT_DATA_ENHANCEMENTS
Decoding only.
Definition: avcodec.h:426
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
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1865
f
f
Definition: af_crystalizer.c:122
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:515
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
SideDataMap::packet
enum AVPacketSideDataType packet
Definition: avcodec_internal.h:35
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:540
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:1834
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:1530
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
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:1015
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:296
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
FF_CODEC_CAP_SETS_FRAME_PROPS
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
Definition: codec_internal.h:78
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:151
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:84
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
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:557
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:61
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:789
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:2099
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:2118
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:2083
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:330
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:661
fill_frame_props
static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:572
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:737
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:2241
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:349
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:1029
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
ProgressInternal::progress
ThreadProgress progress
Definition: decode.c:1824
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:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
ff_progress_frame_await
void ff_progress_frame_await(const ProgressFrame *f, int n)
Wait for earlier decoding threads to finish reference frames.
Definition: decode.c:1898
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:259
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:1416
AVCodecContext::nb_side_data_prefer_packet
unsigned nb_side_data_prefer_packet
Number of entries in side_data_prefer_packet.
Definition: avcodec.h:2075
detect_colorspace
static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: decode.c:566
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:807
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1604
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
av_mastering_display_metadata_alloc_size
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc_size(size_t *size)
Allocate an AVMasteringDisplayMetadata structure and set its fields to default values.
Definition: mastering_display_metadata.c:44
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2105
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:728
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:392
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:2239
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:532
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: frame.c:113
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:152
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1773
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
attach_post_process_data
static void attach_post_process_data(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1679
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:657
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:621
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:1943
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:649
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
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:1507
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:708
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:50
profile
int profile
Definition: mxfenc.c:2233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCodecContext::height
int height
Definition: avcodec.h:624
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:414
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
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:1485
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:199
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1887
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2041
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:1168
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:1815
ret
ret
Definition: filter_design.txt:187
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:72
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:134
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
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:781
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:1904
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
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:2223
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:550
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:1883
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
progress_frame_pool_init_cb
static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj)
Definition: decode.c:1910
progress_frame_pool_free_entry_cb
static av_cold void progress_frame_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj)
Definition: decode.c:1935
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:1564
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:451
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1612
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, const AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:903
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_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ff_refstruct_pool_alloc_ext
static FFRefStructPool * ff_refstruct_pool_alloc_ext(size_t size, unsigned flags, void *opaque, int(*init_cb)(FFRefStructOpaque opaque, void *obj), void(*reset_cb)(FFRefStructOpaque opaque, void *obj), void(*free_entry_cb)(FFRefStructOpaque opaque, void *obj), void(*free_cb)(FFRefStructOpaque opaque))
A wrapper around ff_refstruct_pool_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:258
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
side_data_stereo3d_merge
static int side_data_stereo3d_merge(AVFrameSideData *sd_frame, const AVPacketSideData *sd_pkt)
Definition: decode.c:1432
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:1937
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:1825
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:149
AVPacket::stream_index
int stream_index
Definition: packet.h:541
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:833
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:118
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:447
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:250
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:187
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
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:644
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:2146
side_data_map
static int side_data_map(AVFrame *dst, const AVPacketSideData *sd_src, int nb_sd_src, const SideDataMap *map)
Definition: decode.c:1468
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:2311
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:406
ff_icc_profile_sanitize
int ff_icc_profile_sanitize(FFIccContext *s, cmsHPROFILE profile)
Sanitize an ICC profile to try and fix badly broken values.
Definition: fflcms2.c:213
mastering_display_metadata.h
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1639
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:154
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:384
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:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
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:1159
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
bytestream.h
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:345
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:670
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:2236
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:183
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:2126
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:648
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 **pbuf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: frame.c:862
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_refstruct_pool_get
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
ff_decode_internal_sync
void ff_decode_internal_sync(AVCodecContext *dst, const AVCodecContext *src)
Definition: decode.c:2303
Frame::height
int height
Definition: ffplay.c:160
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:551
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:3090
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:1891
min
float min
Definition: vorbis_enc_data.h:429