FFmpeg
decode.c
Go to the documentation of this file.
1 /*
2  * generic decoding-related code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 #include <string.h>
23 
24 #include "config.h"
25 
26 #if CONFIG_ICONV
27 # include <iconv.h>
28 #endif
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/bprint.h"
34 #include "libavutil/common.h"
35 #include "libavutil/emms.h"
36 #include "libavutil/fifo.h"
37 #include "libavutil/frame.h"
38 #include "libavutil/hwcontext.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/intmath.h"
42 #include "libavutil/opt.h"
43 
44 #include "avcodec.h"
45 #include "avcodec_internal.h"
46 #include "bytestream.h"
47 #include "bsf.h"
48 #include "codec_internal.h"
49 #include "decode.h"
50 #include "hwaccel_internal.h"
51 #include "hwconfig.h"
52 #include "internal.h"
53 #include "packet_internal.h"
54 #include "thread.h"
55 
56 typedef struct DecodeContext {
58 
59  /* to prevent infinite loop on errors when draining */
61 
62  /**
63  * The caller has submitted a NULL packet on input.
64  */
67 
69 {
70  return (DecodeContext *)avci;
71 }
72 
73 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
74 {
75  int ret;
76  size_t size;
77  const uint8_t *data;
78  uint32_t flags;
79  int64_t val;
80 
82  if (!data)
83  return 0;
84 
85  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
86  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
87  "changes, but PARAM_CHANGE side data was sent to it.\n");
88  ret = AVERROR(EINVAL);
89  goto fail2;
90  }
91 
92  if (size < 4)
93  goto fail;
94 
95  flags = bytestream_get_le32(&data);
96  size -= 4;
97 
98 #if FF_API_OLD_CHANNEL_LAYOUT
100  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
101  if (size < 4)
102  goto fail;
103  val = bytestream_get_le32(&data);
104  if (val <= 0 || val > INT_MAX) {
105  av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
107  goto fail2;
108  }
110  avctx->ch_layout.nb_channels = val;
112  size -= 4;
113  }
114  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
115  if (size < 8)
116  goto fail;
118  ret = av_channel_layout_from_mask(&avctx->ch_layout, bytestream_get_le64(&data));
119  if (ret < 0)
120  goto fail2;
121  size -= 8;
122  }
123  if (flags & (AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT |
124  AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)) {
125  avctx->channels = avctx->ch_layout.nb_channels;
126  avctx->channel_layout = (avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) ?
127  avctx->ch_layout.u.mask : 0;
128  }
130 #endif
132  if (size < 4)
133  goto fail;
134  val = bytestream_get_le32(&data);
135  if (val <= 0 || val > INT_MAX) {
136  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
138  goto fail2;
139  }
140  avctx->sample_rate = val;
141  size -= 4;
142  }
144  if (size < 8)
145  goto fail;
146  avctx->width = bytestream_get_le32(&data);
147  avctx->height = bytestream_get_le32(&data);
148  size -= 8;
149  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
150  if (ret < 0)
151  goto fail2;
152  }
153 
154  return 0;
155 fail:
156  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
158 fail2:
159  if (ret < 0) {
160  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
161  if (avctx->err_recognition & AV_EF_EXPLODE)
162  return ret;
163  }
164  return 0;
165 }
166 
168 {
169  int ret = 0;
170 
172  if (pkt) {
174 #if FF_API_FRAME_PKT
175  if (!ret)
176  avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props().
177 #endif
178  }
179  return ret;
180 }
181 
183 {
184  AVCodecInternal *avci = avctx->internal;
185  const FFCodec *const codec = ffcodec(avctx->codec);
186  int ret;
187 
188  if (avci->bsf)
189  return 0;
190 
191  ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
192  if (ret < 0) {
193  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
194  if (ret != AVERROR(ENOMEM))
195  ret = AVERROR_BUG;
196  goto fail;
197  }
198 
199  /* We do not currently have an API for passing the input timebase into decoders,
200  * but no filters used here should actually need it.
201  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
202  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
204  if (ret < 0)
205  goto fail;
206 
207  ret = av_bsf_init(avci->bsf);
208  if (ret < 0)
209  goto fail;
210 
211  return 0;
212 fail:
213  av_bsf_free(&avci->bsf);
214  return ret;
215 }
216 
218 {
219  AVCodecInternal *avci = avctx->internal;
220  int ret;
221 
222  ret = av_bsf_receive_packet(avci->bsf, pkt);
223  if (ret == AVERROR_EOF)
224  avci->draining = 1;
225  if (ret < 0)
226  return ret;
227 
230  if (ret < 0)
231  goto finish;
232  }
233 
234  ret = apply_param_change(avctx, pkt);
235  if (ret < 0)
236  goto finish;
237 
238  return 0;
239 finish:
241  return ret;
242 }
243 
245 {
246  AVCodecInternal *avci = avctx->internal;
247  DecodeContext *dc = decode_ctx(avci);
248 
249  if (avci->draining)
250  return AVERROR_EOF;
251 
252  while (1) {
253  int ret = decode_get_packet(avctx, pkt);
254  if (ret == AVERROR(EAGAIN) &&
255  (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
256  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
257  if (ret < 0) {
259  return ret;
260  }
261 
262  continue;
263  }
264 
265  return ret;
266  }
267 }
268 
269 /**
270  * Attempt to guess proper monotonic timestamps for decoded video frames
271  * which might have incorrect times. Input timestamps may wrap around, in
272  * which case the output will as well.
273  *
274  * @param pts the pts field of the decoded AVPacket, as passed through
275  * AVFrame.pts
276  * @param dts the dts field of the decoded AVPacket
277  * @return one of the input values, may be AV_NOPTS_VALUE
278  */
280  int64_t reordered_pts, int64_t dts)
281 {
282  int64_t pts = AV_NOPTS_VALUE;
283 
284  if (dts != AV_NOPTS_VALUE) {
285  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
286  ctx->pts_correction_last_dts = dts;
287  } else if (reordered_pts != AV_NOPTS_VALUE)
288  ctx->pts_correction_last_dts = reordered_pts;
289 
290  if (reordered_pts != AV_NOPTS_VALUE) {
291  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
292  ctx->pts_correction_last_pts = reordered_pts;
293  } else if(dts != AV_NOPTS_VALUE)
294  ctx->pts_correction_last_pts = dts;
295 
296  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
297  && reordered_pts != AV_NOPTS_VALUE)
298  pts = reordered_pts;
299  else
300  pts = dts;
301 
302  return pts;
303 }
304 
305 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
306 {
307  AVCodecInternal *avci = avctx->internal;
308  AVFrameSideData *side;
309  uint32_t discard_padding = 0;
310  uint8_t skip_reason = 0;
311  uint8_t discard_reason = 0;
312 
314  if (side && side->size >= 10) {
315  avci->skip_samples = AV_RL32(side->data);
316  avci->skip_samples = FFMAX(0, avci->skip_samples);
317  discard_padding = AV_RL32(side->data + 4);
318  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
319  avci->skip_samples, (int)discard_padding);
320  skip_reason = AV_RL8(side->data + 8);
321  discard_reason = AV_RL8(side->data + 9);
322  }
323 
324  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
325  if (!side && (avci->skip_samples || discard_padding))
327  if (side && (avci->skip_samples || discard_padding)) {
328  AV_WL32(side->data, avci->skip_samples);
329  AV_WL32(side->data + 4, discard_padding);
330  AV_WL8(side->data + 8, skip_reason);
331  AV_WL8(side->data + 9, discard_reason);
332  avci->skip_samples = 0;
333  }
334  return 0;
335  }
337 
338  if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
339  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
340  *discarded_samples += frame->nb_samples;
341  return AVERROR(EAGAIN);
342  }
343 
344  if (avci->skip_samples > 0) {
345  if (frame->nb_samples <= avci->skip_samples){
346  *discarded_samples += frame->nb_samples;
347  avci->skip_samples -= frame->nb_samples;
348  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
349  avci->skip_samples);
350  return AVERROR(EAGAIN);
351  } else {
352  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
353  frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
354  if (avctx->pkt_timebase.num && avctx->sample_rate) {
355  int64_t diff_ts = av_rescale_q(avci->skip_samples,
356  (AVRational){1, avctx->sample_rate},
357  avctx->pkt_timebase);
358  if (frame->pts != AV_NOPTS_VALUE)
359  frame->pts += diff_ts;
360  if (frame->pkt_dts != AV_NOPTS_VALUE)
361  frame->pkt_dts += diff_ts;
362  if (frame->duration >= diff_ts)
363  frame->duration -= diff_ts;
364  } else
365  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
366 
367  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
368  avci->skip_samples, frame->nb_samples);
369  *discarded_samples += avci->skip_samples;
370  frame->nb_samples -= avci->skip_samples;
371  avci->skip_samples = 0;
372  }
373  }
374 
375  if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
376  if (discard_padding == frame->nb_samples) {
377  *discarded_samples += frame->nb_samples;
378  return AVERROR(EAGAIN);
379  } else {
380  if (avctx->pkt_timebase.num && avctx->sample_rate) {
381  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
382  (AVRational){1, avctx->sample_rate},
383  avctx->pkt_timebase);
384  frame->duration = diff_ts;
385  } else
386  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
387 
388  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
389  (int)discard_padding, frame->nb_samples);
390  frame->nb_samples -= discard_padding;
391  }
392  }
393 
394  return 0;
395 }
396 
397 /*
398  * The core of the receive_frame_wrapper for the decoders implementing
399  * the simple API. Certain decoders might consume partial packets without
400  * returning any output, so this function needs to be called in a loop until it
401  * returns EAGAIN.
402  **/
403 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
404 {
405  AVCodecInternal *avci = avctx->internal;
406  AVPacket *const pkt = avci->in_pkt;
407  const FFCodec *const codec = ffcodec(avctx->codec);
408  int got_frame, consumed;
409  int ret;
410 
411  if (!pkt->data && !avci->draining) {
413  ret = ff_decode_get_packet(avctx, pkt);
414  if (ret < 0 && ret != AVERROR_EOF)
415  return ret;
416  }
417 
418  // Some codecs (at least wma lossless) will crash when feeding drain packets
419  // after EOF was signaled.
420  if (avci->draining_done)
421  return AVERROR_EOF;
422 
423  if (!pkt->data &&
424  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
426  return AVERROR_EOF;
427 
428  got_frame = 0;
429 
430  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
431  consumed = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
432  } else {
433  consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
434 
436  frame->pkt_dts = pkt->dts;
437  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
438 #if FF_API_FRAME_PKT
440  if(!avctx->has_b_frames)
441  frame->pkt_pos = pkt->pos;
443 #endif
444  }
445  }
446  emms_c();
447 
448  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
449  ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
450  ? AVERROR(EAGAIN)
451  : 0;
452  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
453  ret = !got_frame ? AVERROR(EAGAIN)
454  : discard_samples(avctx, frame, discarded_samples);
455  }
456 
457  if (ret == AVERROR(EAGAIN))
459 
460  // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
461  // code later will add AVERROR(EAGAIN) to a pointer
462  av_assert0(consumed != AVERROR(EAGAIN));
463  if (consumed < 0)
464  ret = consumed;
465  if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
466  consumed = pkt->size;
467 
468  if (!ret)
469  av_assert0(frame->buf[0]);
470  if (ret == AVERROR(EAGAIN))
471  ret = 0;
472 
473  /* do not stop draining when got_frame != 0 or ret < 0 */
474  if (avci->draining && !got_frame) {
475  if (ret < 0) {
476  /* prevent infinite loop if a decoder wrongly always return error on draining */
477  /* reasonable nb_errors_max = maximum b frames + thread count */
478  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
479  avctx->thread_count : 1);
480 
481  if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
482  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
483  "Stop draining and force EOF.\n");
484  avci->draining_done = 1;
485  ret = AVERROR_BUG;
486  }
487  } else {
488  avci->draining_done = 1;
489  }
490  }
491 
492  if (consumed >= pkt->size || ret < 0) {
494  } else {
495  pkt->data += consumed;
496  pkt->size -= consumed;
500 #if FF_API_FRAME_PKT
501  // See extract_packet_props() comment.
502  avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed;
503 #endif
506  }
507  }
508 
509  return ret;
510 }
511 
512 #if CONFIG_LCMS2
513 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
514 {
515  AVCodecInternal *avci = avctx->internal;
517  AVColorPrimariesDesc coeffs;
518  enum AVColorPrimaries prim;
519  cmsHPROFILE profile;
520  AVFrameSideData *sd;
521  int ret;
522  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
523  return 0;
524 
526  if (!sd || !sd->size)
527  return 0;
528 
529  if (!avci->icc.avctx) {
530  ret = ff_icc_context_init(&avci->icc, avctx);
531  if (ret < 0)
532  return ret;
533  }
534 
535  profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
536  if (!profile)
537  return AVERROR_INVALIDDATA;
538 
539  ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
540  if (!ret)
541  ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
542  cmsCloseProfile(profile);
543  if (ret < 0)
544  return ret;
545 
546  prim = av_csp_primaries_id_from_desc(&coeffs);
547  if (prim != AVCOL_PRI_UNSPECIFIED)
548  frame->color_primaries = prim;
549  if (trc != AVCOL_TRC_UNSPECIFIED)
550  frame->color_trc = trc;
551  return 0;
552 }
553 #else /* !CONFIG_LCMS2 */
555 {
556  return 0;
557 }
558 #endif
559 
560 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
561 {
562  int ret;
563 
564  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
565  frame->color_primaries = avctx->color_primaries;
566  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
567  frame->color_trc = avctx->color_trc;
568  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
569  frame->colorspace = avctx->colorspace;
570  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
571  frame->color_range = avctx->color_range;
572  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
573  frame->chroma_location = avctx->chroma_sample_location;
574 
575  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
576  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
577  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
578  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
579  if (frame->format == AV_SAMPLE_FMT_NONE)
580  frame->format = avctx->sample_fmt;
581  if (!frame->ch_layout.nb_channels) {
582  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
583  if (ret < 0)
584  return ret;
585  }
586 #if FF_API_OLD_CHANNEL_LAYOUT
588  if (!frame->channel_layout)
589  frame->channel_layout = avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
590  avctx->ch_layout.u.mask : 0;
591  if (!frame->channels)
592  frame->channels = avctx->ch_layout.nb_channels;
594 #endif
595  if (!frame->sample_rate)
596  frame->sample_rate = avctx->sample_rate;
597  }
598 
599  return 0;
600 }
601 
603 {
604  int ret;
605  int64_t discarded_samples = 0;
606 
607  while (!frame->buf[0]) {
608  if (discarded_samples > avctx->max_samples)
609  return AVERROR(EAGAIN);
610  ret = decode_simple_internal(avctx, frame, &discarded_samples);
611  if (ret < 0)
612  return ret;
613  }
614 
615  return 0;
616 }
617 
619 {
620  AVCodecInternal *avci = avctx->internal;
621  const FFCodec *const codec = ffcodec(avctx->codec);
622  int ret, ok;
623 
624  av_assert0(!frame->buf[0]);
625 
626  if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
627  ret = codec->cb.receive_frame(avctx, frame);
628  emms_c();
629  if (!ret) {
630  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO)
631  ret = (frame->flags & AV_FRAME_FLAG_DISCARD) ? AVERROR(EAGAIN) : 0;
632  else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
633  int64_t discarded_samples = 0;
634  ret = discard_samples(avctx, frame, &discarded_samples);
635  }
636  }
637  } else
639 
640  if (ret == AVERROR_EOF)
641  avci->draining_done = 1;
642 
643  /* preserve ret */
644  ok = detect_colorspace(avctx, frame);
645  if (ok < 0) {
647  return ok;
648  }
649 
650  if (!ret) {
651  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
652  if (!frame->width)
653  frame->width = avctx->width;
654  if (!frame->height)
655  frame->height = avctx->height;
656  } else
657  frame->flags |= AV_FRAME_FLAG_KEY;
658 
659  ret = fill_frame_props(avctx, frame);
660  if (ret < 0) {
662  return ret;
663  }
664 
665 #if FF_API_FRAME_KEY
667  frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY);
669 #endif
670 #if FF_API_INTERLACED_FRAME
672  frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED);
673  frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
675 #endif
676  frame->best_effort_timestamp = guess_correct_pts(avctx,
677  frame->pts,
678  frame->pkt_dts);
679 
680 #if FF_API_PKT_DURATION
682  frame->pkt_duration = frame->duration;
684 #endif
685 
686  /* the only case where decode data is not set should be decoders
687  * that do not call ff_get_buffer() */
688  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
689  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
690 
691  if (frame->private_ref) {
692  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
693 
694  if (fdd->post_process) {
695  ret = fdd->post_process(avctx, frame);
696  if (ret < 0) {
698  return ret;
699  }
700  }
701  }
702  }
703 
704  /* free the per-frame decode data */
705  av_buffer_unref(&frame->private_ref);
706 
707  return ret;
708 }
709 
711 {
712  AVCodecInternal *avci = avctx->internal;
713  DecodeContext *dc = decode_ctx(avci);
714  int ret;
715 
716  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
717  return AVERROR(EINVAL);
718 
719  if (dc->draining_started)
720  return AVERROR_EOF;
721 
722  if (avpkt && !avpkt->size && avpkt->data)
723  return AVERROR(EINVAL);
724 
725  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
726  if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
727  return AVERROR(EAGAIN);
728  ret = av_packet_ref(avci->buffer_pkt, avpkt);
729  if (ret < 0)
730  return ret;
731  } else
732  dc->draining_started = 1;
733 
734  if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
736  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
737  return ret;
738  }
739 
740  return 0;
741 }
742 
744 {
745  /* make sure we are noisy about decoders returning invalid cropping data */
746  if (frame->crop_left >= INT_MAX - frame->crop_right ||
747  frame->crop_top >= INT_MAX - frame->crop_bottom ||
748  (frame->crop_left + frame->crop_right) >= frame->width ||
749  (frame->crop_top + frame->crop_bottom) >= frame->height) {
750  av_log(avctx, AV_LOG_WARNING,
751  "Invalid cropping information set by a decoder: "
753  "(frame size %dx%d). This is a bug, please report it\n",
754  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
755  frame->width, frame->height);
756  frame->crop_left = 0;
757  frame->crop_right = 0;
758  frame->crop_top = 0;
759  frame->crop_bottom = 0;
760  return 0;
761  }
762 
763  if (!avctx->apply_cropping)
764  return 0;
765 
768 }
769 
770 // make sure frames returned to the caller are valid
772 {
773  if (!frame->buf[0] || frame->format < 0)
774  goto fail;
775 
776  switch (avctx->codec_type) {
777  case AVMEDIA_TYPE_VIDEO:
778  if (frame->width <= 0 || frame->height <= 0)
779  goto fail;
780  break;
781  case AVMEDIA_TYPE_AUDIO:
782  if (!av_channel_layout_check(&frame->ch_layout) ||
783  frame->sample_rate <= 0)
784  goto fail;
785 
786  break;
787  default: av_assert0(0);
788  }
789 
790  return 0;
791 fail:
792  av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
793  "This is a bug, please report it.\n");
794  return AVERROR_BUG;
795 }
796 
798 {
799  AVCodecInternal *avci = avctx->internal;
800  int ret;
801 
802  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
803  return AVERROR(EINVAL);
804 
805  if (avci->buffer_frame->buf[0]) {
807  } else {
809  if (ret < 0)
810  return ret;
811  }
812 
813  ret = frame_validate(avctx, frame);
814  if (ret < 0)
815  goto fail;
816 
817  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
818  ret = apply_cropping(avctx, frame);
819  if (ret < 0)
820  goto fail;
821  }
822 
823  avctx->frame_num++;
824 #if FF_API_AVCTX_FRAME_NUMBER
826  avctx->frame_number = avctx->frame_num;
828 #endif
829 
830 #if FF_API_DROPCHANGED
831  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
832 
833  if (avctx->frame_num == 1) {
834  avci->initial_format = frame->format;
835  switch(avctx->codec_type) {
836  case AVMEDIA_TYPE_VIDEO:
837  avci->initial_width = frame->width;
838  avci->initial_height = frame->height;
839  break;
840  case AVMEDIA_TYPE_AUDIO:
841  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
842  avctx->sample_rate;
843  ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
844  if (ret < 0)
845  goto fail;
846  break;
847  }
848  }
849 
850  if (avctx->frame_num > 1) {
851  int changed = avci->initial_format != frame->format;
852 
853  switch(avctx->codec_type) {
854  case AVMEDIA_TYPE_VIDEO:
855  changed |= avci->initial_width != frame->width ||
856  avci->initial_height != frame->height;
857  break;
858  case AVMEDIA_TYPE_AUDIO:
859  changed |= avci->initial_sample_rate != frame->sample_rate ||
860  avci->initial_sample_rate != avctx->sample_rate ||
862  break;
863  }
864 
865  if (changed) {
866  avci->changed_frames_dropped++;
867  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64
868  " drop count: %d \n",
869  avctx->frame_num, frame->pts,
870  avci->changed_frames_dropped);
872  goto fail;
873  }
874  }
875  }
876 #endif
877  return 0;
878 fail:
880  return ret;
881 }
882 
884 {
885  memset(sub, 0, sizeof(*sub));
886  sub->pts = AV_NOPTS_VALUE;
887 }
888 
889 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
890 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
891  const AVPacket *inpkt, AVPacket *buf_pkt)
892 {
893 #if CONFIG_ICONV
894  iconv_t cd = (iconv_t)-1;
895  int ret = 0;
896  char *inb, *outb;
897  size_t inl, outl;
898 #endif
899 
900  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
901  *outpkt = inpkt;
902  return 0;
903  }
904 
905 #if CONFIG_ICONV
906  inb = inpkt->data;
907  inl = inpkt->size;
908 
909  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
910  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
911  return AVERROR(ERANGE);
912  }
913 
914  cd = iconv_open("UTF-8", avctx->sub_charenc);
915  av_assert0(cd != (iconv_t)-1);
916 
917  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
918  if (ret < 0)
919  goto end;
920  ret = av_packet_copy_props(buf_pkt, inpkt);
921  if (ret < 0)
922  goto end;
923  outb = buf_pkt->data;
924  outl = buf_pkt->size;
925 
926  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
927  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
928  outl >= buf_pkt->size || inl != 0) {
929  ret = FFMIN(AVERROR(errno), -1);
930  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
931  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
932  goto end;
933  }
934  buf_pkt->size -= outl;
935  memset(buf_pkt->data + buf_pkt->size, 0, outl);
936  *outpkt = buf_pkt;
937 
938  ret = 0;
939 end:
940  if (ret < 0)
941  av_packet_unref(buf_pkt);
942  if (cd != (iconv_t)-1)
943  iconv_close(cd);
944  return ret;
945 #else
946  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
947  return AVERROR(EINVAL);
948 #endif
949 }
950 
951 static int utf8_check(const uint8_t *str)
952 {
953  const uint8_t *byte;
954  uint32_t codepoint, min;
955 
956  while (*str) {
957  byte = str;
958  GET_UTF8(codepoint, *(byte++), return 0;);
959  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
960  1 << (5 * (byte - str) - 4);
961  if (codepoint < min || codepoint >= 0x110000 ||
962  codepoint == 0xFFFE /* BOM */ ||
963  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
964  return 0;
965  str = byte;
966  }
967  return 1;
968 }
969 
971  int *got_sub_ptr, const AVPacket *avpkt)
972 {
973  int ret = 0;
974 
975  if (!avpkt->data && avpkt->size) {
976  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
977  return AVERROR(EINVAL);
978  }
979  if (!avctx->codec)
980  return AVERROR(EINVAL);
981  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
982  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
983  return AVERROR(EINVAL);
984  }
985 
986  *got_sub_ptr = 0;
988 
989  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
990  AVCodecInternal *avci = avctx->internal;
991  const AVPacket *pkt;
992 
993  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
994  if (ret < 0)
995  return ret;
996 
997  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
998  sub->pts = av_rescale_q(avpkt->pts,
999  avctx->pkt_timebase, AV_TIME_BASE_Q);
1000  ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
1001  if (pkt == avci->buffer_pkt) // did we recode?
1002  av_packet_unref(avci->buffer_pkt);
1003  if (ret < 0) {
1004  *got_sub_ptr = 0;
1005  avsubtitle_free(sub);
1006  return ret;
1007  }
1008  av_assert1(!sub->num_rects || *got_sub_ptr);
1009 
1010  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1011  avctx->pkt_timebase.num) {
1012  AVRational ms = { 1, 1000 };
1013  sub->end_display_time = av_rescale_q(avpkt->duration,
1014  avctx->pkt_timebase, ms);
1015  }
1016 
1018  sub->format = 0;
1019  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1020  sub->format = 1;
1021 
1022  for (unsigned i = 0; i < sub->num_rects; i++) {
1024  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1025  av_log(avctx, AV_LOG_ERROR,
1026  "Invalid UTF-8 in decoded subtitles text; "
1027  "maybe missing -sub_charenc option\n");
1028  avsubtitle_free(sub);
1029  *got_sub_ptr = 0;
1030  return AVERROR_INVALIDDATA;
1031  }
1032  }
1033 
1034  if (*got_sub_ptr)
1035  avctx->frame_num++;
1036 #if FF_API_AVCTX_FRAME_NUMBER
1038  avctx->frame_number = avctx->frame_num;
1040 #endif
1041  }
1042 
1043  return ret;
1044 }
1045 
1047  const enum AVPixelFormat *fmt)
1048 {
1049  const AVPixFmtDescriptor *desc;
1050  const AVCodecHWConfig *config;
1051  int i, n;
1052 
1053  // If a device was supplied when the codec was opened, assume that the
1054  // user wants to use it.
1055  if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
1056  AVHWDeviceContext *device_ctx =
1058  for (i = 0;; i++) {
1059  config = &ffcodec(avctx->codec)->hw_configs[i]->public;
1060  if (!config)
1061  break;
1062  if (!(config->methods &
1064  continue;
1065  if (device_ctx->type != config->device_type)
1066  continue;
1067  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1068  if (config->pix_fmt == fmt[n])
1069  return fmt[n];
1070  }
1071  }
1072  }
1073  // No device or other setup, so we have to choose from things which
1074  // don't any other external information.
1075 
1076  // If the last element of the list is a software format, choose it
1077  // (this should be best software format if any exist).
1078  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1079  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1080  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1081  return fmt[n - 1];
1082 
1083  // Finally, traverse the list in order and choose the first entry
1084  // with no external dependencies (if there is no hardware configuration
1085  // information available then this just picks the first entry).
1086  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1087  for (i = 0;; i++) {
1088  config = avcodec_get_hw_config(avctx->codec, i);
1089  if (!config)
1090  break;
1091  if (config->pix_fmt == fmt[n])
1092  break;
1093  }
1094  if (!config) {
1095  // No specific config available, so the decoder must be able
1096  // to handle this format without any additional setup.
1097  return fmt[n];
1098  }
1099  if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1100  // Usable with only internal setup.
1101  return fmt[n];
1102  }
1103  }
1104 
1105  // Nothing is usable, give up.
1106  return AV_PIX_FMT_NONE;
1107 }
1108 
1110  enum AVHWDeviceType dev_type)
1111 {
1112  AVHWDeviceContext *device_ctx;
1113  AVHWFramesContext *frames_ctx;
1114  int ret;
1115 
1116  if (!avctx->hwaccel)
1117  return AVERROR(ENOSYS);
1118 
1119  if (avctx->hw_frames_ctx)
1120  return 0;
1121  if (!avctx->hw_device_ctx) {
1122  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1123  "required for hardware accelerated decoding.\n");
1124  return AVERROR(EINVAL);
1125  }
1126 
1127  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1128  if (device_ctx->type != dev_type) {
1129  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1130  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1131  av_hwdevice_get_type_name(device_ctx->type));
1132  return AVERROR(EINVAL);
1133  }
1134 
1136  avctx->hw_device_ctx,
1137  avctx->hwaccel->pix_fmt,
1138  &avctx->hw_frames_ctx);
1139  if (ret < 0)
1140  return ret;
1141 
1142  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1143 
1144 
1145  if (frames_ctx->initial_pool_size) {
1146  // We guarantee 4 base work surfaces. The function above guarantees 1
1147  // (the absolute minimum), so add the missing count.
1148  frames_ctx->initial_pool_size += 3;
1149  }
1150 
1152  if (ret < 0) {
1153  av_buffer_unref(&avctx->hw_frames_ctx);
1154  return ret;
1155  }
1156 
1157  return 0;
1158 }
1159 
1161  AVBufferRef *device_ref,
1163  AVBufferRef **out_frames_ref)
1164 {
1165  AVBufferRef *frames_ref = NULL;
1166  const AVCodecHWConfigInternal *hw_config;
1167  const FFHWAccel *hwa;
1168  int i, ret;
1169 
1170  for (i = 0;; i++) {
1171  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1172  if (!hw_config)
1173  return AVERROR(ENOENT);
1174  if (hw_config->public.pix_fmt == hw_pix_fmt)
1175  break;
1176  }
1177 
1178  hwa = hw_config->hwaccel;
1179  if (!hwa || !hwa->frame_params)
1180  return AVERROR(ENOENT);
1181 
1182  frames_ref = av_hwframe_ctx_alloc(device_ref);
1183  if (!frames_ref)
1184  return AVERROR(ENOMEM);
1185 
1186  if (!avctx->internal->hwaccel_priv_data) {
1187  avctx->internal->hwaccel_priv_data =
1188  av_mallocz(hwa->priv_data_size);
1189  if (!avctx->internal->hwaccel_priv_data) {
1190  av_buffer_unref(&frames_ref);
1191  return AVERROR(ENOMEM);
1192  }
1193  }
1194 
1195  ret = hwa->frame_params(avctx, frames_ref);
1196  if (ret >= 0) {
1197  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1198 
1199  if (frames_ctx->initial_pool_size) {
1200  // If the user has requested that extra output surfaces be
1201  // available then add them here.
1202  if (avctx->extra_hw_frames > 0)
1203  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1204 
1205  // If frame threading is enabled then an extra surface per thread
1206  // is also required.
1207  if (avctx->active_thread_type & FF_THREAD_FRAME)
1208  frames_ctx->initial_pool_size += avctx->thread_count;
1209  }
1210 
1211  *out_frames_ref = frames_ref;
1212  } else {
1213  av_buffer_unref(&frames_ref);
1214  }
1215  return ret;
1216 }
1217 
1218 static int hwaccel_init(AVCodecContext *avctx,
1219  const FFHWAccel *hwaccel)
1220 {
1221  int err;
1222 
1225  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1226  hwaccel->p.name);
1227  return AVERROR_PATCHWELCOME;
1228  }
1229 
1230  if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1231  avctx->internal->hwaccel_priv_data =
1232  av_mallocz(hwaccel->priv_data_size);
1233  if (!avctx->internal->hwaccel_priv_data)
1234  return AVERROR(ENOMEM);
1235  }
1236 
1237  avctx->hwaccel = &hwaccel->p;
1238  if (hwaccel->init) {
1239  err = hwaccel->init(avctx);
1240  if (err < 0) {
1241  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1242  "hwaccel initialisation returned error.\n",
1243  av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1245  avctx->hwaccel = NULL;
1246  return err;
1247  }
1248  }
1249 
1250  return 0;
1251 }
1252 
1254 {
1255  if (FF_HW_HAS_CB(avctx, uninit))
1256  FF_HW_SIMPLE_CALL(avctx, uninit);
1257 
1259 
1260  avctx->hwaccel = NULL;
1261 
1262  av_buffer_unref(&avctx->hw_frames_ctx);
1263 }
1264 
1265 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1266 {
1267  const AVPixFmtDescriptor *desc;
1268  enum AVPixelFormat *choices;
1269  enum AVPixelFormat ret, user_choice;
1270  const AVCodecHWConfigInternal *hw_config;
1271  const AVCodecHWConfig *config;
1272  int i, n, err;
1273 
1274  // Find end of list.
1275  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1276  // Must contain at least one entry.
1277  av_assert0(n >= 1);
1278  // If a software format is available, it must be the last entry.
1279  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1280  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1281  // No software format is available.
1282  } else {
1283  avctx->sw_pix_fmt = fmt[n - 1];
1284  }
1285 
1286  choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1287  if (!choices)
1288  return AV_PIX_FMT_NONE;
1289 
1290  for (;;) {
1291  // Remove the previous hwaccel, if there was one.
1292  ff_hwaccel_uninit(avctx);
1293 
1294  user_choice = avctx->get_format(avctx, choices);
1295  if (user_choice == AV_PIX_FMT_NONE) {
1296  // Explicitly chose nothing, give up.
1297  ret = AV_PIX_FMT_NONE;
1298  break;
1299  }
1300 
1301  desc = av_pix_fmt_desc_get(user_choice);
1302  if (!desc) {
1303  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1304  "get_format() callback.\n");
1305  ret = AV_PIX_FMT_NONE;
1306  break;
1307  }
1308  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1309  desc->name);
1310 
1311  for (i = 0; i < n; i++) {
1312  if (choices[i] == user_choice)
1313  break;
1314  }
1315  if (i == n) {
1316  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1317  "%s not in possible list.\n", desc->name);
1318  ret = AV_PIX_FMT_NONE;
1319  break;
1320  }
1321 
1322  if (ffcodec(avctx->codec)->hw_configs) {
1323  for (i = 0;; i++) {
1324  hw_config = ffcodec(avctx->codec)->hw_configs[i];
1325  if (!hw_config)
1326  break;
1327  if (hw_config->public.pix_fmt == user_choice)
1328  break;
1329  }
1330  } else {
1331  hw_config = NULL;
1332  }
1333 
1334  if (!hw_config) {
1335  // No config available, so no extra setup required.
1336  ret = user_choice;
1337  break;
1338  }
1339  config = &hw_config->public;
1340 
1341  if (config->methods &
1343  avctx->hw_frames_ctx) {
1344  const AVHWFramesContext *frames_ctx =
1346  if (frames_ctx->format != user_choice) {
1347  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1348  "does not match the format of the provided frames "
1349  "context.\n", desc->name);
1350  goto try_again;
1351  }
1352  } else if (config->methods &
1354  avctx->hw_device_ctx) {
1355  const AVHWDeviceContext *device_ctx =
1357  if (device_ctx->type != config->device_type) {
1358  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1359  "does not match the type of the provided device "
1360  "context.\n", desc->name);
1361  goto try_again;
1362  }
1363  } else if (config->methods &
1365  // Internal-only setup, no additional configuration.
1366  } else if (config->methods &
1368  // Some ad-hoc configuration we can't see and can't check.
1369  } else {
1370  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1371  "missing configuration.\n", desc->name);
1372  goto try_again;
1373  }
1374  if (hw_config->hwaccel) {
1375  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1376  "initialisation.\n", desc->name);
1377  err = hwaccel_init(avctx, hw_config->hwaccel);
1378  if (err < 0)
1379  goto try_again;
1380  }
1381  ret = user_choice;
1382  break;
1383 
1384  try_again:
1385  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1386  "get_format() without it.\n", desc->name);
1387  for (i = 0; i < n; i++) {
1388  if (choices[i] == user_choice)
1389  break;
1390  }
1391  for (; i + 1 < n; i++)
1392  choices[i] = choices[i + 1];
1393  --n;
1394  }
1395 
1396  if (ret < 0)
1397  ff_hwaccel_uninit(avctx);
1398 
1399  av_freep(&choices);
1400  return ret;
1401 }
1402 
1404 {
1405  size_t size;
1406  const uint8_t *side_metadata;
1407 
1408  AVDictionary **frame_md = &frame->metadata;
1409 
1410  side_metadata = av_packet_get_side_data(avpkt,
1412  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1413 }
1414 
1416  AVFrame *frame, const AVPacket *pkt)
1417 {
1418  static const struct {
1419  enum AVPacketSideDataType packet;
1421  } sd[] = {
1435  };
1436 
1437  frame->pts = pkt->pts;
1438  frame->duration = pkt->duration;
1439 #if FF_API_FRAME_PKT
1441  frame->pkt_pos = pkt->pos;
1442  frame->pkt_size = pkt->size;
1444 #endif
1445 
1446  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1447  size_t size;
1448  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1449  if (packet_sd) {
1451  sd[i].frame,
1452  size);
1453  if (!frame_sd)
1454  return AVERROR(ENOMEM);
1455 
1456  memcpy(frame_sd->data, packet_sd, size);
1457  }
1458  }
1460 
1461  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1462  frame->flags |= AV_FRAME_FLAG_DISCARD;
1463  } else {
1464  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1465  }
1466 
1467  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1468  int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1469  if (ret < 0)
1470  return ret;
1471  frame->opaque = pkt->opaque;
1472  }
1473 
1474  return 0;
1475 }
1476 
1478 {
1479  const AVPacket *pkt = avctx->internal->last_pkt_props;
1480  int ret;
1481 
1484  if (ret < 0)
1485  return ret;
1486 #if FF_API_FRAME_PKT
1488  frame->pkt_size = pkt->stream_index;
1490 #endif
1491  }
1492 #if FF_API_REORDERED_OPAQUE
1494  frame->reordered_opaque = avctx->reordered_opaque;
1496 #endif
1497 
1498  ret = fill_frame_props(avctx, frame);
1499  if (ret < 0)
1500  return ret;
1501 
1502  switch (avctx->codec->type) {
1503  case AVMEDIA_TYPE_VIDEO:
1504  if (frame->width && frame->height &&
1505  av_image_check_sar(frame->width, frame->height,
1506  frame->sample_aspect_ratio) < 0) {
1507  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1508  frame->sample_aspect_ratio.num,
1509  frame->sample_aspect_ratio.den);
1510  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1511  }
1512  break;
1513  }
1514  return 0;
1515 }
1516 
1518 {
1519  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1520  int i;
1521  int num_planes = av_pix_fmt_count_planes(frame->format);
1523  int flags = desc ? desc->flags : 0;
1524  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1525  num_planes = 2;
1526  for (i = 0; i < num_planes; i++) {
1527  av_assert0(frame->data[i]);
1528  }
1529  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1530  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1531  if (frame->data[i])
1532  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1533  frame->data[i] = NULL;
1534  }
1535  }
1536 }
1537 
1538 static void decode_data_free(void *opaque, uint8_t *data)
1539 {
1541 
1542  if (fdd->post_process_opaque_free)
1544 
1545  if (fdd->hwaccel_priv_free)
1546  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1547 
1548  av_freep(&fdd);
1549 }
1550 
1552 {
1553  AVBufferRef *fdd_buf;
1554  FrameDecodeData *fdd;
1555 
1556  av_assert1(!frame->private_ref);
1557  av_buffer_unref(&frame->private_ref);
1558 
1559  fdd = av_mallocz(sizeof(*fdd));
1560  if (!fdd)
1561  return AVERROR(ENOMEM);
1562 
1563  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1565  if (!fdd_buf) {
1566  av_freep(&fdd);
1567  return AVERROR(ENOMEM);
1568  }
1569 
1570  frame->private_ref = fdd_buf;
1571 
1572  return 0;
1573 }
1574 
1576 {
1577  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1578  int override_dimensions = 1;
1579  int ret;
1580 
1582 
1583  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1584  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1585  (ret = av_image_check_size2(FFALIGN(avctx->width, STRIDE_ALIGN), avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) {
1586  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1587  ret = AVERROR(EINVAL);
1588  goto fail;
1589  }
1590 
1591  if (frame->width <= 0 || frame->height <= 0) {
1592  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1593  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1594  override_dimensions = 0;
1595  }
1596 
1597  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1598  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1599  ret = AVERROR(EINVAL);
1600  goto fail;
1601  }
1602  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1603 #if FF_API_OLD_CHANNEL_LAYOUT
1605  /* compat layer for old-style get_buffer() implementations */
1606  avctx->channels = avctx->ch_layout.nb_channels;
1607  avctx->channel_layout = (avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) ?
1608  avctx->ch_layout.u.mask : 0;
1610 #endif
1611 
1612  if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1613  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1614  ret = AVERROR(EINVAL);
1615  goto fail;
1616  }
1617  }
1618  ret = ff_decode_frame_props(avctx, frame);
1619  if (ret < 0)
1620  goto fail;
1621 
1622  if (hwaccel) {
1623  if (hwaccel->alloc_frame) {
1624  ret = hwaccel->alloc_frame(avctx, frame);
1625  goto end;
1626  }
1627  } else
1628  avctx->sw_pix_fmt = avctx->pix_fmt;
1629 
1630  ret = avctx->get_buffer2(avctx, frame, flags);
1631  if (ret < 0)
1632  goto fail;
1633 
1635 
1637  if (ret < 0)
1638  goto fail;
1639 
1640 end:
1641  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1643  frame->width = avctx->width;
1644  frame->height = avctx->height;
1645  }
1646 
1647 fail:
1648  if (ret < 0) {
1649  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1651  }
1652 
1653  return ret;
1654 }
1655 
1657 {
1658  AVFrame *tmp;
1659  int ret;
1660 
1662 
1663  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1664  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1665  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1667  }
1668 
1669  if (!frame->data[0])
1670  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1671 
1673  return ff_decode_frame_props(avctx, frame);
1674 
1675  tmp = av_frame_alloc();
1676  if (!tmp)
1677  return AVERROR(ENOMEM);
1678 
1680 
1682  if (ret < 0) {
1683  av_frame_free(&tmp);
1684  return ret;
1685  }
1686 
1688  av_frame_free(&tmp);
1689 
1690  return 0;
1691 }
1692 
1694 {
1695  int ret = reget_buffer_internal(avctx, frame, flags);
1696  if (ret < 0)
1697  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1698  return ret;
1699 }
1700 
1702 {
1703  AVCodecInternal *avci = avctx->internal;
1704  int ret = 0;
1705 
1706  /* if the decoder init function was already called previously,
1707  * free the already allocated subtitle_header before overwriting it */
1708  av_freep(&avctx->subtitle_header);
1709 
1710  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1711  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1712  avctx->codec->max_lowres);
1713  avctx->lowres = avctx->codec->max_lowres;
1714  }
1715  if (avctx->sub_charenc) {
1716  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1717  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1718  "supported with subtitles codecs\n");
1719  return AVERROR(EINVAL);
1720  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1721  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1722  "subtitles character encoding will be ignored\n",
1723  avctx->codec_descriptor->name);
1725  } else {
1726  /* input character encoding is set for a text based subtitle
1727  * codec at this point */
1730 
1732 #if CONFIG_ICONV
1733  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1734  if (cd == (iconv_t)-1) {
1735  ret = AVERROR(errno);
1736  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1737  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1738  return ret;
1739  }
1740  iconv_close(cd);
1741 #else
1742  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1743  "conversion needs a libavcodec built with iconv support "
1744  "for this codec\n");
1745  return AVERROR(ENOSYS);
1746 #endif
1747  }
1748  }
1749  }
1750 
1752  avctx->pts_correction_num_faulty_dts = 0;
1753  avctx->pts_correction_last_pts =
1754  avctx->pts_correction_last_dts = INT64_MIN;
1755 
1756  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1758  av_log(avctx, AV_LOG_WARNING,
1759  "gray decoding requested but not enabled at configuration time\n");
1760  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1762  }
1763 
1764  avci->in_pkt = av_packet_alloc();
1765  avci->last_pkt_props = av_packet_alloc();
1766  if (!avci->in_pkt || !avci->last_pkt_props)
1767  return AVERROR(ENOMEM);
1768 
1769  ret = decode_bsfs_init(avctx);
1770  if (ret < 0)
1771  return ret;
1772 
1773 #if FF_API_DROPCHANGED
1774  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED)
1775  av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n");
1776 #endif
1777 
1778  return 0;
1779 }
1780 
1781 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1782 {
1783  size_t size;
1784  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1785 
1786  if (pal && size == AVPALETTE_SIZE) {
1787  memcpy(dst, pal, AVPALETTE_SIZE);
1788  return 1;
1789  } else if (pal) {
1790  av_log(logctx, AV_LOG_ERROR,
1791  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1792  }
1793  return 0;
1794 }
1795 
1796 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private,
1797  AVBufferRef **hwaccel_priv_buf)
1798 {
1799  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1800  AVBufferRef *ref;
1801  AVHWFramesContext *frames_ctx;
1802  uint8_t *data;
1803 
1804  if (!hwaccel || !hwaccel->frame_priv_data_size)
1805  return 0;
1806 
1807  av_assert0(!*hwaccel_picture_private);
1808  data = av_mallocz(hwaccel->frame_priv_data_size);
1809  if (!data)
1810  return AVERROR(ENOMEM);
1811 
1812  frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
1813 
1815  hwaccel->free_frame_priv,
1816  frames_ctx->device_ctx, 0);
1817  if (!ref) {
1818  av_free(data);
1819  return AVERROR(ENOMEM);
1820  }
1821 
1822  *hwaccel_priv_buf = ref;
1823  *hwaccel_picture_private = ref->data;
1824 
1825  return 0;
1826 }
1827 
1829 {
1830  AVCodecInternal *avci = avctx->internal;
1831  DecodeContext *dc = decode_ctx(avci);
1832 
1834  av_packet_unref(avci->in_pkt);
1835 
1836  avctx->pts_correction_last_pts =
1837  avctx->pts_correction_last_dts = INT64_MIN;
1838 
1839  av_bsf_flush(avci->bsf);
1840 
1841  dc->nb_draining_errors = 0;
1842  dc->draining_started = 0;
1843 }
1844 
1846 {
1847  return av_mallocz(sizeof(DecodeContext));
1848 }
AVSubtitle
Definition: avcodec.h:2263
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:143
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_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:423
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1431
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:1218
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:244
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:45
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
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:2268
opt.h
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:708
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:204
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1025
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:566
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1265
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:743
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1060
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:824
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:812
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
AVColorPrimariesDesc
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition: csp.h:78
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:322
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2936
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:2163
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:100
AV_PKT_FLAG_DISCARD
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
Definition: packet.h:436
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:119
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1408
AV_CODEC_FLAG_UNALIGNED
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e....
Definition: avcodec.h:212
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h: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
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2267
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:602
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:37
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:34
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:334
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h: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:1018
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:143
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVHWAccel::capabilities
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2156
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:569
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
data
const char data[16]
Definition: mxf.c:148
FFCodec
Definition: codec_internal.h:127
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1770
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:458
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
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:53
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:173
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
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:1846
AVDictionary
Definition: dict.c:34
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:306
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:541
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1046
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:706
AVChannelLayout::mask
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
Definition: channel_layout.h:333
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
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:91
decode_ctx
static DecodeContext * decode_ctx(AVCodecInternal *avci)
Definition: decode.c:68
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:1845
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
AVChannelLayout::u
union AVChannelLayout::@331 u
Details about which channels are present in this layout.
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:995
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:309
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1253
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:641
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
decode_get_packet
static int decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: decode.c:217
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:207
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2976
DecodeContext::nb_draining_errors
int nb_draining_errors
Definition: decode.c:60
FFHWAccel::alloc_frame
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: hwaccel_internal.h:42
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:291
fifo.h
finish
static void finish(void)
Definition: movenc.c:342
FFHWAccel
Definition: hwaccel_internal.h:33
bsf.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:446
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:410
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:49
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2101
fail
#define fail()
Definition: checkasm.h:138
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:1528
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:1844
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:517
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:47
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:1415
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:1403
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:632
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
guess_correct_pts
static int64_t guess_correct_pts(AVCodecContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
Definition: decode.c:279
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2041
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2258
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:411
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:100
AVCodecContext::get_buffer2
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1233
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:470
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:970
FFHWAccel::free_frame_priv
void(* free_frame_priv)(void *hwctx, uint8_t *data)
Callback to free the hwaccel-specific frame data.
Definition: hwaccel_internal.h:157
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:236
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1011
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
AVCodecContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
Definition: avcodec.h:1825
ff_decode_receive_frame
int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
Definition: decode.c:797
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
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
FFHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: hwaccel_internal.h:105
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:740
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:459
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:883
FrameDecodeData::post_process_opaque
void * post_process_opaque
Definition: decode.h:46
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:98
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1517
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:134
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:51
FFHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: hwaccel_internal.h:111
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
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:417
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:395
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_PKT_DATA_ICC_PROFILE
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition: packet.h:275
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:300
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVCodecHWConfig::pix_fmt
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:350
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2269
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:1953
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:93
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:399
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:544
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:1026
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:305
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1538
ff_decode_get_hw_frames_ctx
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
Definition: decode.c:1109
DecodeContext::draining_started
int draining_started
The caller has submitted a NULL packet on input.
Definition: decode.c:65
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:140
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:1835
ff_decode_internal_alloc
AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:1845
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:380
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:951
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:1828
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:2011
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1035
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::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:472
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
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:142
FFCodec::cb
union FFCodec::@53 cb
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:390
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:251
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:431
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:136
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:176
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:889
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
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:635
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private, AVBufferRef **hwaccel_priv_buf)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:1796
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:84
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
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:83
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1520
FFHWAccel::init
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: hwaccel_internal.h:125
f
f
Definition: af_crystalizer.c:121
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:524
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
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:314
AVPacket::size
int size
Definition: packet.h:375
ff_thread_decode_frame
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
Definition: pthread_frame.c:501
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
byte
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:99
AVCodecContext::extra_hw_frames
int extra_hw_frames
Definition: avcodec.h:2025
codec_internal.h
FrameDecodeData::post_process
int(* post_process)(void *logctx, AVFrame *frame)
The callback to perform some delayed processing on the frame right before it is returned to the calle...
Definition: decode.h:45
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:124
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:899
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
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:141
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:78
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1076
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:1811
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:771
AVFrameSideData::data
uint8_t * data
Definition: frame.h:248
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:325
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:666
fill_frame_props
static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:560
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:689
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2266
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:343
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:919
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:1826
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:1827
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:118
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:63
AVCodecInternal
Definition: internal.h:52
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
detect_colorspace
static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: decode.c:554
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:938
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:1539
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2129
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:710
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:167
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:386
bprint.h
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVSubtitle::format
uint16_t format
Definition: avcodec.h:2264
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:142
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1656
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:618
internal.h
common.h
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:77
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:243
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:1828
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1701
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
DecodeContext::avci
AVCodecInternal avci
Definition: decode.c:57
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:649
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
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:1975
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
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1042
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:2111
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:598
AVCodecContext::height
int height
Definition: avcodec.h:617
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:403
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:654
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
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:1934
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:1843
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2112
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:1160
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:1693
ret
ret
Definition: filter_design.txt:187
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:79
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:149
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1367
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:912
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:292
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:141
apply_param_change
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:73
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:1477
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:437
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1547
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1818
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, const AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:890
channel_layout.h
avcodec_internal.h
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:329
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:165
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:636
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
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:2051
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
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:376
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:856
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:135
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:643
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:129
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:632
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:199
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:445
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:632
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_bsf_list_parse_str
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
Definition: bsf.c:526
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:338
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:398
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1551
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:144
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:376
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:617
bytestream.h
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:52
imgutils.h
AVCodecContext::frame_number
attribute_deprecated int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1102
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:467
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:341
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:285
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1804
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:323
avstring.h
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1781
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:182
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:2150
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:818
DecodeContext
Definition: decode.c:56
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: decode.h:129
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:386
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2856
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:1847
min
float min
Definition: vorbis_enc_data.h:429
intmath.h