FFmpeg
decode.c
Go to the documentation of this file.
1 /*
2  * generic decoding-related code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 #include <string.h>
23 
24 #include "config.h"
25 
26 #if CONFIG_ICONV
27 # include <iconv.h>
28 #endif
29 
30 #include "libavutil/avassert.h"
32 #include "libavutil/common.h"
33 #include "libavutil/emms.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
39 
40 #include "avcodec.h"
41 #include "avcodec_internal.h"
42 #include "bytestream.h"
43 #include "bsf.h"
44 #include "codec_desc.h"
45 #include "codec_internal.h"
46 #include "decode.h"
47 #include "hwaccel_internal.h"
48 #include "hwconfig.h"
49 #include "internal.h"
50 #include "packet_internal.h"
51 #include "refstruct.h"
52 #include "thread.h"
53 
54 typedef struct DecodeContext {
56 
57  /* to prevent infinite loop on errors when draining */
59 
60  /**
61  * The caller has submitted a NULL packet on input.
62  */
64 
65  int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
66  int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
67  int64_t pts_correction_last_pts; /// PTS of the last frame
68  int64_t pts_correction_last_dts; /// DTS of the last frame
69 
70  /**
71  * Bitmask indicating for which side data types we prefer user-supplied
72  * (global or attached to packets) side data over bytestream.
73  */
76 
78 {
79  return (DecodeContext *)avci;
80 }
81 
82 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
83 {
84  int ret;
85  size_t size;
86  const uint8_t *data;
87  uint32_t flags;
88  int64_t val;
89 
91  if (!data)
92  return 0;
93 
94  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
95  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
96  "changes, but PARAM_CHANGE side data was sent to it.\n");
97  ret = AVERROR(EINVAL);
98  goto fail2;
99  }
100 
101  if (size < 4)
102  goto fail;
103 
104  flags = bytestream_get_le32(&data);
105  size -= 4;
106 
108  if (size < 4)
109  goto fail;
110  val = bytestream_get_le32(&data);
111  if (val <= 0 || val > INT_MAX) {
112  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
114  goto fail2;
115  }
116  avctx->sample_rate = val;
117  size -= 4;
118  }
120  if (size < 8)
121  goto fail;
122  avctx->width = bytestream_get_le32(&data);
123  avctx->height = bytestream_get_le32(&data);
124  size -= 8;
125  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
126  if (ret < 0)
127  goto fail2;
128  }
129 
130  return 0;
131 fail:
132  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
134 fail2:
135  if (ret < 0) {
136  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
137  if (avctx->err_recognition & AV_EF_EXPLODE)
138  return ret;
139  }
140  return 0;
141 }
142 
144 {
145  int ret = 0;
146 
148  if (pkt) {
150 #if FF_API_FRAME_PKT
151  if (!ret)
152  avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props().
153 #endif
154  }
155  return ret;
156 }
157 
159 {
160  AVCodecInternal *avci = avctx->internal;
161  const FFCodec *const codec = ffcodec(avctx->codec);
162  int ret;
163 
164  if (avci->bsf)
165  return 0;
166 
167  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
168  if (ret < 0) {
169  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
170  if (ret != AVERROR(ENOMEM))
171  ret = AVERROR_BUG;
172  goto fail;
173  }
174 
175  /* We do not currently have an API for passing the input timebase into decoders,
176  * but no filters used here should actually need it.
177  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
178  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
180  if (ret < 0)
181  goto fail;
182 
183  ret = av_bsf_init(avci->bsf);
184  if (ret < 0)
185  goto fail;
186 
187  return 0;
188 fail:
189  av_bsf_free(&avci->bsf);
190  return ret;
191 }
192 
194 {
195  AVCodecInternal *avci = avctx->internal;
196  int ret;
197 
198  ret = av_bsf_receive_packet(avci->bsf, pkt);
199  if (ret == AVERROR_EOF)
200  avci->draining = 1;
201  if (ret < 0)
202  return ret;
203 
206  if (ret < 0)
207  goto finish;
208  }
209 
210  ret = apply_param_change(avctx, pkt);
211  if (ret < 0)
212  goto finish;
213 
214  return 0;
215 finish:
217  return ret;
218 }
219 
221 {
222  AVCodecInternal *avci = avctx->internal;
223  DecodeContext *dc = decode_ctx(avci);
224 
225  if (avci->draining)
226  return AVERROR_EOF;
227 
228  while (1) {
229  int ret = decode_get_packet(avctx, pkt);
230  if (ret == AVERROR(EAGAIN) &&
231  (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
232  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
233  if (ret < 0) {
235  return ret;
236  }
237 
238  continue;
239  }
240 
241  return ret;
242  }
243 }
244 
245 /**
246  * Attempt to guess proper monotonic timestamps for decoded video frames
247  * which might have incorrect times. Input timestamps may wrap around, in
248  * which case the output will as well.
249  *
250  * @param pts the pts field of the decoded AVPacket, as passed through
251  * AVFrame.pts
252  * @param dts the dts field of the decoded AVPacket
253  * @return one of the input values, may be AV_NOPTS_VALUE
254  */
256  int64_t reordered_pts, int64_t dts)
257 {
258  int64_t pts = AV_NOPTS_VALUE;
259 
260  if (dts != AV_NOPTS_VALUE) {
261  dc->pts_correction_num_faulty_dts += dts <= dc->pts_correction_last_dts;
262  dc->pts_correction_last_dts = dts;
263  } else if (reordered_pts != AV_NOPTS_VALUE)
264  dc->pts_correction_last_dts = reordered_pts;
265 
266  if (reordered_pts != AV_NOPTS_VALUE) {
267  dc->pts_correction_num_faulty_pts += reordered_pts <= dc->pts_correction_last_pts;
268  dc->pts_correction_last_pts = reordered_pts;
269  } else if(dts != AV_NOPTS_VALUE)
270  dc->pts_correction_last_pts = dts;
271 
272  if ((dc->pts_correction_num_faulty_pts<=dc->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
273  && reordered_pts != AV_NOPTS_VALUE)
274  pts = reordered_pts;
275  else
276  pts = dts;
277 
278  return pts;
279 }
280 
281 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
282 {
283  AVCodecInternal *avci = avctx->internal;
284  AVFrameSideData *side;
285  uint32_t discard_padding = 0;
286  uint8_t skip_reason = 0;
287  uint8_t discard_reason = 0;
288 
290  if (side && side->size >= 10) {
291  avci->skip_samples = AV_RL32(side->data);
292  avci->skip_samples = FFMAX(0, avci->skip_samples);
293  discard_padding = AV_RL32(side->data + 4);
294  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
295  avci->skip_samples, (int)discard_padding);
296  skip_reason = AV_RL8(side->data + 8);
297  discard_reason = AV_RL8(side->data + 9);
298  }
299 
300  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
301  if (!side && (avci->skip_samples || discard_padding))
303  if (side && (avci->skip_samples || discard_padding)) {
304  AV_WL32(side->data, avci->skip_samples);
305  AV_WL32(side->data + 4, discard_padding);
306  AV_WL8(side->data + 8, skip_reason);
307  AV_WL8(side->data + 9, discard_reason);
308  avci->skip_samples = 0;
309  }
310  return 0;
311  }
313 
314  if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
315  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
316  *discarded_samples += frame->nb_samples;
317  return AVERROR(EAGAIN);
318  }
319 
320  if (avci->skip_samples > 0) {
321  if (frame->nb_samples <= avci->skip_samples){
322  *discarded_samples += frame->nb_samples;
323  avci->skip_samples -= frame->nb_samples;
324  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
325  avci->skip_samples);
326  return AVERROR(EAGAIN);
327  } else {
328  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
329  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
330  if (avctx->pkt_timebase.num && avctx->sample_rate) {
331  int64_t diff_ts = av_rescale_q(avci->skip_samples,
332  (AVRational){1, avctx->sample_rate},
333  avctx->pkt_timebase);
334  if (frame->pts != AV_NOPTS_VALUE)
335  frame->pts += diff_ts;
336  if (frame->pkt_dts != AV_NOPTS_VALUE)
337  frame->pkt_dts += diff_ts;
338  if (frame->duration >= diff_ts)
339  frame->duration -= diff_ts;
340  } else
341  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
342 
343  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
344  avci->skip_samples, frame->nb_samples);
345  *discarded_samples += avci->skip_samples;
346  frame->nb_samples -= avci->skip_samples;
347  avci->skip_samples = 0;
348  }
349  }
350 
351  if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
352  if (discard_padding == frame->nb_samples) {
353  *discarded_samples += frame->nb_samples;
354  return AVERROR(EAGAIN);
355  } else {
356  if (avctx->pkt_timebase.num && avctx->sample_rate) {
357  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
358  (AVRational){1, avctx->sample_rate},
359  avctx->pkt_timebase);
360  frame->duration = diff_ts;
361  } else
362  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
363 
364  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
365  (int)discard_padding, frame->nb_samples);
366  frame->nb_samples -= discard_padding;
367  }
368  }
369 
370  return 0;
371 }
372 
373 /*
374  * The core of the receive_frame_wrapper for the decoders implementing
375  * the simple API. Certain decoders might consume partial packets without
376  * returning any output, so this function needs to be called in a loop until it
377  * returns EAGAIN.
378  **/
379 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
380 {
381  AVCodecInternal *avci = avctx->internal;
382  AVPacket *const pkt = avci->in_pkt;
383  const FFCodec *const codec = ffcodec(avctx->codec);
384  int got_frame, consumed;
385  int ret;
386 
387  if (!pkt->data && !avci->draining) {
389  ret = ff_decode_get_packet(avctx, pkt);
390  if (ret < 0 && ret != AVERROR_EOF)
391  return ret;
392  }
393 
394  // Some codecs (at least wma lossless) will crash when feeding drain packets
395  // after EOF was signaled.
396  if (avci->draining_done)
397  return AVERROR_EOF;
398 
399  if (!pkt->data &&
400  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
402  return AVERROR_EOF;
403 
404  got_frame = 0;
405 
406  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
407  consumed = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
408  } else {
409  consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
410 
412  frame->pkt_dts = pkt->dts;
413  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
414 #if FF_API_FRAME_PKT
416  if(!avctx->has_b_frames)
417  frame->pkt_pos = pkt->pos;
419 #endif
420  }
421  }
422  emms_c();
423 
424  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
425  ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
426  ? AVERROR(EAGAIN)
427  : 0;
428  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
429  ret = !got_frame ? AVERROR(EAGAIN)
430  : discard_samples(avctx, frame, discarded_samples);
431  }
432 
433  if (ret == AVERROR(EAGAIN))
435 
436  // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
437  // code later will add AVERROR(EAGAIN) to a pointer
438  av_assert0(consumed != AVERROR(EAGAIN));
439  if (consumed < 0)
440  ret = consumed;
441  if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
442  consumed = pkt->size;
443 
444  if (!ret)
445  av_assert0(frame->buf[0]);
446  if (ret == AVERROR(EAGAIN))
447  ret = 0;
448 
449  /* do not stop draining when got_frame != 0 or ret < 0 */
450  if (avci->draining && !got_frame) {
451  if (ret < 0) {
452  /* prevent infinite loop if a decoder wrongly always return error on draining */
453  /* reasonable nb_errors_max = maximum b frames + thread count */
454  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
455  avctx->thread_count : 1);
456 
457  if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
458  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
459  "Stop draining and force EOF.\n");
460  avci->draining_done = 1;
461  ret = AVERROR_BUG;
462  }
463  } else {
464  avci->draining_done = 1;
465  }
466  }
467 
468  if (consumed >= pkt->size || ret < 0) {
470  } else {
471  pkt->data += consumed;
472  pkt->size -= consumed;
476 #if FF_API_FRAME_PKT
477  // See extract_packet_props() comment.
478  avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed;
479 #endif
482  }
483  }
484 
485  return ret;
486 }
487 
488 #if CONFIG_LCMS2
489 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
490 {
491  AVCodecInternal *avci = avctx->internal;
493  AVColorPrimariesDesc coeffs;
494  enum AVColorPrimaries prim;
495  cmsHPROFILE profile;
496  AVFrameSideData *sd;
497  int ret;
498  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
499  return 0;
500 
502  if (!sd || !sd->size)
503  return 0;
504 
505  if (!avci->icc.avctx) {
506  ret = ff_icc_context_init(&avci->icc, avctx);
507  if (ret < 0)
508  return ret;
509  }
510 
511  profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
512  if (!profile)
513  return AVERROR_INVALIDDATA;
514 
515  ret = ff_icc_profile_sanitize(&avci->icc, profile);
516  if (!ret)
517  ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
518  if (!ret)
519  ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
520  cmsCloseProfile(profile);
521  if (ret < 0)
522  return ret;
523 
524  prim = av_csp_primaries_id_from_desc(&coeffs);
525  if (prim != AVCOL_PRI_UNSPECIFIED)
526  frame->color_primaries = prim;
527  if (trc != AVCOL_TRC_UNSPECIFIED)
528  frame->color_trc = trc;
529  return 0;
530 }
531 #else /* !CONFIG_LCMS2 */
533 {
534  return 0;
535 }
536 #endif
537 
538 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
539 {
540  int ret;
541 
542  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
543  frame->color_primaries = avctx->color_primaries;
544  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
545  frame->color_trc = avctx->color_trc;
546  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
547  frame->colorspace = avctx->colorspace;
548  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
549  frame->color_range = avctx->color_range;
550  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
551  frame->chroma_location = avctx->chroma_sample_location;
552 
553  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
554  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
555  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
556  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
557  if (frame->format == AV_SAMPLE_FMT_NONE)
558  frame->format = avctx->sample_fmt;
559  if (!frame->ch_layout.nb_channels) {
560  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
561  if (ret < 0)
562  return ret;
563  }
564  if (!frame->sample_rate)
565  frame->sample_rate = avctx->sample_rate;
566  }
567 
568  return 0;
569 }
570 
572 {
573  int ret;
574  int64_t discarded_samples = 0;
575 
576  while (!frame->buf[0]) {
577  if (discarded_samples > avctx->max_samples)
578  return AVERROR(EAGAIN);
579  ret = decode_simple_internal(avctx, frame, &discarded_samples);
580  if (ret < 0)
581  return ret;
582  }
583 
584  return 0;
585 }
586 
588 {
589  AVCodecInternal *avci = avctx->internal;
590  DecodeContext *dc = decode_ctx(avci);
591  const FFCodec *const codec = ffcodec(avctx->codec);
592  int ret, ok;
593 
594  av_assert0(!frame->buf[0]);
595 
596  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
597  ret = codec->cb.receive_frame(avctx, frame);
598  emms_c();
599  if (!ret) {
600  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO)
601  ret = (frame->flags & AV_FRAME_FLAG_DISCARD) ? AVERROR(EAGAIN) : 0;
602  else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
603  int64_t discarded_samples = 0;
604  ret = discard_samples(avctx, frame, &discarded_samples);
605  }
606  }
607  } else
609 
610  if (ret == AVERROR_EOF)
611  avci->draining_done = 1;
612 
613  /* preserve ret */
614  ok = detect_colorspace(avctx, frame);
615  if (ok < 0) {
617  return ok;
618  }
619 
620  if (!ret) {
621  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
622  if (!frame->width)
623  frame->width = avctx->width;
624  if (!frame->height)
625  frame->height = avctx->height;
626  } else
627  frame->flags |= AV_FRAME_FLAG_KEY;
628 
629  ret = fill_frame_props(avctx, frame);
630  if (ret < 0) {
632  return ret;
633  }
634 
635 #if FF_API_FRAME_KEY
637  frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY);
639 #endif
640 #if FF_API_INTERLACED_FRAME
642  frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED);
643  frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
645 #endif
646  frame->best_effort_timestamp = guess_correct_pts(dc,
647  frame->pts,
648  frame->pkt_dts);
649 
650  /* the only case where decode data is not set should be decoders
651  * that do not call ff_get_buffer() */
652  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
653  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
654 
655  if (frame->private_ref) {
656  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
657 
658  if (fdd->post_process) {
659  ret = fdd->post_process(avctx, frame);
660  if (ret < 0) {
662  return ret;
663  }
664  }
665  }
666  }
667 
668  /* free the per-frame decode data */
669  av_buffer_unref(&frame->private_ref);
670 
671  return ret;
672 }
673 
675 {
676  AVCodecInternal *avci = avctx->internal;
677  DecodeContext *dc = decode_ctx(avci);
678  int ret;
679 
680  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
681  return AVERROR(EINVAL);
682 
683  if (dc->draining_started)
684  return AVERROR_EOF;
685 
686  if (avpkt && !avpkt->size && avpkt->data)
687  return AVERROR(EINVAL);
688 
689  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
690  if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
691  return AVERROR(EAGAIN);
692  ret = av_packet_ref(avci->buffer_pkt, avpkt);
693  if (ret < 0)
694  return ret;
695  } else
696  dc->draining_started = 1;
697 
698  if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
700  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
701  return ret;
702  }
703 
704  return 0;
705 }
706 
708 {
709  /* make sure we are noisy about decoders returning invalid cropping data */
710  if (frame->crop_left >= INT_MAX - frame->crop_right ||
711  frame->crop_top >= INT_MAX - frame->crop_bottom ||
712  (frame->crop_left + frame->crop_right) >= frame->width ||
713  (frame->crop_top + frame->crop_bottom) >= frame->height) {
714  av_log(avctx, AV_LOG_WARNING,
715  "Invalid cropping information set by a decoder: "
717  "(frame size %dx%d). This is a bug, please report it\n",
718  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
719  frame->width, frame->height);
720  frame->crop_left = 0;
721  frame->crop_right = 0;
722  frame->crop_top = 0;
723  frame->crop_bottom = 0;
724  return 0;
725  }
726 
727  if (!avctx->apply_cropping)
728  return 0;
729 
732 }
733 
734 // make sure frames returned to the caller are valid
736 {
737  if (!frame->buf[0] || frame->format < 0)
738  goto fail;
739 
740  switch (avctx->codec_type) {
741  case AVMEDIA_TYPE_VIDEO:
742  if (frame->width <= 0 || frame->height <= 0)
743  goto fail;
744  break;
745  case AVMEDIA_TYPE_AUDIO:
746  if (!av_channel_layout_check(&frame->ch_layout) ||
747  frame->sample_rate <= 0)
748  goto fail;
749 
750  break;
751  default: av_assert0(0);
752  }
753 
754  return 0;
755 fail:
756  av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
757  "This is a bug, please report it.\n");
758  return AVERROR_BUG;
759 }
760 
762 {
763  AVCodecInternal *avci = avctx->internal;
764  int ret;
765 
766  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
767  return AVERROR(EINVAL);
768 
769  if (avci->buffer_frame->buf[0]) {
771  } else {
773  if (ret < 0)
774  return ret;
775  }
776 
777  ret = frame_validate(avctx, frame);
778  if (ret < 0)
779  goto fail;
780 
781  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
782  ret = apply_cropping(avctx, frame);
783  if (ret < 0)
784  goto fail;
785  }
786 
787  avctx->frame_num++;
788 
789 #if FF_API_DROPCHANGED
790  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
791 
792  if (avctx->frame_num == 1) {
793  avci->initial_format = frame->format;
794  switch(avctx->codec_type) {
795  case AVMEDIA_TYPE_VIDEO:
796  avci->initial_width = frame->width;
797  avci->initial_height = frame->height;
798  break;
799  case AVMEDIA_TYPE_AUDIO:
800  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
801  avctx->sample_rate;
802  ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
803  if (ret < 0)
804  goto fail;
805  break;
806  }
807  }
808 
809  if (avctx->frame_num > 1) {
810  int changed = avci->initial_format != frame->format;
811 
812  switch(avctx->codec_type) {
813  case AVMEDIA_TYPE_VIDEO:
814  changed |= avci->initial_width != frame->width ||
815  avci->initial_height != frame->height;
816  break;
817  case AVMEDIA_TYPE_AUDIO:
818  changed |= avci->initial_sample_rate != frame->sample_rate ||
819  avci->initial_sample_rate != avctx->sample_rate ||
821  break;
822  }
823 
824  if (changed) {
825  avci->changed_frames_dropped++;
826  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64
827  " drop count: %d \n",
828  avctx->frame_num, frame->pts,
829  avci->changed_frames_dropped);
831  goto fail;
832  }
833  }
834  }
835 #endif
836  return 0;
837 fail:
839  return ret;
840 }
841 
843 {
844  memset(sub, 0, sizeof(*sub));
845  sub->pts = AV_NOPTS_VALUE;
846 }
847 
848 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
849 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
850  const AVPacket *inpkt, AVPacket *buf_pkt)
851 {
852 #if CONFIG_ICONV
853  iconv_t cd = (iconv_t)-1;
854  int ret = 0;
855  char *inb, *outb;
856  size_t inl, outl;
857 #endif
858 
859  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
860  *outpkt = inpkt;
861  return 0;
862  }
863 
864 #if CONFIG_ICONV
865  inb = inpkt->data;
866  inl = inpkt->size;
867 
868  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
869  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
870  return AVERROR(ERANGE);
871  }
872 
873  cd = iconv_open("UTF-8", avctx->sub_charenc);
874  av_assert0(cd != (iconv_t)-1);
875 
876  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
877  if (ret < 0)
878  goto end;
879  ret = av_packet_copy_props(buf_pkt, inpkt);
880  if (ret < 0)
881  goto end;
882  outb = buf_pkt->data;
883  outl = buf_pkt->size;
884 
885  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
886  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
887  outl >= buf_pkt->size || inl != 0) {
888  ret = FFMIN(AVERROR(errno), -1);
889  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
890  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
891  goto end;
892  }
893  buf_pkt->size -= outl;
894  memset(buf_pkt->data + buf_pkt->size, 0, outl);
895  *outpkt = buf_pkt;
896 
897  ret = 0;
898 end:
899  if (ret < 0)
900  av_packet_unref(buf_pkt);
901  if (cd != (iconv_t)-1)
902  iconv_close(cd);
903  return ret;
904 #else
905  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
906  return AVERROR(EINVAL);
907 #endif
908 }
909 
910 static int utf8_check(const uint8_t *str)
911 {
912  const uint8_t *byte;
913  uint32_t codepoint, min;
914 
915  while (*str) {
916  byte = str;
917  GET_UTF8(codepoint, *(byte++), return 0;);
918  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
919  1 << (5 * (byte - str) - 4);
920  if (codepoint < min || codepoint >= 0x110000 ||
921  codepoint == 0xFFFE /* BOM */ ||
922  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
923  return 0;
924  str = byte;
925  }
926  return 1;
927 }
928 
930  int *got_sub_ptr, const AVPacket *avpkt)
931 {
932  int ret = 0;
933 
934  if (!avpkt->data && avpkt->size) {
935  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
936  return AVERROR(EINVAL);
937  }
938  if (!avctx->codec)
939  return AVERROR(EINVAL);
941  av_log(avctx, AV_LOG_ERROR, "Codec not subtitle decoder\n");
942  return AVERROR(EINVAL);
943  }
944 
945  *got_sub_ptr = 0;
947 
948  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
949  AVCodecInternal *avci = avctx->internal;
950  const AVPacket *pkt;
951 
952  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
953  if (ret < 0)
954  return ret;
955 
956  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
957  sub->pts = av_rescale_q(avpkt->pts,
958  avctx->pkt_timebase, AV_TIME_BASE_Q);
959  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
960  if (pkt == avci->buffer_pkt) // did we recode?
962  if (ret < 0) {
963  *got_sub_ptr = 0;
964  avsubtitle_free(sub);
965  return ret;
966  }
967  av_assert1(!sub->num_rects || *got_sub_ptr);
968 
969  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
970  avctx->pkt_timebase.num) {
971  AVRational ms = { 1, 1000 };
972  sub->end_display_time = av_rescale_q(avpkt->duration,
973  avctx->pkt_timebase, ms);
974  }
975 
977  sub->format = 0;
978  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
979  sub->format = 1;
980 
981  for (unsigned i = 0; i < sub->num_rects; i++) {
983  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
984  av_log(avctx, AV_LOG_ERROR,
985  "Invalid UTF-8 in decoded subtitles text; "
986  "maybe missing -sub_charenc option\n");
987  avsubtitle_free(sub);
988  *got_sub_ptr = 0;
989  return AVERROR_INVALIDDATA;
990  }
991  }
992 
993  if (*got_sub_ptr)
994  avctx->frame_num++;
995  }
996 
997  return ret;
998 }
999 
1001  const enum AVPixelFormat *fmt)
1002 {
1003  const AVPixFmtDescriptor *desc;
1004  const AVCodecHWConfig *config;
1005  int i, n;
1006 
1007  // If a device was supplied when the codec was opened, assume that the
1008  // user wants to use it.
1009  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
1010  AVHWDeviceContext *device_ctx =
1012  for (i = 0;; i++) {
1013  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
1014  if (!config)
1015  break;
1016  if (!(config->methods &
1018  continue;
1019  if (device_ctx->type != config->device_type)
1020  continue;
1021  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1022  if (config->pix_fmt == fmt[n])
1023  return fmt[n];
1024  }
1025  }
1026  }
1027  // No device or other setup, so we have to choose from things which
1028  // don't any other external information.
1029 
1030  // If the last element of the list is a software format, choose it
1031  // (this should be best software format if any exist).
1032  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1033  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1034  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1035  return fmt[n - 1];
1036 
1037  // Finally, traverse the list in order and choose the first entry
1038  // with no external dependencies (if there is no hardware configuration
1039  // information available then this just picks the first entry).
1040  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1041  for (i = 0;; i++) {
1042  config = avcodec_get_hw_config(avctx->codec, i);
1043  if (!config)
1044  break;
1045  if (config->pix_fmt == fmt[n])
1046  break;
1047  }
1048  if (!config) {
1049  // No specific config available, so the decoder must be able
1050  // to handle this format without any additional setup.
1051  return fmt[n];
1052  }
1053  if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1054  // Usable with only internal setup.
1055  return fmt[n];
1056  }
1057  }
1058 
1059  // Nothing is usable, give up.
1060  return AV_PIX_FMT_NONE;
1061 }
1062 
1064  enum AVHWDeviceType dev_type)
1065 {
1066  AVHWDeviceContext *device_ctx;
1067  AVHWFramesContext *frames_ctx;
1068  int ret;
1069 
1070  if (!avctx->hwaccel)
1071  return AVERROR(ENOSYS);
1072 
1073  if (avctx->hw_frames_ctx)
1074  return 0;
1075  if (!avctx->hw_device_ctx) {
1076  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1077  "required for hardware accelerated decoding.\n");
1078  return AVERROR(EINVAL);
1079  }
1080 
1081  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1082  if (device_ctx->type != dev_type) {
1083  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1084  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1085  av_hwdevice_get_type_name(device_ctx->type));
1086  return AVERROR(EINVAL);
1087  }
1088 
1090  avctx->hw_device_ctx,
1091  avctx->hwaccel->pix_fmt,
1092  &avctx->hw_frames_ctx);
1093  if (ret < 0)
1094  return ret;
1095 
1096  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1097 
1098 
1099  if (frames_ctx->initial_pool_size) {
1100  // We guarantee 4 base work surfaces. The function above guarantees 1
1101  // (the absolute minimum), so add the missing count.
1102  frames_ctx->initial_pool_size += 3;
1103  }
1104 
1106  if (ret < 0) {
1107  av_buffer_unref(&avctx->hw_frames_ctx);
1108  return ret;
1109  }
1110 
1111  return 0;
1112 }
1113 
1115  AVBufferRef *device_ref,
1117  AVBufferRef **out_frames_ref)
1118 {
1119  AVBufferRef *frames_ref = NULL;
1120  const AVCodecHWConfigInternal *hw_config;
1121  const FFHWAccel *hwa;
1122  int i, ret;
1123 
1124  for (i = 0;; i++) {
1125  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1126  if (!hw_config)
1127  return AVERROR(ENOENT);
1128  if (hw_config->public.pix_fmt == hw_pix_fmt)
1129  break;
1130  }
1131 
1132  hwa = hw_config->hwaccel;
1133  if (!hwa || !hwa->frame_params)
1134  return AVERROR(ENOENT);
1135 
1136  frames_ref = av_hwframe_ctx_alloc(device_ref);
1137  if (!frames_ref)
1138  return AVERROR(ENOMEM);
1139 
1140  if (!avctx->internal->hwaccel_priv_data) {
1141  avctx->internal->hwaccel_priv_data =
1142  av_mallocz(hwa->priv_data_size);
1143  if (!avctx->internal->hwaccel_priv_data) {
1144  av_buffer_unref(&frames_ref);
1145  return AVERROR(ENOMEM);
1146  }
1147  }
1148 
1149  ret = hwa->frame_params(avctx, frames_ref);
1150  if (ret >= 0) {
1151  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1152 
1153  if (frames_ctx->initial_pool_size) {
1154  // If the user has requested that extra output surfaces be
1155  // available then add them here.
1156  if (avctx->extra_hw_frames > 0)
1157  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1158 
1159  // If frame threading is enabled then an extra surface per thread
1160  // is also required.
1161  if (avctx->active_thread_type & FF_THREAD_FRAME)
1162  frames_ctx->initial_pool_size += avctx->thread_count;
1163  }
1164 
1165  *out_frames_ref = frames_ref;
1166  } else {
1167  av_buffer_unref(&frames_ref);
1168  }
1169  return ret;
1170 }
1171 
1172 static int hwaccel_init(AVCodecContext *avctx,
1173  const FFHWAccel *hwaccel)
1174 {
1175  int err;
1176 
1177  if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1179  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1180  hwaccel->p.name);
1181  return AVERROR_PATCHWELCOME;
1182  }
1183 
1184  if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1185  avctx->internal->hwaccel_priv_data =
1186  av_mallocz(hwaccel->priv_data_size);
1187  if (!avctx->internal->hwaccel_priv_data)
1188  return AVERROR(ENOMEM);
1189  }
1190 
1191  avctx->hwaccel = &hwaccel->p;
1192  if (hwaccel->init) {
1193  err = hwaccel->init(avctx);
1194  if (err < 0) {
1195  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1196  "hwaccel initialisation returned error.\n",
1197  av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1199  avctx->hwaccel = NULL;
1200  return err;
1201  }
1202  }
1203 
1204  return 0;
1205 }
1206 
1208 {
1209  if (FF_HW_HAS_CB(avctx, uninit))
1210  FF_HW_SIMPLE_CALL(avctx, uninit);
1211 
1213 
1214  avctx->hwaccel = NULL;
1215 
1216  av_buffer_unref(&avctx->hw_frames_ctx);
1217 }
1218 
1219 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1220 {
1221  const AVPixFmtDescriptor *desc;
1222  enum AVPixelFormat *choices;
1223  enum AVPixelFormat ret, user_choice;
1224  const AVCodecHWConfigInternal *hw_config;
1225  const AVCodecHWConfig *config;
1226  int i, n, err;
1227 
1228  // Find end of list.
1229  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1230  // Must contain at least one entry.
1231  av_assert0(n >= 1);
1232  // If a software format is available, it must be the last entry.
1233  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1234  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1235  // No software format is available.
1236  } else {
1237  avctx->sw_pix_fmt = fmt[n - 1];
1238  }
1239 
1240  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1241  if (!choices)
1242  return AV_PIX_FMT_NONE;
1243 
1244  for (;;) {
1245  // Remove the previous hwaccel, if there was one.
1246  ff_hwaccel_uninit(avctx);
1247 
1248  user_choice = avctx->get_format(avctx, choices);
1249  if (user_choice == AV_PIX_FMT_NONE) {
1250  // Explicitly chose nothing, give up.
1251  ret = AV_PIX_FMT_NONE;
1252  break;
1253  }
1254 
1255  desc = av_pix_fmt_desc_get(user_choice);
1256  if (!desc) {
1257  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1258  "get_format() callback.\n");
1259  ret = AV_PIX_FMT_NONE;
1260  break;
1261  }
1262  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1263  desc->name);
1264 
1265  for (i = 0; i < n; i++) {
1266  if (choices[i] == user_choice)
1267  break;
1268  }
1269  if (i == n) {
1270  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1271  "%s not in possible list.\n", desc->name);
1272  ret = AV_PIX_FMT_NONE;
1273  break;
1274  }
1275 
1276  if (ffcodec(avctx->codec)->hw_configs) {
1277  for (i = 0;; i++) {
1278  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1279  if (!hw_config)
1280  break;
1281  if (hw_config->public.pix_fmt == user_choice)
1282  break;
1283  }
1284  } else {
1285  hw_config = NULL;
1286  }
1287 
1288  if (!hw_config) {
1289  // No config available, so no extra setup required.
1290  ret = user_choice;
1291  break;
1292  }
1293  config = &hw_config->public;
1294 
1295  if (config->methods &
1297  avctx->hw_frames_ctx) {
1298  const AVHWFramesContext *frames_ctx =
1300  if (frames_ctx->format != user_choice) {
1301  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1302  "does not match the format of the provided frames "
1303  "context.\n", desc->name);
1304  goto try_again;
1305  }
1306  } else if (config->methods &
1308  avctx->hw_device_ctx) {
1309  const AVHWDeviceContext *device_ctx =
1311  if (device_ctx->type != config->device_type) {
1312  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1313  "does not match the type of the provided device "
1314  "context.\n", desc->name);
1315  goto try_again;
1316  }
1317  } else if (config->methods &
1319  // Internal-only setup, no additional configuration.
1320  } else if (config->methods &
1322  // Some ad-hoc configuration we can't see and can't check.
1323  } else {
1324  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1325  "missing configuration.\n", desc->name);
1326  goto try_again;
1327  }
1328  if (hw_config->hwaccel) {
1329  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1330  "initialisation.\n", desc->name);
1331  err = hwaccel_init(avctx, hw_config->hwaccel);
1332  if (err < 0)
1333  goto try_again;
1334  }
1335  ret = user_choice;
1336  break;
1337 
1338  try_again:
1339  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1340  "get_format() without it.\n", desc->name);
1341  for (i = 0; i < n; i++) {
1342  if (choices[i] == user_choice)
1343  break;
1344  }
1345  for (; i + 1 < n; i++)
1346  choices[i] = choices[i + 1];
1347  --n;
1348  }
1349 
1350  if (ret < 0)
1351  ff_hwaccel_uninit(avctx);
1352 
1353  av_freep(&choices);
1354  return ret;
1355 }
1356 
1359 {
1360  for (int i = 0; i < avctx->nb_coded_side_data; i++)
1361  if (avctx->coded_side_data[i].type == type)
1362  return &avctx->coded_side_data[i];
1363 
1364  return NULL;
1365 }
1366 
1368 {
1369  size_t size;
1370  const uint8_t *side_metadata;
1371 
1372  AVDictionary **frame_md = &frame->metadata;
1373 
1374  side_metadata = av_packet_get_side_data(avpkt,
1376  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1377 }
1378 
1379 static const struct {
1382 } sd_global_map[] = {
1392 };
1393 
1395  AVFrame *frame, const AVPacket *pkt)
1396 {
1397  static const struct {
1400  } sd[] = {
1406  };
1407 
1408  frame->pts = pkt->pts;
1409  frame->duration = pkt->duration;
1410 #if FF_API_FRAME_PKT
1412  frame->pkt_pos = pkt->pos;
1413  frame->pkt_size = pkt->size;
1415 #endif
1416 
1417  for (int i = 0; i < FF_ARRAY_ELEMS(sd_global_map); i++) {
1418  size_t size;
1419  const uint8_t *packet_sd = av_packet_get_side_data(pkt, sd_global_map[i].packet, &size);
1420  if (packet_sd) {
1421  AVFrameSideData *frame_sd;
1422 
1424  if (!frame_sd)
1425  return AVERROR(ENOMEM);
1426  memcpy(frame_sd->data, packet_sd, size);
1427  }
1428  }
1429  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1430  size_t size;
1431  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1432  if (packet_sd) {
1434  sd[i].frame,
1435  size);
1436  if (!frame_sd)
1437  return AVERROR(ENOMEM);
1438 
1439  memcpy(frame_sd->data, packet_sd, size);
1440  }
1441  }
1443 
1444  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1445  frame->flags |= AV_FRAME_FLAG_DISCARD;
1446  } else {
1447  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1448  }
1449 
1450  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1451  int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1452  if (ret < 0)
1453  return ret;
1454  frame->opaque = pkt->opaque;
1455  }
1456 
1457  return 0;
1458 }
1459 
1461 {
1462  int ret;
1463 
1464  for (int i = 0; i < FF_ARRAY_ELEMS(sd_global_map); i++) {
1465  const AVPacketSideData *packet_sd = ff_get_coded_side_data(avctx,
1467  if (packet_sd) {
1470  packet_sd->size);
1471  if (!frame_sd)
1472  return AVERROR(ENOMEM);
1473 
1474  memcpy(frame_sd->data, packet_sd->data, packet_sd->size);
1475  }
1476  }
1477 
1479  const AVPacket *pkt = avctx->internal->last_pkt_props;
1480 
1482  if (ret < 0)
1483  return ret;
1484 #if FF_API_FRAME_PKT
1486  frame->pkt_size = pkt->stream_index;
1488 #endif
1489  }
1490 
1491  ret = fill_frame_props(avctx, frame);
1492  if (ret < 0)
1493  return ret;
1494 
1495  switch (avctx->codec->type) {
1496  case AVMEDIA_TYPE_VIDEO:
1497  if (frame->width && frame->height &&
1498  av_image_check_sar(frame->width, frame->height,
1499  frame->sample_aspect_ratio) < 0) {
1500  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1501  frame->sample_aspect_ratio.num,
1502  frame->sample_aspect_ratio.den);
1503  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1504  }
1505  break;
1506  }
1507  return 0;
1508 }
1509 
1511 {
1512  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1513  int i;
1514  int num_planes = av_pix_fmt_count_planes(frame->format);
1516  int flags = desc ? desc->flags : 0;
1517  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1518  num_planes = 2;
1519  for (i = 0; i < num_planes; i++) {
1520  av_assert0(frame->data[i]);
1521  }
1522  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1523  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1524  if (frame->data[i])
1525  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1526  frame->data[i] = NULL;
1527  }
1528  }
1529 }
1530 
1531 static void decode_data_free(void *opaque, uint8_t *data)
1532 {
1534 
1535  if (fdd->post_process_opaque_free)
1537 
1538  if (fdd->hwaccel_priv_free)
1539  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1540 
1541  av_freep(&fdd);
1542 }
1543 
1545 {
1546  AVBufferRef *fdd_buf;
1547  FrameDecodeData *fdd;
1548 
1549  av_assert1(!frame->private_ref);
1550  av_buffer_unref(&frame->private_ref);
1551 
1552  fdd = av_mallocz(sizeof(*fdd));
1553  if (!fdd)
1554  return AVERROR(ENOMEM);
1555 
1556  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1558  if (!fdd_buf) {
1559  av_freep(&fdd);
1560  return AVERROR(ENOMEM);
1561  }
1562 
1563  frame->private_ref = fdd_buf;
1564 
1565  return 0;
1566 }
1567 
1569 {
1570  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1571  int override_dimensions = 1;
1572  int ret;
1573 
1575 
1576  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1577  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1578  (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) {
1579  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1580  ret = AVERROR(EINVAL);
1581  goto fail;
1582  }
1583 
1584  if (frame->width <= 0 || frame->height <= 0) {
1585  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1586  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1587  override_dimensions = 0;
1588  }
1589 
1590  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1591  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1592  ret = AVERROR(EINVAL);
1593  goto fail;
1594  }
1595  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1596  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1597  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1598  ret = AVERROR(EINVAL);
1599  goto fail;
1600  }
1601  }
1602  ret = ff_decode_frame_props(avctx, frame);
1603  if (ret < 0)
1604  goto fail;
1605 
1606  if (hwaccel) {
1607  if (hwaccel->alloc_frame) {
1608  ret = hwaccel->alloc_frame(avctx, frame);
1609  goto end;
1610  }
1611  } else
1612  avctx->sw_pix_fmt = avctx->pix_fmt;
1613 
1614  ret = avctx->get_buffer2(avctx, frame, flags);
1615  if (ret < 0)
1616  goto fail;
1617 
1619 
1621  if (ret < 0)
1622  goto fail;
1623 
1624 end:
1625  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1627  frame->width = avctx->width;
1628  frame->height = avctx->height;
1629  }
1630 
1631 fail:
1632  if (ret < 0) {
1633  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1635  }
1636 
1637  return ret;
1638 }
1639 
1641 {
1642  AVFrame *tmp;
1643  int ret;
1644 
1646 
1647  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1648  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1649  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1651  }
1652 
1653  if (!frame->data[0])
1654  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1655 
1657  return ff_decode_frame_props(avctx, frame);
1658 
1659  tmp = av_frame_alloc();
1660  if (!tmp)
1661  return AVERROR(ENOMEM);
1662 
1664 
1666  if (ret < 0) {
1667  av_frame_free(&tmp);
1668  return ret;
1669  }
1670 
1672  av_frame_free(&tmp);
1673 
1674  return 0;
1675 }
1676 
1678 {
1679  int ret = reget_buffer_internal(avctx, frame, flags);
1680  if (ret < 0)
1681  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1682  return ret;
1683 }
1684 
1686 {
1687  AVCodecInternal *avci = avctx->internal;
1688  DecodeContext *dc = decode_ctx(avci);
1689  int ret = 0;
1690 
1691  /* if the decoder init function was already called previously,
1692  * free the already allocated subtitle_header before overwriting it */
1693  av_freep(&avctx->subtitle_header);
1694 
1695  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1696  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1697  avctx->codec->max_lowres);
1698  avctx->lowres = avctx->codec->max_lowres;
1699  }
1700  if (avctx->sub_charenc) {
1701  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1702  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1703  "supported with subtitles codecs\n");
1704  return AVERROR(EINVAL);
1705  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1706  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1707  "subtitles character encoding will be ignored\n",
1708  avctx->codec_descriptor->name);
1710  } else {
1711  /* input character encoding is set for a text based subtitle
1712  * codec at this point */
1715 
1717 #if CONFIG_ICONV
1718  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1719  if (cd == (iconv_t)-1) {
1720  ret = AVERROR(errno);
1721  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1722  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1723  return ret;
1724  }
1725  iconv_close(cd);
1726 #else
1727  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1728  "conversion needs a libavcodec built with iconv support "
1729  "for this codec\n");
1730  return AVERROR(ENOSYS);
1731 #endif
1732  }
1733  }
1734  }
1735 
1736  dc->pts_correction_num_faulty_pts =
1737  dc->pts_correction_num_faulty_dts = 0;
1738  dc->pts_correction_last_pts =
1739  dc->pts_correction_last_dts = INT64_MIN;
1740 
1741  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1743  av_log(avctx, AV_LOG_WARNING,
1744  "gray decoding requested but not enabled at configuration time\n");
1745  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1747  }
1748 
1749  if (avctx->nb_side_data_prefer_packet == 1 &&
1750  avctx->side_data_prefer_packet[0] == -1)
1751  dc->side_data_pref_mask = ~0ULL;
1752  else {
1753  for (unsigned i = 0; i < avctx->nb_side_data_prefer_packet; i++) {
1754  int val = avctx->side_data_prefer_packet[i];
1755 
1756  if (val < 0 || val >= AV_PKT_DATA_NB) {
1757  av_log(avctx, AV_LOG_ERROR, "Invalid side data type: %d\n", val);
1758  return AVERROR(EINVAL);
1759  }
1760 
1761  for (unsigned j = 0; j < FF_ARRAY_ELEMS(sd_global_map); j++) {
1762  if (sd_global_map[j].packet == val) {
1763  val = sd_global_map[j].frame;
1764 
1765  // this code will need to be changed when we have more than
1766  // 64 frame side data types
1767  if (val >= 64) {
1768  av_log(avctx, AV_LOG_ERROR, "Side data type too big\n");
1769  return AVERROR_BUG;
1770  }
1771 
1772  dc->side_data_pref_mask |= 1ULL << val;
1773  }
1774  }
1775  }
1776  }
1777 
1778  avci->in_pkt = av_packet_alloc();
1779  avci->last_pkt_props = av_packet_alloc();
1780  if (!avci->in_pkt || !avci->last_pkt_props)
1781  return AVERROR(ENOMEM);
1782 
1783  ret = decode_bsfs_init(avctx);
1784  if (ret < 0)
1785  return ret;
1786 
1787 #if FF_API_DROPCHANGED
1788  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED)
1789  av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n");
1790 #endif
1791 
1792  return 0;
1793 }
1794 
1795 /**
1796  * Check side data preference and clear existing side data from frame
1797  * if needed.
1798  *
1799  * @retval 0 side data of this type can be added to frame
1800  * @retval 1 side data of this type should not be added to frame
1801  */
1802 static int side_data_pref(const AVCodecContext *avctx, AVFrame *frame,
1804 {
1805  DecodeContext *dc = decode_ctx(avctx->internal);
1806 
1807  // Note: could be skipped for `type` without corresponding packet sd
1809  if (dc->side_data_pref_mask & (1ULL << type))
1810  return 1;
1812  }
1813 
1814  return 0;
1815 }
1816 
1817 
1819  enum AVFrameSideDataType type, size_t size,
1820  AVFrameSideData **psd)
1821 {
1822  AVFrameSideData *sd;
1823 
1824  if (side_data_pref(avctx, frame, type)) {
1825  if (psd)
1826  *psd = NULL;
1827  return 0;
1828  }
1829 
1831  if (psd)
1832  *psd = sd;
1833 
1834  return sd ? 0 : AVERROR(ENOMEM);
1835 }
1836 
1839  AVBufferRef **buf, AVFrameSideData **psd)
1840 {
1841  AVFrameSideData *sd = NULL;
1842  int ret = 0;
1843 
1844  if (side_data_pref(avctx, frame, type))
1845  goto finish;
1846 
1848  if (sd)
1849  *buf = NULL;
1850  else
1851  ret = AVERROR(ENOMEM);
1852 
1853 finish:
1854  av_buffer_unref(buf);
1855  if (psd)
1856  *psd = sd;
1857 
1858  return ret;
1859 }
1860 
1863 {
1865  *mdm = NULL;
1866  return 0;
1867  }
1868 
1870  return *mdm ? 0 : AVERROR(ENOMEM);
1871 }
1872 
1874  AVContentLightMetadata **clm)
1875 {
1877  *clm = NULL;
1878  return 0;
1879  }
1880 
1882  return *clm ? 0 : AVERROR(ENOMEM);
1883 }
1884 
1885 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1886 {
1887  size_t size;
1888  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1889 
1890  if (pal && size == AVPALETTE_SIZE) {
1891  memcpy(dst, pal, AVPALETTE_SIZE);
1892  return 1;
1893  } else if (pal) {
1894  av_log(logctx, AV_LOG_ERROR,
1895  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1896  }
1897  return 0;
1898 }
1899 
1900 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
1901 {
1902  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1903 
1904  if (!hwaccel || !hwaccel->frame_priv_data_size)
1905  return 0;
1906 
1907  av_assert0(!*hwaccel_picture_private);
1908 
1909  if (hwaccel->free_frame_priv) {
1910  AVHWFramesContext *frames_ctx;
1911 
1912  if (!avctx->hw_frames_ctx)
1913  return AVERROR(EINVAL);
1914 
1915  frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
1916  *hwaccel_picture_private = ff_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
1917  frames_ctx->device_ctx,
1918  hwaccel->free_frame_priv);
1919  } else {
1920  *hwaccel_picture_private = ff_refstruct_allocz(hwaccel->frame_priv_data_size);
1921  }
1922 
1923  if (!*hwaccel_picture_private)
1924  return AVERROR(ENOMEM);
1925 
1926  return 0;
1927 }
1928 
1930 {
1931  AVCodecInternal *avci = avctx->internal;
1932  DecodeContext *dc = decode_ctx(avci);
1933 
1935  av_packet_unref(avci->in_pkt);
1936 
1937  dc->pts_correction_last_pts =
1938  dc->pts_correction_last_dts = INT64_MIN;
1939 
1940  av_bsf_flush(avci->bsf);
1941 
1942  dc->nb_draining_errors = 0;
1943  dc->draining_started = 0;
1944 }
1945 
1947 {
1948  return av_mallocz(sizeof(DecodeContext));
1949 }
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:1357
AVSubtitle
Definition: avcodec.h:2214
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:140
hwconfig.h
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_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1427
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
FFCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec_internal.h:210
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:1172
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:220
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:45
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:331
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:2219
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:787
ff_icc_profile_read_primaries
int ff_icc_profile_read_primaries(FFIccContext *s, cmsHPROFILE profile, AVColorPrimariesDesc *out_primaries)
Read the color primaries and white point coefficients encoded by an ICC profile, and return the raw v...
Definition: fflcms2.c:255
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf, AVFrameSideData **psd)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:1837
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:580
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1219
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:707
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:716
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:704
AVColorPrimariesDesc
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition: csp.h:78
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
Definition: avcodec.h:2115
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
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:584
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:116
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
AV_CODEC_FLAG_UNALIGNED
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e....
Definition: avcodec.h:220
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1861
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
AV_WL8
#define AV_WL8(p, d)
Definition: intreadwrite.h:397
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1915
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2218
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:571
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:88
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:67
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:322
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
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:522
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
data
const char data[16]
Definition: mxf.c:148
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:292
FFCodec
Definition: codec_internal.h:127
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1891
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:599
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
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
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:1879
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:555
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1000
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:676
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:553
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:396
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
decode_ctx
static DecodeContext * decode_ctx(AVCodecInternal *avci)
Definition: decode.c:77
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:1878
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
av_frame_apply_cropping
int av_frame_apply_cropping(AVFrame *frame, int flags)
Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ crop_bottom fields.
Definition: frame.c:859
DecodeContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: decode.c:66
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1207
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:604
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
decode_get_packet
static int decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: decode.c:193
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:375
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3002
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:100
DecodeContext::nb_draining_errors
int nb_draining_errors
Definition: decode.c:58
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:342
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:255
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:558
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:46
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
fail
#define fail()
Definition: checkasm.h:179
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:1582
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
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:1877
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FrameDecodeData::post_process_opaque_free
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h:46
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_decode_frame_props_from_pkt
int ff_decode_frame_props_from_pkt(const AVCodecContext *avctx, AVFrame *frame, const AVPacket *pkt)
Set various frame properties from the provided packet.
Definition: decode.c:1394
pts
static int64_t pts
Definition: transcode_aac.c:643
add_metadata_from_side_data
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1367
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1977
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
refstruct.h
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2211
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:379
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:302
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:76
AVCodecContext::get_buffer2
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1222
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:472
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:929
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
side_data_pref
static int side_data_pref(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type)
Check side data preference and clear existing side data from frame if needed.
Definition: decode.c:1802
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_PKT_DATA_PARAM_CHANGE
@ AV_PKT_DATA_PARAM_CHANGE
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
Definition: packet.h:73
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:249
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_decode_receive_frame
int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
Definition: decode.c:761
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:591
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:600
AVCodecContext::side_data_prefer_packet
int * side_data_prefer_packet
Decoding only.
Definition: avcodec.h:2060
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:1900
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:842
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: avpacket.c:98
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1510
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:131
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:58
FFHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: hwaccel_internal.h:112
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVERROR_INPUT_CHANGED
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
Definition: error.h:75
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:114
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
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_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVCodecHWConfig::pix_fmt
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:343
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2220
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:1934
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
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:547
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCodecHWConfigInternal::hwaccel
const struct FFHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
Definition: hwconfig.h:35
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:193
discard_samples
static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:281
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1531
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:1063
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:1861
DecodeContext::draining_started
int draining_started
The caller has submitted a NULL packet on input.
Definition: decode.c:63
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:137
AVCodecContext::sub_charenc
char * sub_charenc
Character encoding of the input subtitles file.
Definition: avcodec.h:1868
ff_decode_internal_alloc
AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:1946
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_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:910
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
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:1929
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1961
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
hwaccel_internal.h
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1916
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:112
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:376
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_CODEC_PROP_BITMAP_SUB
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: codec_desc.h: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:139
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:672
DecodeContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: decode.c:68
AV_CODEC_FLAG2_ICC_PROFILES
#define AV_CODEC_FLAG2_ICC_PROFILES
Generate/parse ICC profiles on encode/decode, as appropriate for the type of file.
Definition: avcodec.h:398
ff_icc_profile_detect_transfer
int ff_icc_profile_detect_transfer(FFIccContext *s, cmsHPROFILE profile, enum AVColorTransferCharacteristic *out_trc)
Attempt detecting the transfer characteristic that best approximates the transfer function encoded by...
Definition: fflcms2.c:302
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:435
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:133
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:848
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
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
sd_global_map
static const struct @71 sd_global_map[]
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:81
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:341
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
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:1854
f
f
Definition: af_crystalizer.c:121
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:509
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1568
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:77
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:523
ff_thread_decode_frame
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
Definition: pthread_frame.c:488
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
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: frame.h:216
byte
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:99
AVCodecContext::extra_hw_frames
int extra_hw_frames
Video decoding only.
Definition: avcodec.h:1520
codec_internal.h
FrameDecodeData::post_process
int(* post_process)(void *logctx, AVFrame *frame)
The callback to perform some delayed processing on the frame right before it is returned to the calle...
Definition: decode.h:44
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:121
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:769
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:300
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
FF_CODEC_CAP_SETS_FRAME_PROPS
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
Definition: codec_internal.h:78
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:138
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:75
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:60
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
frame_validate
static int frame_validate(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:735
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:1818
AVFrameSideData::data
uint8_t * data
Definition: frame.h:248
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:306
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:573
fill_frame_props
static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:538
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:703
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2217
frame.h
av_packet_unpack_dictionary
int av_packet_unpack_dictionary(const uint8_t *data, size_t size, AVDictionary **dict)
Unpack a dictionary from side_data.
Definition: avpacket.c:347
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:783
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
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:55
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:63
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:261
DecodeContext::side_data_pref_mask
uint64_t side_data_pref_mask
DTS of the last frame.
Definition: decode.c:74
AVCodecContext::nb_side_data_prefer_packet
unsigned nb_side_data_prefer_packet
Number of entries in side_data_prefer_packet.
Definition: avcodec.h:2064
detect_colorspace
static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: decode.c:532
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:800
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1593
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
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:965
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
emms.h
avcodec_send_packet
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:674
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:143
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: avpacket.c:390
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2215
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:139
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1640
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:252
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:587
internal.h
AV_PKT_DATA_ICC_PROFILE
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:275
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:74
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
packet
enum AVPacketSideDataType packet
Definition: decode.c:1380
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1685
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
DecodeContext::avci
AVCodecInternal avci
Definition: decode.c:55
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:561
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:534
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:254
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1497
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
FF_CODEC_CAP_SETS_PKT_DTS
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: codec_internal.h:49
profile
int profile
Definition: mxfenc.c:2226
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:618
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:379
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:599
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1475
avcodec.h
FFCodec::decode_sub
int(* decode_sub)(struct AVCodecContext *avctx, struct AVSubtitle *sub, int *got_frame_ptr, const struct AVPacket *avpkt)
Decode subtitle data to an AVSubtitle.
Definition: codec_internal.h:201
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1876
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:2030
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:1114
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:1677
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
AV_CODEC_HW_CONFIG_METHOD_AD_HOC
@ AV_CODEC_HW_CONFIG_METHOD_AD_HOC
The codec supports this format by some ad-hoc method.
Definition: codec.h:331
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:134
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:108
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:774
hwaccel
static const char * hwaccel
Definition: ffplay.c:356
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:1873
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
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:315
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:141
apply_param_change
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:82
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:1460
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1601
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, const AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:849
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:32
avcodec_internal.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
AV_PKT_DATA_AFD
@ AV_PKT_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: packet.h:262
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
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:1926
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
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:143
AVPacket::stream_index
int stream_index
Definition: packet.h:524
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:838
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:132
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:439
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:126
frame
enum AVFrameSideDataType frame
Definition: decode.c:1381
FFCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec_internal.h:252
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition: packet.h:121
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:187
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
AV_FRAME_FLAG_DISCARD
#define AV_FRAME_FLAG_DISCARD
A flag to mark the frames which need to be decoded, but shouldn't be output.
Definition: frame.h:595
desc
const char * desc
Definition: libsvtav1.c:73
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
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:243
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:1544
FFCodec::cb
union FFCodec::@65 cb
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:141
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:246
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:384
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:542
DecodeContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Definition: decode.c:65
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVCodecHWConfig
Definition: codec.h:334
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:664
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:323
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1885
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:158
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:2102
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:642
DecodeContext
Definition: decode.c:54
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: decode.h:128
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:534
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:2882
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:1880
min
float min
Definition: vorbis_enc_data.h:429