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"
33 #include "libavutil/common.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/intmath.h"
39 #include "libavutil/opt.h"
40 
41 #include "avcodec.h"
42 #include "bytestream.h"
43 #include "decode.h"
44 #include "hwconfig.h"
45 #include "internal.h"
46 #include "thread.h"
47 
48 typedef struct FramePool {
49  /**
50  * Pools for each data plane. For audio all the planes have the same size,
51  * so only pools[0] is used.
52  */
54 
55  /*
56  * Pool parameters
57  */
58  int format;
59  int width, height;
61  int linesize[4];
62  int planes;
63  int channels;
64  int samples;
65 } FramePool;
66 
67 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
68 {
69  int ret;
71  const uint8_t *data;
72  uint32_t flags;
73  int64_t val;
74 
76  if (!data)
77  return 0;
78 
79  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
80  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
81  "changes, but PARAM_CHANGE side data was sent to it.\n");
82  ret = AVERROR(EINVAL);
83  goto fail2;
84  }
85 
86  if (size < 4)
87  goto fail;
88 
89  flags = bytestream_get_le32(&data);
90  size -= 4;
91 
93  if (size < 4)
94  goto fail;
95  val = bytestream_get_le32(&data);
96  if (val <= 0 || val > INT_MAX) {
97  av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
99  goto fail2;
100  }
101  avctx->channels = val;
102  size -= 4;
103  }
105  if (size < 8)
106  goto fail;
107  avctx->channel_layout = bytestream_get_le64(&data);
108  size -= 8;
109  }
111  if (size < 4)
112  goto fail;
113  val = bytestream_get_le32(&data);
114  if (val <= 0 || val > INT_MAX) {
115  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
117  goto fail2;
118  }
119  avctx->sample_rate = val;
120  size -= 4;
121  }
123  if (size < 8)
124  goto fail;
125  avctx->width = bytestream_get_le32(&data);
126  avctx->height = bytestream_get_le32(&data);
127  size -= 8;
128  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
129  if (ret < 0)
130  goto fail2;
131  }
132 
133  return 0;
134 fail:
135  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
137 fail2:
138  if (ret < 0) {
139  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
140  if (avctx->err_recognition & AV_EF_EXPLODE)
141  return ret;
142  }
143  return 0;
144 }
145 
146 #define IS_EMPTY(pkt) (!(pkt)->data)
147 
148 static int copy_packet_props(AVPacket *dst, const AVPacket *src)
149 {
150  int ret = av_packet_copy_props(dst, src);
151  if (ret < 0)
152  return ret;
153 
154  dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
155  dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
156 
157  return 0;
158 }
159 
161 {
162  AVPacket tmp = { 0 };
163  int ret = 0;
164 
165  if (IS_EMPTY(avci->last_pkt_props)) {
166  if (av_fifo_size(avci->pkt_props) >= sizeof(*pkt)) {
168  sizeof(*avci->last_pkt_props), NULL);
169  } else
170  return copy_packet_props(avci->last_pkt_props, pkt);
171  }
172 
173  if (av_fifo_space(avci->pkt_props) < sizeof(*pkt)) {
174  ret = av_fifo_grow(avci->pkt_props, sizeof(*pkt));
175  if (ret < 0)
176  return ret;
177  }
178 
180  if (ret < 0)
181  return ret;
182 
183  av_fifo_generic_write(avci->pkt_props, &tmp, sizeof(tmp), NULL);
184 
185  return 0;
186 }
187 
189 {
190  AVCodecInternal *avci = avctx->internal;
191  int ret;
192 
193  if (avci->bsf)
194  return 0;
195 
196  ret = av_bsf_list_parse_str(avctx->codec->bsfs, &avci->bsf);
197  if (ret < 0) {
198  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", avctx->codec->bsfs, av_err2str(ret));
199  if (ret != AVERROR(ENOMEM))
200  ret = AVERROR_BUG;
201  goto fail;
202  }
203 
204  /* We do not currently have an API for passing the input timebase into decoders,
205  * but no filters used here should actually need it.
206  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
207  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
209  if (ret < 0)
210  goto fail;
211 
212  ret = av_bsf_init(avci->bsf);
213  if (ret < 0)
214  goto fail;
215 
216  return 0;
217 fail:
218  av_bsf_free(&avci->bsf);
219  return ret;
220 }
221 
223 {
224  AVCodecInternal *avci = avctx->internal;
225  int ret;
226 
227  if (avci->draining)
228  return AVERROR_EOF;
229 
230  ret = av_bsf_receive_packet(avci->bsf, pkt);
231  if (ret == AVERROR_EOF)
232  avci->draining = 1;
233  if (ret < 0)
234  return ret;
235 
238  if (ret < 0)
239  goto finish;
240  }
241 
242  ret = apply_param_change(avctx, pkt);
243  if (ret < 0)
244  goto finish;
245 
246 #if FF_API_OLD_ENCDEC
247  if (avctx->codec->receive_frame)
248  avci->compat_decode_consumed += pkt->size;
249 #endif
250 
251  return 0;
252 finish:
254  return ret;
255 }
256 
257 /**
258  * Attempt to guess proper monotonic timestamps for decoded video frames
259  * which might have incorrect times. Input timestamps may wrap around, in
260  * which case the output will as well.
261  *
262  * @param pts the pts field of the decoded AVPacket, as passed through
263  * AVFrame.pts
264  * @param dts the dts field of the decoded AVPacket
265  * @return one of the input values, may be AV_NOPTS_VALUE
266  */
268  int64_t reordered_pts, int64_t dts)
269 {
270  int64_t pts = AV_NOPTS_VALUE;
271 
272  if (dts != AV_NOPTS_VALUE) {
273  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
274  ctx->pts_correction_last_dts = dts;
275  } else if (reordered_pts != AV_NOPTS_VALUE)
276  ctx->pts_correction_last_dts = reordered_pts;
277 
278  if (reordered_pts != AV_NOPTS_VALUE) {
279  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
280  ctx->pts_correction_last_pts = reordered_pts;
281  } else if(dts != AV_NOPTS_VALUE)
282  ctx->pts_correction_last_pts = dts;
283 
284  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
285  && reordered_pts != AV_NOPTS_VALUE)
286  pts = reordered_pts;
287  else
288  pts = dts;
289 
290  return pts;
291 }
292 
293 /*
294  * The core of the receive_frame_wrapper for the decoders implementing
295  * the simple API. Certain decoders might consume partial packets without
296  * returning any output, so this function needs to be called in a loop until it
297  * returns EAGAIN.
298  **/
299 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
300 {
301  AVCodecInternal *avci = avctx->internal;
302  DecodeSimpleContext *ds = &avci->ds;
303  AVPacket *pkt = ds->in_pkt;
304  int got_frame, actual_got_frame;
305  int ret;
306 
307  if (!pkt->data && !avci->draining) {
309  ret = ff_decode_get_packet(avctx, pkt);
310  if (ret < 0 && ret != AVERROR_EOF)
311  return ret;
312  }
313 
314  // Some codecs (at least wma lossless) will crash when feeding drain packets
315  // after EOF was signaled.
316  if (avci->draining_done)
317  return AVERROR_EOF;
318 
319  if (!pkt->data &&
320  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
322  return AVERROR_EOF;
323 
324  got_frame = 0;
325 
326  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
327  ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
328  } else {
329  ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
330 
332  frame->pkt_dts = pkt->dts;
333  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
334  if(!avctx->has_b_frames)
335  frame->pkt_pos = pkt->pos;
336  //FIXME these should be under if(!avctx->has_b_frames)
337  /* get_buffer is supposed to set frame parameters */
338  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
339  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
340  if (!frame->width) frame->width = avctx->width;
341  if (!frame->height) frame->height = avctx->height;
342  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
343  }
344  }
345  }
346  emms_c();
347  actual_got_frame = got_frame;
348 
349  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
350  if (frame->flags & AV_FRAME_FLAG_DISCARD)
351  got_frame = 0;
352  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
353  uint8_t *side;
354  buffer_size_t side_size;
355  uint32_t discard_padding = 0;
356  uint8_t skip_reason = 0;
357  uint8_t discard_reason = 0;
358 
359  if (ret >= 0 && got_frame) {
360  if (frame->format == AV_SAMPLE_FMT_NONE)
361  frame->format = avctx->sample_fmt;
362  if (!frame->channel_layout)
363  frame->channel_layout = avctx->channel_layout;
364  if (!frame->channels)
365  frame->channels = avctx->channels;
366  if (!frame->sample_rate)
367  frame->sample_rate = avctx->sample_rate;
368  }
369 
371  if(side && side_size>=10) {
372  avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
373  discard_padding = AV_RL32(side + 4);
374  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
375  avci->skip_samples, (int)discard_padding);
376  skip_reason = AV_RL8(side + 8);
377  discard_reason = AV_RL8(side + 9);
378  }
379 
380  if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
381  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
382  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
383  got_frame = 0;
384  *discarded_samples += frame->nb_samples;
385  }
386 
387  if (avci->skip_samples > 0 && got_frame &&
388  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
389  if(frame->nb_samples <= avci->skip_samples){
390  got_frame = 0;
391  *discarded_samples += frame->nb_samples;
392  avci->skip_samples -= frame->nb_samples;
393  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
394  avci->skip_samples);
395  } else {
396  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
397  frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
398  if(avctx->pkt_timebase.num && avctx->sample_rate) {
399  int64_t diff_ts = av_rescale_q(avci->skip_samples,
400  (AVRational){1, avctx->sample_rate},
401  avctx->pkt_timebase);
402  if(frame->pts!=AV_NOPTS_VALUE)
403  frame->pts += diff_ts;
404 #if FF_API_PKT_PTS
406  if(frame->pkt_pts!=AV_NOPTS_VALUE)
407  frame->pkt_pts += diff_ts;
409 #endif
410  if(frame->pkt_dts!=AV_NOPTS_VALUE)
411  frame->pkt_dts += diff_ts;
412  if (frame->pkt_duration >= diff_ts)
413  frame->pkt_duration -= diff_ts;
414  } else {
415  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
416  }
417  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
418  avci->skip_samples, frame->nb_samples);
419  *discarded_samples += avci->skip_samples;
420  frame->nb_samples -= avci->skip_samples;
421  avci->skip_samples = 0;
422  }
423  }
424 
425  if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
426  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
427  if (discard_padding == frame->nb_samples) {
428  *discarded_samples += frame->nb_samples;
429  got_frame = 0;
430  } else {
431  if(avctx->pkt_timebase.num && avctx->sample_rate) {
432  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
433  (AVRational){1, avctx->sample_rate},
434  avctx->pkt_timebase);
435  frame->pkt_duration = diff_ts;
436  } else {
437  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
438  }
439  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
440  (int)discard_padding, frame->nb_samples);
441  frame->nb_samples -= discard_padding;
442  }
443  }
444 
445  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
447  if (fside) {
448  AV_WL32(fside->data, avci->skip_samples);
449  AV_WL32(fside->data + 4, discard_padding);
450  AV_WL8(fside->data + 8, skip_reason);
451  AV_WL8(fside->data + 9, discard_reason);
452  avci->skip_samples = 0;
453  }
454  }
455  }
456 
457  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
459  ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
460  av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
461  avci->showed_multi_packet_warning = 1;
462  }
463 
464  if (!got_frame)
466 
467  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
468  ret = pkt->size;
469 
470 #if FF_API_AVCTX_TIMEBASE
471  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
472  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
473 #endif
474 
475  /* do not stop draining when actual_got_frame != 0 or ret < 0 */
476  /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
477  if (avci->draining && !actual_got_frame) {
478  if (ret < 0) {
479  /* prevent infinite loop if a decoder wrongly always return error on draining */
480  /* reasonable nb_errors_max = maximum b frames + thread count */
481  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
482  avctx->thread_count : 1);
483 
484  if (avci->nb_draining_errors++ >= nb_errors_max) {
485  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
486  "Stop draining and force EOF.\n");
487  avci->draining_done = 1;
488  ret = AVERROR_BUG;
489  }
490  } else {
491  avci->draining_done = 1;
492  }
493  }
494 
495 #if FF_API_OLD_ENCDEC
496  avci->compat_decode_consumed += ret;
497 #endif
498 
499  if (ret >= pkt->size || ret < 0) {
502  } else {
503  int consumed = ret;
504 
505  pkt->data += consumed;
506  pkt->size -= consumed;
510  avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
513  }
514  }
515 
516  if (got_frame)
517  av_assert0(frame->buf[0]);
518 
519  return ret < 0 ? ret : 0;
520 }
521 
523 {
524  int ret;
525  int64_t discarded_samples = 0;
526 
527  while (!frame->buf[0]) {
528  if (discarded_samples > avctx->max_samples)
529  return AVERROR(EAGAIN);
530  ret = decode_simple_internal(avctx, frame, &discarded_samples);
531  if (ret < 0)
532  return ret;
533  }
534 
535  return 0;
536 }
537 
539 {
540  AVCodecInternal *avci = avctx->internal;
541  int ret;
542 
543  av_assert0(!frame->buf[0]);
544 
545  if (avctx->codec->receive_frame) {
546  ret = avctx->codec->receive_frame(avctx, frame);
547  if (ret != AVERROR(EAGAIN))
549  } else
551 
552  if (ret == AVERROR_EOF)
553  avci->draining_done = 1;
554 
556  IS_EMPTY(avci->last_pkt_props) && av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props))
558  avci->last_pkt_props, sizeof(*avci->last_pkt_props), NULL);
559 
560  if (!ret) {
561  frame->best_effort_timestamp = guess_correct_pts(avctx,
562  frame->pts,
563  frame->pkt_dts);
564 
565  /* the only case where decode data is not set should be decoders
566  * that do not call ff_get_buffer() */
567  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
568  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
569 
570  if (frame->private_ref) {
571  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
572 
573  if (fdd->post_process) {
574  ret = fdd->post_process(avctx, frame);
575  if (ret < 0) {
577  return ret;
578  }
579  }
580  }
581  }
582 
583  /* free the per-frame decode data */
584  av_buffer_unref(&frame->private_ref);
585 
586  return ret;
587 }
588 
589 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
590 {
591  AVCodecInternal *avci = avctx->internal;
592  int ret;
593 
594  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
595  return AVERROR(EINVAL);
596 
597  if (avctx->internal->draining)
598  return AVERROR_EOF;
599 
600  if (avpkt && !avpkt->size && avpkt->data)
601  return AVERROR(EINVAL);
602 
604  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
605  ret = av_packet_ref(avci->buffer_pkt, avpkt);
606  if (ret < 0)
607  return ret;
608  }
609 
610  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
611  if (ret < 0) {
613  return ret;
614  }
615 
616  if (!avci->buffer_frame->buf[0]) {
618  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
619  return ret;
620  }
621 
622  return 0;
623 }
624 
626 {
627  /* make sure we are noisy about decoders returning invalid cropping data */
628  if (frame->crop_left >= INT_MAX - frame->crop_right ||
629  frame->crop_top >= INT_MAX - frame->crop_bottom ||
630  (frame->crop_left + frame->crop_right) >= frame->width ||
631  (frame->crop_top + frame->crop_bottom) >= frame->height) {
632  av_log(avctx, AV_LOG_WARNING,
633  "Invalid cropping information set by a decoder: "
635  "(frame size %dx%d). This is a bug, please report it\n",
636  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
637  frame->width, frame->height);
638  frame->crop_left = 0;
639  frame->crop_right = 0;
640  frame->crop_top = 0;
641  frame->crop_bottom = 0;
642  return 0;
643  }
644 
645  if (!avctx->apply_cropping)
646  return 0;
647 
650 }
651 
652 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
653 {
654  AVCodecInternal *avci = avctx->internal;
655  int ret, changed;
656 
658 
659  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
660  return AVERROR(EINVAL);
661 
662  if (avci->buffer_frame->buf[0]) {
664  } else {
666  if (ret < 0)
667  return ret;
668  }
669 
670  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
671  ret = apply_cropping(avctx, frame);
672  if (ret < 0) {
674  return ret;
675  }
676  }
677 
678  avctx->frame_number++;
679 
680  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
681 
682  if (avctx->frame_number == 1) {
683  avci->initial_format = frame->format;
684  switch(avctx->codec_type) {
685  case AVMEDIA_TYPE_VIDEO:
686  avci->initial_width = frame->width;
687  avci->initial_height = frame->height;
688  break;
689  case AVMEDIA_TYPE_AUDIO:
690  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
691  avctx->sample_rate;
692  avci->initial_channels = frame->channels;
693  avci->initial_channel_layout = frame->channel_layout;
694  break;
695  }
696  }
697 
698  if (avctx->frame_number > 1) {
699  changed = avci->initial_format != frame->format;
700 
701  switch(avctx->codec_type) {
702  case AVMEDIA_TYPE_VIDEO:
703  changed |= avci->initial_width != frame->width ||
704  avci->initial_height != frame->height;
705  break;
706  case AVMEDIA_TYPE_AUDIO:
707  changed |= avci->initial_sample_rate != frame->sample_rate ||
708  avci->initial_sample_rate != avctx->sample_rate ||
709  avci->initial_channels != frame->channels ||
710  avci->initial_channel_layout != frame->channel_layout;
711  break;
712  }
713 
714  if (changed) {
715  avci->changed_frames_dropped++;
716  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
717  " drop count: %d \n",
718  avctx->frame_number, frame->pts,
719  avci->changed_frames_dropped);
721  return AVERROR_INPUT_CHANGED;
722  }
723  }
724  }
725  return 0;
726 }
727 
728 #if FF_API_OLD_ENCDEC
731 {
732  int ret;
733 
734  /* move the original frame to our backup */
735  av_frame_unref(avci->to_free);
737 
738  /* now copy everything except the AVBufferRefs back
739  * note that we make a COPY of the side data, so calling av_frame_free() on
740  * the caller's frame will work properly */
742  if (ret < 0)
743  return ret;
744 
745  memcpy(frame->data, avci->to_free->data, sizeof(frame->data));
746  memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
747  if (avci->to_free->extended_data != avci->to_free->data) {
748  int planes = avci->to_free->channels;
749  int size = planes * sizeof(*frame->extended_data);
750 
751  if (!size) {
753  return AVERROR_BUG;
754  }
755 
756  frame->extended_data = av_malloc(size);
757  if (!frame->extended_data) {
759  return AVERROR(ENOMEM);
760  }
761  memcpy(frame->extended_data, avci->to_free->extended_data,
762  size);
763  } else
764  frame->extended_data = frame->data;
765 
766  frame->format = avci->to_free->format;
767  frame->width = avci->to_free->width;
768  frame->height = avci->to_free->height;
769  frame->channel_layout = avci->to_free->channel_layout;
770  frame->nb_samples = avci->to_free->nb_samples;
771  frame->channels = avci->to_free->channels;
772 
773  return 0;
774 }
775 
777  int *got_frame, const AVPacket *pkt)
778 {
779  AVCodecInternal *avci = avctx->internal;
780  int ret = 0;
781 
783 
784  if (avci->draining_done && pkt && pkt->size != 0) {
785  av_log(avctx, AV_LOG_WARNING, "Got unexpected packet after EOF\n");
786  avcodec_flush_buffers(avctx);
787  }
788 
789  *got_frame = 0;
790 
791  if (avci->compat_decode_partial_size > 0 &&
792  avci->compat_decode_partial_size != pkt->size) {
793  av_log(avctx, AV_LOG_ERROR,
794  "Got unexpected packet size after a partial decode\n");
795  ret = AVERROR(EINVAL);
796  goto finish;
797  }
798 
799  if (!avci->compat_decode_partial_size) {
800  ret = avcodec_send_packet(avctx, pkt);
801  if (ret == AVERROR_EOF)
802  ret = 0;
803  else if (ret == AVERROR(EAGAIN)) {
804  /* we fully drain all the output in each decode call, so this should not
805  * ever happen */
806  ret = AVERROR_BUG;
807  goto finish;
808  } else if (ret < 0)
809  goto finish;
810  }
811 
812  while (ret >= 0) {
813  ret = avcodec_receive_frame(avctx, frame);
814  if (ret < 0) {
815  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
816  ret = 0;
817  goto finish;
818  }
819 
820  if (frame != avci->compat_decode_frame) {
821  if (!avctx->refcounted_frames) {
822  ret = unrefcount_frame(avci, frame);
823  if (ret < 0)
824  goto finish;
825  }
826 
827  *got_frame = 1;
828  frame = avci->compat_decode_frame;
829  } else {
830  if (!avci->compat_decode_warned) {
831  av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_decode_* "
832  "API cannot return all the frames for this decoder. "
833  "Some frames will be dropped. Update your code to the "
834  "new decoding API to fix this.\n");
835  avci->compat_decode_warned = 1;
836  }
837  }
838 
839  if (avci->draining || (!avctx->codec->bsfs && avci->compat_decode_consumed < pkt->size))
840  break;
841  }
842 
843 finish:
844  if (ret == 0) {
845  /* if there are any bsfs then assume full packet is always consumed */
846  if (avctx->codec->bsfs)
847  ret = pkt->size;
848  else
850  }
851  avci->compat_decode_consumed = 0;
852  avci->compat_decode_partial_size = (ret >= 0) ? pkt->size - ret : 0;
853 
854  return ret;
855 }
856 
857 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
858  int *got_picture_ptr,
859  const AVPacket *avpkt)
860 {
861  return compat_decode(avctx, picture, got_picture_ptr, avpkt);
862 }
863 
864 int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
865  AVFrame *frame,
866  int *got_frame_ptr,
867  const AVPacket *avpkt)
868 {
869  return compat_decode(avctx, frame, got_frame_ptr, avpkt);
870 }
872 #endif
873 
875 {
876  memset(sub, 0, sizeof(*sub));
877  sub->pts = AV_NOPTS_VALUE;
878 }
879 
880 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
881 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
882  AVPacket *inpkt, AVPacket *buf_pkt)
883 {
884 #if CONFIG_ICONV
885  iconv_t cd = (iconv_t)-1;
886  int ret = 0;
887  char *inb, *outb;
888  size_t inl, outl;
889 #endif
890 
891  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
892  *outpkt = inpkt;
893  return 0;
894  }
895 
896 #if CONFIG_ICONV
897  inb = inpkt->data;
898  inl = inpkt->size;
899 
900  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
901  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
902  return AVERROR(ERANGE);
903  }
904 
905  cd = iconv_open("UTF-8", avctx->sub_charenc);
906  av_assert0(cd != (iconv_t)-1);
907 
908  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
909  if (ret < 0)
910  goto end;
911  ret = av_packet_copy_props(buf_pkt, inpkt);
912  if (ret < 0)
913  goto end;
914  outb = buf_pkt->data;
915  outl = buf_pkt->size;
916 
917  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
918  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
919  outl >= buf_pkt->size || inl != 0) {
920  ret = FFMIN(AVERROR(errno), -1);
921  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
922  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
923  goto end;
924  }
925  buf_pkt->size -= outl;
926  memset(buf_pkt->data + buf_pkt->size, 0, outl);
927  *outpkt = buf_pkt;
928 
929  ret = 0;
930 end:
931  if (ret < 0)
932  av_packet_unref(buf_pkt);
933  if (cd != (iconv_t)-1)
934  iconv_close(cd);
935  return ret;
936 #else
937  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
938  return AVERROR(EINVAL);
939 #endif
940 }
941 
942 static int utf8_check(const uint8_t *str)
943 {
944  const uint8_t *byte;
945  uint32_t codepoint, min;
946 
947  while (*str) {
948  byte = str;
949  GET_UTF8(codepoint, *(byte++), return 0;);
950  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
951  1 << (5 * (byte - str) - 4);
952  if (codepoint < min || codepoint >= 0x110000 ||
953  codepoint == 0xFFFE /* BOM */ ||
954  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
955  return 0;
956  str = byte;
957  }
958  return 1;
959 }
960 
961 #if FF_API_ASS_TIMING
962 static void insert_ts(AVBPrint *buf, int ts)
963 {
964  if (ts == -1) {
965  av_bprintf(buf, "9:59:59.99,");
966  } else {
967  int h, m, s;
968 
969  h = ts/360000; ts -= 360000*h;
970  m = ts/ 6000; ts -= 6000*m;
971  s = ts/ 100; ts -= 100*s;
972  av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
973  }
974 }
975 
977 {
978  int i;
979  AVBPrint buf;
980 
982 
983  for (i = 0; i < sub->num_rects; i++) {
984  char *final_dialog;
985  const char *dialog;
986  AVSubtitleRect *rect = sub->rects[i];
987  int ts_start, ts_duration = -1;
988  long int layer;
989 
990  if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
991  continue;
992 
993  av_bprint_clear(&buf);
994 
995  /* skip ReadOrder */
996  dialog = strchr(rect->ass, ',');
997  if (!dialog)
998  continue;
999  dialog++;
1000 
1001  /* extract Layer or Marked */
1002  layer = strtol(dialog, (char**)&dialog, 10);
1003  if (*dialog != ',')
1004  continue;
1005  dialog++;
1006 
1007  /* rescale timing to ASS time base (ms) */
1008  ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
1009  if (pkt->duration != -1)
1010  ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
1011  sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
1012 
1013  /* construct ASS (standalone file form with timestamps) string */
1014  av_bprintf(&buf, "Dialogue: %ld,", layer);
1015  insert_ts(&buf, ts_start);
1016  insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
1017  av_bprintf(&buf, "%s\r\n", dialog);
1018 
1019  final_dialog = av_strdup(buf.str);
1020  if (!av_bprint_is_complete(&buf) || !final_dialog) {
1021  av_freep(&final_dialog);
1022  av_bprint_finalize(&buf, NULL);
1023  return AVERROR(ENOMEM);
1024  }
1025  av_freep(&rect->ass);
1026  rect->ass = final_dialog;
1027  }
1028 
1029  av_bprint_finalize(&buf, NULL);
1030  return 0;
1031 }
1032 #endif
1033 
1035  int *got_sub_ptr,
1036  AVPacket *avpkt)
1037 {
1038  int ret = 0;
1039 
1040  if (!avpkt->data && avpkt->size) {
1041  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
1042  return AVERROR(EINVAL);
1043  }
1044  if (!avctx->codec)
1045  return AVERROR(EINVAL);
1046  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
1047  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
1048  return AVERROR(EINVAL);
1049  }
1050 
1051  *got_sub_ptr = 0;
1053 
1054  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
1055  AVCodecInternal *avci = avctx->internal;
1056  AVPacket *pkt;
1057 
1058  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
1059  if (ret < 0)
1060  return ret;
1061 
1062  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
1063  sub->pts = av_rescale_q(avpkt->pts,
1064  avctx->pkt_timebase, AV_TIME_BASE_Q);
1065  ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
1066  av_assert1((ret >= 0) >= !!*got_sub_ptr &&
1067  !!*got_sub_ptr >= !!sub->num_rects);
1068 
1069 #if FF_API_ASS_TIMING
1071  && *got_sub_ptr && sub->num_rects) {
1072  const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
1073  : avctx->time_base;
1074  int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
1075  if (err < 0)
1076  ret = err;
1077  }
1078 #endif
1079 
1080  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1081  avctx->pkt_timebase.num) {
1082  AVRational ms = { 1, 1000 };
1083  sub->end_display_time = av_rescale_q(avpkt->duration,
1084  avctx->pkt_timebase, ms);
1085  }
1086 
1088  sub->format = 0;
1089  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1090  sub->format = 1;
1091 
1092  for (unsigned i = 0; i < sub->num_rects; i++) {
1094  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1095  av_log(avctx, AV_LOG_ERROR,
1096  "Invalid UTF-8 in decoded subtitles text; "
1097  "maybe missing -sub_charenc option\n");
1100  break;
1101  }
1102  }
1103 
1104  if (*got_sub_ptr)
1105  avctx->frame_number++;
1106 
1107  if (pkt == avci->buffer_pkt) // did we recode?
1108  av_packet_unref(avci->buffer_pkt);
1109  }
1110 
1111  return ret;
1112 }
1113 
1115  const enum AVPixelFormat *fmt)
1116 {
1117  const AVPixFmtDescriptor *desc;
1118  const AVCodecHWConfig *config;
1119  int i, n;
1120 
1121  // If a device was supplied when the codec was opened, assume that the
1122  // user wants to use it.
1123  if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
1124  AVHWDeviceContext *device_ctx =
1126  for (i = 0;; i++) {
1127  config = &avctx->codec->hw_configs[i]->public;
1128  if (!config)
1129  break;
1130  if (!(config->methods &
1132  continue;
1133  if (device_ctx->type != config->device_type)
1134  continue;
1135  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1136  if (config->pix_fmt == fmt[n])
1137  return fmt[n];
1138  }
1139  }
1140  }
1141  // No device or other setup, so we have to choose from things which
1142  // don't any other external information.
1143 
1144  // If the last element of the list is a software format, choose it
1145  // (this should be best software format if any exist).
1146  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1147  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1148  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1149  return fmt[n - 1];
1150 
1151  // Finally, traverse the list in order and choose the first entry
1152  // with no external dependencies (if there is no hardware configuration
1153  // information available then this just picks the first entry).
1154  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1155  for (i = 0;; i++) {
1156  config = avcodec_get_hw_config(avctx->codec, i);
1157  if (!config)
1158  break;
1159  if (config->pix_fmt == fmt[n])
1160  break;
1161  }
1162  if (!config) {
1163  // No specific config available, so the decoder must be able
1164  // to handle this format without any additional setup.
1165  return fmt[n];
1166  }
1168  // Usable with only internal setup.
1169  return fmt[n];
1170  }
1171  }
1172 
1173  // Nothing is usable, give up.
1174  return AV_PIX_FMT_NONE;
1175 }
1176 
1178  enum AVHWDeviceType dev_type)
1179 {
1180  AVHWDeviceContext *device_ctx;
1181  AVHWFramesContext *frames_ctx;
1182  int ret;
1183 
1184  if (!avctx->hwaccel)
1185  return AVERROR(ENOSYS);
1186 
1187  if (avctx->hw_frames_ctx)
1188  return 0;
1189  if (!avctx->hw_device_ctx) {
1190  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1191  "required for hardware accelerated decoding.\n");
1192  return AVERROR(EINVAL);
1193  }
1194 
1195  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1196  if (device_ctx->type != dev_type) {
1197  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1198  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1199  av_hwdevice_get_type_name(device_ctx->type));
1200  return AVERROR(EINVAL);
1201  }
1202 
1204  avctx->hw_device_ctx,
1205  avctx->hwaccel->pix_fmt,
1206  &avctx->hw_frames_ctx);
1207  if (ret < 0)
1208  return ret;
1209 
1210  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1211 
1212 
1213  if (frames_ctx->initial_pool_size) {
1214  // We guarantee 4 base work surfaces. The function above guarantees 1
1215  // (the absolute minimum), so add the missing count.
1216  frames_ctx->initial_pool_size += 3;
1217  }
1218 
1220  if (ret < 0) {
1221  av_buffer_unref(&avctx->hw_frames_ctx);
1222  return ret;
1223  }
1224 
1225  return 0;
1226 }
1227 
1229  AVBufferRef *device_ref,
1231  AVBufferRef **out_frames_ref)
1232 {
1233  AVBufferRef *frames_ref = NULL;
1234  const AVCodecHWConfigInternal *hw_config;
1235  const AVHWAccel *hwa;
1236  int i, ret;
1237 
1238  for (i = 0;; i++) {
1239  hw_config = avctx->codec->hw_configs[i];
1240  if (!hw_config)
1241  return AVERROR(ENOENT);
1242  if (hw_config->public.pix_fmt == hw_pix_fmt)
1243  break;
1244  }
1245 
1246  hwa = hw_config->hwaccel;
1247  if (!hwa || !hwa->frame_params)
1248  return AVERROR(ENOENT);
1249 
1250  frames_ref = av_hwframe_ctx_alloc(device_ref);
1251  if (!frames_ref)
1252  return AVERROR(ENOMEM);
1253 
1254  ret = hwa->frame_params(avctx, frames_ref);
1255  if (ret >= 0) {
1256  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1257 
1258  if (frames_ctx->initial_pool_size) {
1259  // If the user has requested that extra output surfaces be
1260  // available then add them here.
1261  if (avctx->extra_hw_frames > 0)
1262  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1263 
1264  // If frame threading is enabled then an extra surface per thread
1265  // is also required.
1266  if (avctx->active_thread_type & FF_THREAD_FRAME)
1267  frames_ctx->initial_pool_size += avctx->thread_count;
1268  }
1269 
1270  *out_frames_ref = frames_ref;
1271  } else {
1272  av_buffer_unref(&frames_ref);
1273  }
1274  return ret;
1275 }
1276 
1277 static int hwaccel_init(AVCodecContext *avctx,
1278  const AVCodecHWConfigInternal *hw_config)
1279 {
1280  const AVHWAccel *hwaccel;
1281  int err;
1282 
1283  hwaccel = hw_config->hwaccel;
1286  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1287  hwaccel->name);
1288  return AVERROR_PATCHWELCOME;
1289  }
1290 
1291  if (hwaccel->priv_data_size) {
1292  avctx->internal->hwaccel_priv_data =
1293  av_mallocz(hwaccel->priv_data_size);
1294  if (!avctx->internal->hwaccel_priv_data)
1295  return AVERROR(ENOMEM);
1296  }
1297 
1298  avctx->hwaccel = hwaccel;
1299  if (hwaccel->init) {
1300  err = hwaccel->init(avctx);
1301  if (err < 0) {
1302  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1303  "hwaccel initialisation returned error.\n",
1304  av_get_pix_fmt_name(hw_config->public.pix_fmt));
1306  avctx->hwaccel = NULL;
1307  return err;
1308  }
1309  }
1310 
1311  return 0;
1312 }
1313 
1314 static void hwaccel_uninit(AVCodecContext *avctx)
1315 {
1316  if (avctx->hwaccel && avctx->hwaccel->uninit)
1317  avctx->hwaccel->uninit(avctx);
1318 
1320 
1321  avctx->hwaccel = NULL;
1322 
1323  av_buffer_unref(&avctx->hw_frames_ctx);
1324 }
1325 
1326 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1327 {
1328  const AVPixFmtDescriptor *desc;
1329  enum AVPixelFormat *choices;
1330  enum AVPixelFormat ret, user_choice;
1331  const AVCodecHWConfigInternal *hw_config;
1332  const AVCodecHWConfig *config;
1333  int i, n, err;
1334 
1335  // Find end of list.
1336  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1337  // Must contain at least one entry.
1338  av_assert0(n >= 1);
1339  // If a software format is available, it must be the last entry.
1340  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1341  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1342  // No software format is available.
1343  } else {
1344  avctx->sw_pix_fmt = fmt[n - 1];
1345  }
1346 
1347  choices = av_malloc_array(n + 1, sizeof(*choices));
1348  if (!choices)
1349  return AV_PIX_FMT_NONE;
1350 
1351  memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1352 
1353  for (;;) {
1354  // Remove the previous hwaccel, if there was one.
1355  hwaccel_uninit(avctx);
1356 
1357  user_choice = avctx->get_format(avctx, choices);
1358  if (user_choice == AV_PIX_FMT_NONE) {
1359  // Explicitly chose nothing, give up.
1360  ret = AV_PIX_FMT_NONE;
1361  break;
1362  }
1363 
1364  desc = av_pix_fmt_desc_get(user_choice);
1365  if (!desc) {
1366  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1367  "get_format() callback.\n");
1368  ret = AV_PIX_FMT_NONE;
1369  break;
1370  }
1371  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1372  desc->name);
1373 
1374  for (i = 0; i < n; i++) {
1375  if (choices[i] == user_choice)
1376  break;
1377  }
1378  if (i == n) {
1379  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1380  "%s not in possible list.\n", desc->name);
1381  ret = AV_PIX_FMT_NONE;
1382  break;
1383  }
1384 
1385  if (avctx->codec->hw_configs) {
1386  for (i = 0;; i++) {
1387  hw_config = avctx->codec->hw_configs[i];
1388  if (!hw_config)
1389  break;
1390  if (hw_config->public.pix_fmt == user_choice)
1391  break;
1392  }
1393  } else {
1394  hw_config = NULL;
1395  }
1396 
1397  if (!hw_config) {
1398  // No config available, so no extra setup required.
1399  ret = user_choice;
1400  break;
1401  }
1402  config = &hw_config->public;
1403 
1404  if (config->methods &
1406  avctx->hw_frames_ctx) {
1407  const AVHWFramesContext *frames_ctx =
1409  if (frames_ctx->format != user_choice) {
1410  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1411  "does not match the format of the provided frames "
1412  "context.\n", desc->name);
1413  goto try_again;
1414  }
1415  } else if (config->methods &
1417  avctx->hw_device_ctx) {
1418  const AVHWDeviceContext *device_ctx =
1420  if (device_ctx->type != config->device_type) {
1421  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1422  "does not match the type of the provided device "
1423  "context.\n", desc->name);
1424  goto try_again;
1425  }
1426  } else if (config->methods &
1428  // Internal-only setup, no additional configuration.
1429  } else if (config->methods &
1431  // Some ad-hoc configuration we can't see and can't check.
1432  } else {
1433  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1434  "missing configuration.\n", desc->name);
1435  goto try_again;
1436  }
1437  if (hw_config->hwaccel) {
1438  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1439  "initialisation.\n", desc->name);
1440  err = hwaccel_init(avctx, hw_config);
1441  if (err < 0)
1442  goto try_again;
1443  }
1444  ret = user_choice;
1445  break;
1446 
1447  try_again:
1448  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1449  "get_format() without it.\n", desc->name);
1450  for (i = 0; i < n; i++) {
1451  if (choices[i] == user_choice)
1452  break;
1453  }
1454  for (; i + 1 < n; i++)
1455  choices[i] = choices[i + 1];
1456  --n;
1457  }
1458 
1459  av_freep(&choices);
1460  return ret;
1461 }
1462 
1463 static void frame_pool_free(void *opaque, uint8_t *data)
1464 {
1465  FramePool *pool = (FramePool*)data;
1466  int i;
1467 
1468  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1469  av_buffer_pool_uninit(&pool->pools[i]);
1470 
1471  av_freep(&data);
1472 }
1473 
1475 {
1476  FramePool *pool = av_mallocz(sizeof(*pool));
1477  AVBufferRef *buf;
1478 
1479  if (!pool)
1480  return NULL;
1481 
1482  buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1483  frame_pool_free, NULL, 0);
1484  if (!buf) {
1485  av_freep(&pool);
1486  return NULL;
1487  }
1488 
1489  return buf;
1490 }
1491 
1493 {
1494  FramePool *pool = avctx->internal->pool ?
1495  (FramePool*)avctx->internal->pool->data : NULL;
1496  AVBufferRef *pool_buf;
1497  int i, ret, ch, planes;
1498 
1499  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1500  int planar = av_sample_fmt_is_planar(frame->format);
1501  ch = frame->channels;
1502  planes = planar ? ch : 1;
1503  }
1504 
1505  if (pool && pool->format == frame->format) {
1506  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1507  pool->width == frame->width && pool->height == frame->height)
1508  return 0;
1509  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1510  pool->channels == ch && frame->nb_samples == pool->samples)
1511  return 0;
1512  }
1513 
1514  pool_buf = frame_pool_alloc();
1515  if (!pool_buf)
1516  return AVERROR(ENOMEM);
1517  pool = (FramePool*)pool_buf->data;
1518 
1519  switch (avctx->codec_type) {
1520  case AVMEDIA_TYPE_VIDEO: {
1521  int linesize[4];
1522  int w = frame->width;
1523  int h = frame->height;
1524  int unaligned;
1525  ptrdiff_t linesize1[4];
1526  size_t size[4];
1527 
1528  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1529 
1530  do {
1531  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
1532  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1533  ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
1534  if (ret < 0)
1535  goto fail;
1536  // increase alignment of w for next try (rhs gives the lowest bit set in w)
1537  w += w & ~(w - 1);
1538 
1539  unaligned = 0;
1540  for (i = 0; i < 4; i++)
1541  unaligned |= linesize[i] % pool->stride_align[i];
1542  } while (unaligned);
1543 
1544  for (i = 0; i < 4; i++)
1545  linesize1[i] = linesize[i];
1546  ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1547  if (ret < 0)
1548  goto fail;
1549 
1550  for (i = 0; i < 4; i++) {
1551  pool->linesize[i] = linesize[i];
1552  if (size[i]) {
1553  if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1554  ret = AVERROR(EINVAL);
1555  goto fail;
1556  }
1557  pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1558  CONFIG_MEMORY_POISONING ?
1559  NULL :
1561  if (!pool->pools[i]) {
1562  ret = AVERROR(ENOMEM);
1563  goto fail;
1564  }
1565  }
1566  }
1567  pool->format = frame->format;
1568  pool->width = frame->width;
1569  pool->height = frame->height;
1570 
1571  break;
1572  }
1573  case AVMEDIA_TYPE_AUDIO: {
1574  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1575  frame->nb_samples, frame->format, 0);
1576  if (ret < 0)
1577  goto fail;
1578 
1579  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1580  if (!pool->pools[0]) {
1581  ret = AVERROR(ENOMEM);
1582  goto fail;
1583  }
1584 
1585  pool->format = frame->format;
1586  pool->planes = planes;
1587  pool->channels = ch;
1588  pool->samples = frame->nb_samples;
1589  break;
1590  }
1591  default: av_assert0(0);
1592  }
1593 
1594  av_buffer_unref(&avctx->internal->pool);
1595  avctx->internal->pool = pool_buf;
1596 
1597  return 0;
1598 fail:
1599  av_buffer_unref(&pool_buf);
1600  return ret;
1601 }
1602 
1604 {
1605  FramePool *pool = (FramePool*)avctx->internal->pool->data;
1606  int planes = pool->planes;
1607  int i;
1608 
1609  frame->linesize[0] = pool->linesize[0];
1610 
1612  frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
1613  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
1614  frame->extended_buf = av_mallocz_array(frame->nb_extended_buf,
1615  sizeof(*frame->extended_buf));
1616  if (!frame->extended_data || !frame->extended_buf) {
1617  av_freep(&frame->extended_data);
1618  av_freep(&frame->extended_buf);
1619  return AVERROR(ENOMEM);
1620  }
1621  } else {
1622  frame->extended_data = frame->data;
1623  av_assert0(frame->nb_extended_buf == 0);
1624  }
1625 
1626  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1627  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1628  if (!frame->buf[i])
1629  goto fail;
1630  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1631  }
1632  for (i = 0; i < frame->nb_extended_buf; i++) {
1633  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1634  if (!frame->extended_buf[i])
1635  goto fail;
1636  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1637  }
1638 
1639  if (avctx->debug & FF_DEBUG_BUFFERS)
1640  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1641 
1642  return 0;
1643 fail:
1645  return AVERROR(ENOMEM);
1646 }
1647 
1649 {
1650  FramePool *pool = (FramePool*)s->internal->pool->data;
1652  int i;
1653 
1654  if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1655  av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1656  return -1;
1657  }
1658 
1659  if (!desc) {
1661  "Unable to get pixel format descriptor for format %s\n",
1662  av_get_pix_fmt_name(pic->format));
1663  return AVERROR(EINVAL);
1664  }
1665 
1666  memset(pic->data, 0, sizeof(pic->data));
1667  pic->extended_data = pic->data;
1668 
1669  for (i = 0; i < 4 && pool->pools[i]; i++) {
1670  pic->linesize[i] = pool->linesize[i];
1671 
1672  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1673  if (!pic->buf[i])
1674  goto fail;
1675 
1676  pic->data[i] = pic->buf[i]->data;
1677  }
1678  for (; i < AV_NUM_DATA_POINTERS; i++) {
1679  pic->data[i] = NULL;
1680  pic->linesize[i] = 0;
1681  }
1682  if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
1683  ((desc->flags & FF_PSEUDOPAL) && pic->data[1]))
1684  avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
1685 
1686  if (s->debug & FF_DEBUG_BUFFERS)
1687  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1688 
1689  return 0;
1690 fail:
1691  av_frame_unref(pic);
1692  return AVERROR(ENOMEM);
1693 }
1694 
1696 {
1697  int ret;
1698 
1699  if (avctx->hw_frames_ctx) {
1701  frame->width = avctx->coded_width;
1702  frame->height = avctx->coded_height;
1703  return ret;
1704  }
1705 
1706  if ((ret = update_frame_pool(avctx, frame)) < 0)
1707  return ret;
1708 
1709  switch (avctx->codec_type) {
1710  case AVMEDIA_TYPE_VIDEO:
1711  return video_get_buffer(avctx, frame);
1712  case AVMEDIA_TYPE_AUDIO:
1713  return audio_get_buffer(avctx, frame);
1714  default:
1715  return -1;
1716  }
1717 }
1718 
1720 {
1722  const uint8_t *side_metadata;
1723 
1724  AVDictionary **frame_md = &frame->metadata;
1725 
1726  side_metadata = av_packet_get_side_data(avpkt,
1728  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1729 }
1730 
1732 {
1733  AVPacket *pkt = avctx->internal->last_pkt_props;
1734  static const struct {
1735  enum AVPacketSideDataType packet;
1737  } sd[] = {
1748  };
1749 
1751  frame->pts = pkt->pts;
1752 #if FF_API_PKT_PTS
1754  frame->pkt_pts = pkt->pts;
1756 #endif
1757  frame->pkt_pos = pkt->pos;
1758  frame->pkt_duration = pkt->duration;
1759  frame->pkt_size = pkt->size;
1760 
1761  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1763  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1764  if (packet_sd) {
1766  sd[i].frame,
1767  size);
1768  if (!frame_sd)
1769  return AVERROR(ENOMEM);
1770 
1771  memcpy(frame_sd->data, packet_sd, size);
1772  }
1773  }
1775 
1776  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1777  frame->flags |= AV_FRAME_FLAG_DISCARD;
1778  } else {
1779  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1780  }
1781  }
1782  frame->reordered_opaque = avctx->reordered_opaque;
1783 
1784  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1785  frame->color_primaries = avctx->color_primaries;
1786  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1787  frame->color_trc = avctx->color_trc;
1788  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1789  frame->colorspace = avctx->colorspace;
1790  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1791  frame->color_range = avctx->color_range;
1792  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1793  frame->chroma_location = avctx->chroma_sample_location;
1794 
1795  switch (avctx->codec->type) {
1796  case AVMEDIA_TYPE_VIDEO:
1797  frame->format = avctx->pix_fmt;
1798  if (!frame->sample_aspect_ratio.num)
1799  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1800 
1801  if (frame->width && frame->height &&
1802  av_image_check_sar(frame->width, frame->height,
1803  frame->sample_aspect_ratio) < 0) {
1804  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1805  frame->sample_aspect_ratio.num,
1806  frame->sample_aspect_ratio.den);
1807  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1808  }
1809 
1810  break;
1811  case AVMEDIA_TYPE_AUDIO:
1812  if (!frame->sample_rate)
1813  frame->sample_rate = avctx->sample_rate;
1814  if (frame->format < 0)
1815  frame->format = avctx->sample_fmt;
1816  if (!frame->channel_layout) {
1817  if (avctx->channel_layout) {
1819  avctx->channels) {
1820  av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1821  "configuration.\n");
1822  return AVERROR(EINVAL);
1823  }
1824 
1825  frame->channel_layout = avctx->channel_layout;
1826  } else {
1827  if (avctx->channels > FF_SANE_NB_CHANNELS) {
1828  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1829  avctx->channels);
1830  return AVERROR(ENOSYS);
1831  }
1832  }
1833  }
1834  frame->channels = avctx->channels;
1835  break;
1836  }
1837  return 0;
1838 }
1839 
1841 {
1842  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1843  int i;
1844  int num_planes = av_pix_fmt_count_planes(frame->format);
1846  int flags = desc ? desc->flags : 0;
1847  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1848  num_planes = 2;
1849  if ((flags & FF_PSEUDOPAL) && frame->data[1])
1850  num_planes = 2;
1851  for (i = 0; i < num_planes; i++) {
1852  av_assert0(frame->data[i]);
1853  }
1854  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1855  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1856  if (frame->data[i])
1857  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1858  frame->data[i] = NULL;
1859  }
1860  }
1861 }
1862 
1863 static void decode_data_free(void *opaque, uint8_t *data)
1864 {
1866 
1867  if (fdd->post_process_opaque_free)
1869 
1870  if (fdd->hwaccel_priv_free)
1871  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1872 
1873  av_freep(&fdd);
1874 }
1875 
1877 {
1878  AVBufferRef *fdd_buf;
1879  FrameDecodeData *fdd;
1880 
1881  av_assert1(!frame->private_ref);
1882  av_buffer_unref(&frame->private_ref);
1883 
1884  fdd = av_mallocz(sizeof(*fdd));
1885  if (!fdd)
1886  return AVERROR(ENOMEM);
1887 
1888  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1890  if (!fdd_buf) {
1891  av_freep(&fdd);
1892  return AVERROR(ENOMEM);
1893  }
1894 
1895  frame->private_ref = fdd_buf;
1896 
1897  return 0;
1898 }
1899 
1901 {
1902  const AVHWAccel *hwaccel = avctx->hwaccel;
1903  int override_dimensions = 1;
1904  int ret;
1905 
1906  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1907  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1908  (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) {
1909  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1910  ret = AVERROR(EINVAL);
1911  goto fail;
1912  }
1913 
1914  if (frame->width <= 0 || frame->height <= 0) {
1915  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1916  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1917  override_dimensions = 0;
1918  }
1919 
1920  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1921  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1922  ret = AVERROR(EINVAL);
1923  goto fail;
1924  }
1925  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1926  if (frame->nb_samples * (int64_t)avctx->channels > avctx->max_samples) {
1927  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1928  ret = AVERROR(EINVAL);
1929  goto fail;
1930  }
1931  }
1932  ret = ff_decode_frame_props(avctx, frame);
1933  if (ret < 0)
1934  goto fail;
1935 
1936  if (hwaccel) {
1937  if (hwaccel->alloc_frame) {
1938  ret = hwaccel->alloc_frame(avctx, frame);
1939  goto end;
1940  }
1941  } else
1942  avctx->sw_pix_fmt = avctx->pix_fmt;
1943 
1944  ret = avctx->get_buffer2(avctx, frame, flags);
1945  if (ret < 0)
1946  goto fail;
1947 
1949 
1951  if (ret < 0)
1952  goto fail;
1953 
1954 end:
1955  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1957  frame->width = avctx->width;
1958  frame->height = avctx->height;
1959  }
1960 
1961 fail:
1962  if (ret < 0) {
1963  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1965  }
1966 
1967  return ret;
1968 }
1969 
1971 {
1972  AVFrame *tmp;
1973  int ret;
1974 
1976 
1977  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1978  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1979  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1981  }
1982 
1983  if (!frame->data[0])
1984  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1985 
1987  return ff_decode_frame_props(avctx, frame);
1988 
1989  tmp = av_frame_alloc();
1990  if (!tmp)
1991  return AVERROR(ENOMEM);
1992 
1994 
1996  if (ret < 0) {
1997  av_frame_free(&tmp);
1998  return ret;
1999  }
2000 
2002  av_frame_free(&tmp);
2003 
2004  return 0;
2005 }
2006 
2008 {
2009  int ret = reget_buffer_internal(avctx, frame, flags);
2010  if (ret < 0)
2011  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
2012  return ret;
2013 }
2014 
2016 {
2017  int ret = 0;
2018 
2019  /* if the decoder init function was already called previously,
2020  * free the already allocated subtitle_header before overwriting it */
2021  av_freep(&avctx->subtitle_header);
2022 
2023 #if FF_API_THREAD_SAFE_CALLBACKS
2025  if ((avctx->thread_type & FF_THREAD_FRAME) &&
2027  !avctx->thread_safe_callbacks) {
2028  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
2029  "custom get_buffer2() implementation which is not marked as "
2030  "thread safe. This is not supported anymore, make your "
2031  "callback thread-safe.\n");
2032  }
2034 #endif
2035 
2036  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
2037  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2038  avctx->codec->max_lowres);
2039  avctx->lowres = avctx->codec->max_lowres;
2040  }
2041 
2043  avctx->pts_correction_num_faulty_dts = 0;
2044  avctx->pts_correction_last_pts =
2045  avctx->pts_correction_last_dts = INT64_MIN;
2046 
2047  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
2049  av_log(avctx, AV_LOG_WARNING,
2050  "gray decoding requested but not enabled at configuration time\n");
2051  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
2053  }
2054 
2055  ret = decode_bsfs_init(avctx);
2056  if (ret < 0)
2057  return ret;
2058 
2059  return 0;
2060 }
frame_pool_free
static void frame_pool_free(void *opaque, uint8_t *data)
Definition: decode.c:1463
AVSubtitle
Definition: avcodec.h:2722
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:217
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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:222
hw_pix_fmt
static enum AVPixelFormat hw_pix_fmt
Definition: hw_decode.c:46
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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: internal.h:56
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
opt.h
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:788
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
av_fifo_generic_write
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1326
AVCodecHWConfig::methods
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
Definition: codec.h:457
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:625
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:78
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:72
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:32
avcodec_decode_audio4
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: decode.c:864
FramePool::planes
int planes
Definition: decode.c:62
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:92
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:2604
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
av_fifo_grow
int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
Enlarge an AVFifoBuffer.
Definition: fifo.c:107
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:90
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:417
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
rect
Definition: f_ebur128.c:91
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:175
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
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:271
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:726
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AV_WL8
#define AV_WL8(p, d)
Definition: intreadwrite.h:399
AVSubtitleRect
Definition: avcodec.h:2687
decode_simple_receive_frame
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:522
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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:148
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:333
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
FramePool::pools
AVBufferPool * pools[4]
Pools for each data plane.
Definition: decode.c:53
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
AVFrame::width
int width
Definition: frame.h:376
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:216
w
uint8_t w
Definition: llviddspenc.c:39
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1034
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:247
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
AVHWAccel::capabilities
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2471
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
data
const char data[16]
Definition: mxf.c:142
AVCodecInternal::compat_decode_consumed
size_t compat_decode_consumed
Definition: internal.h:198
AVHWAccel::init
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: avcodec.h:2568
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2016
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:434
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
av_buffer_allocz
AVBufferRef * av_buffer_allocz(buffer_size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:53
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:967
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:84
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
FramePool::channels
int channels
Definition: decode.c:63
FramePool::height
int height
Definition: decode.c:59
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:2120
AVDictionary
Definition: dict.c:30
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:1114
AVCodecInternal::compat_decode_partial_size
size_t compat_decode_partial_size
Definition: internal.h:201
FramePool::stride_align
int stride_align[AV_NUM_DATA_POINTERS]
Definition: decode.c:60
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
Definition: packet.h:433
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:848
av_fifo_generic_read
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
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:228
compat_decode
static int compat_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, const AVPacket *pkt)
Definition: decode.c:776
frame_pool_alloc
static AVBufferRef * frame_pool_alloc(void)
Definition: decode.c:1474
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:509
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:398
AVCodecInternal::compat_decode_warned
int compat_decode_warned
Definition: internal.h:195
thread.h
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:148
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:891
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVCodecInternal::initial_channel_layout
uint64_t initial_channel_layout
Definition: internal.h:219
SUBTITLE_ASS
@ SUBTITLE_ASS
Formatted text, the ass field must be set by the decoder and is authoritative.
Definition: avcodec.h:2682
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2071
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:222
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2613
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(buffer_size_t size, AVBufferRef *(*alloc)(buffer_size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:266
AVHWAccel
Definition: avcodec.h:2438
finish
static void finish(void)
Definition: movenc.c:342
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:545
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:118
fail
#define fail()
Definition: checkasm.h:133
AVCodecInternal::showed_multi_packet_warning
int showed_multi_packet_warning
Definition: internal.h:206
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
AVCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:334
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
val
static double val(void *priv, double ch)
Definition: aeval.c:76
FrameDecodeData::post_process_opaque_free
void(* post_process_opaque_free)(void *opaque)
Definition: decode.h:47
pts
static int64_t pts
Definition: transcode_aac.c:652
add_metadata_from_side_data
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1719
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:724
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:108
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:267
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2336
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:48
AVHWAccel::priv_data_size
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
Definition: avcodec.h:2582
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:288
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:551
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:190
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:172
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:99
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:1351
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:499
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:292
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
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:194
av_fifo_space
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
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:2099
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:424
hwaccel_uninit
static void hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1314
AVHWAccel::alloc_frame
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: avcodec.h:2484
copy_packet_props
static int copy_packet_props(AVPacket *dst, const AVPacket *src)
Definition: decode.c:148
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:120
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:373
AVCodecInternal::to_free
AVFrame * to_free
Definition: internal.h:145
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:826
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:435
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:99
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1840
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:114
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:190
AVCodecInternal::compat_decode_frame
AVFrame * compat_decode_frame
Definition: internal.h:202
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
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:128
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2576
buffer_size_t
int buffer_size_t
Definition: internal.h:306
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:624
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:514
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecContext::sub_text_format
int sub_text_format
Control the form of AVSubtitle.rects[N]->ass.
Definition: avcodec.h:2225
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:73
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:113
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:652
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
AVCodecContext::thread_type
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1783
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:274
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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:89
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:452
avcodec_align_dimensions2
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:134
FramePool::format
int format
Definition: decode.c:58
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
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:92
AVCodecInternal::ds
DecodeSimpleContext ds
Definition: internal.h:152
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:461
avpriv_set_systematic_pal2
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:176
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1863
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:1177
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
convert_sub_to_old_ass_form
static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
Definition: decode.c:976
AVCodecInternal::changed_frames_dropped
int changed_frames_dropped
Definition: internal.h:214
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2109
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:384
FramePool::width
int width
Definition: decode.c:59
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:942
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:130
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:2306
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
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:125
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:523
AVCodec::type
enum AVMediaType type
Definition: codec.h:210
av_image_fill_plane_sizes
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
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:571
audio_get_buffer
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1603
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:411
src
#define src
Definition: vp8dsp.c:255
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:97
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:308
FramePool::linesize
int linesize[4]
Definition: decode.c:61
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:143
AV_CODEC_FLAG_TRUNCATED
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:317
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:119
AVCodecInternal::initial_height
int initial_height
Definition: internal.h:216
AVCodecContext::thread_safe_callbacks
attribute_deprecated int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:1812
FF_DEBUG_BUFFERS
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1635
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:208
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:641
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:192
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: internal.h:67
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:880
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:153
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:552
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:431
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:159
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:79
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1754
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
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
update_frame_pool
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1492
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:76
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
AVPacket::size
int size
Definition: packet.h:370
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:505
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:2320
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:180
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:799
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:119
AVCodecInternal::initial_channels
int initial_channels
Definition: internal.h:218
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:215
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2085
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:319
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrameSideData::data
uint8_t * data
Definition: frame.h:222
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:606
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
AVCodecHWConfigInternal
Definition: hwconfig.h:29
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: internal.h:85
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:556
DecodeSimpleContext
Definition: internal.h:121
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:318
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2100
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:2101
AVFrame::channel_layout
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:495
hwaccel_init
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
Definition: decode.c:1277
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:40
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:235
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
AVCodecInternal
Definition: internal.h:129
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:108
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2444
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1695
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:589
AVCodec::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.h:343
av_samples_copy
int av_samples_copy(uint8_t **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:213
extract_packet_props
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
Definition: decode.c:160
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:600
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
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:136
i
int i
Definition: input.c:407
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:227
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:216
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1970
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:538
internal.h
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:440
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
avcodec_decode_video2
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: decode.c:857
AVCodecInternal::pkt_props
AVFifoBuffer * pkt_props
Definition: internal.h:160
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AV_PKT_DATA_A53_CC
@ AV_PKT_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: packet.h:242
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:2102
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:2015
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:63
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:582
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
tb
#define tb
Definition: regdef.h:68
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:237
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
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:2270
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:156
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:119
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:515
AVCodecContext::height
int height
Definition: avcodec.h:709
video_get_buffer
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Definition: decode.c:1648
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:299
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:211
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:2218
avcodec.h
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2117
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
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:1228
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:2007
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
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:328
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:491
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: internal.h:312
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:102
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
FramePool
Definition: decode.c:48
AV_PKT_DATA_S12M_TIMECODE
@ AV_PKT_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1:2014.
Definition: packet.h:291
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AVCodecContext::refcounted_frames
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1368
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:201
FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
Definition: avcodec.h:2228
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
insert_ts
static void insert_ts(AVBPrint *buf, int ts)
Definition: decode.c:962
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
apply_param_change
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: decode.c:67
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:1731
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVFrame::height
int height
Definition: frame.h:376
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2092
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
Definition: packet.h:432
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
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:2346
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:77
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
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:904
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1623
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:191
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:116
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:185
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
planes
static const struct @322 planes[]
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
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:544
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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:547
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:84
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:84
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:403
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:95
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1876
av_fifo_size
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt, AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:881
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:220
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:380
IS_EMPTY
#define IS_EMPTY(pkt)
Definition: decode.c:146
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:346
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVHWAccel::frame_params
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
Definition: avcodec.h:2597
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
AVCodecContext::reordered_opaque
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame....
Definition: avcodec.h:1673
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:40
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:52
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
AVCodecHWConfigInternal::hwaccel
const AVHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
Definition: hwconfig.h:39
DecodeSimpleContext::in_pkt
AVPacket * in_pkt
Definition: internal.h:122
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:303
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FF_PSEUDOPAL
#define FF_PSEUDOPAL
Definition: internal.h:299
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecHWConfig
Definition: codec.h:443
h
h
Definition: vp9dsp_template.c:2038
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2078
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:322
avstring.h
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:107
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
decode_bsfs_init
static int decode_bsfs_init(AVCodecContext *avctx)
Definition: decode.c:188
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:132
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:502
FramePool::samples
int samples
Definition: decode.c:64
AVCodecHWConfig::device_type
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: codec.h:464
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2465
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:915
get_subtitle_defaults
static FF_ENABLE_DEPRECATION_WARNINGS void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:874
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:381
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:2489
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:2121
unrefcount_frame
static FF_DISABLE_DEPRECATION_WARNINGS int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
Definition: decode.c:730
min
float min
Definition: vorbis_enc_data.h:456
intmath.h