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;
70  size_t size;
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 
237  if (ret < 0)
238  goto finish;
239 
240  ret = apply_param_change(avctx, pkt);
241  if (ret < 0)
242  goto finish;
243 
244  return 0;
245 finish:
247  return ret;
248 }
249 
250 /**
251  * Attempt to guess proper monotonic timestamps for decoded video frames
252  * which might have incorrect times. Input timestamps may wrap around, in
253  * which case the output will as well.
254  *
255  * @param pts the pts field of the decoded AVPacket, as passed through
256  * AVFrame.pts
257  * @param dts the dts field of the decoded AVPacket
258  * @return one of the input values, may be AV_NOPTS_VALUE
259  */
261  int64_t reordered_pts, int64_t dts)
262 {
263  int64_t pts = AV_NOPTS_VALUE;
264 
265  if (dts != AV_NOPTS_VALUE) {
266  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
267  ctx->pts_correction_last_dts = dts;
268  } else if (reordered_pts != AV_NOPTS_VALUE)
269  ctx->pts_correction_last_dts = reordered_pts;
270 
271  if (reordered_pts != AV_NOPTS_VALUE) {
272  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
273  ctx->pts_correction_last_pts = reordered_pts;
274  } else if(dts != AV_NOPTS_VALUE)
275  ctx->pts_correction_last_pts = dts;
276 
277  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
278  && reordered_pts != AV_NOPTS_VALUE)
279  pts = reordered_pts;
280  else
281  pts = dts;
282 
283  return pts;
284 }
285 
286 /*
287  * The core of the receive_frame_wrapper for the decoders implementing
288  * the simple API. Certain decoders might consume partial packets without
289  * returning any output, so this function needs to be called in a loop until it
290  * returns EAGAIN.
291  **/
292 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
293 {
294  AVCodecInternal *avci = avctx->internal;
295  DecodeSimpleContext *ds = &avci->ds;
296  AVPacket *pkt = ds->in_pkt;
297  int got_frame, actual_got_frame;
298  int ret;
299 
300  if (!pkt->data && !avci->draining) {
302  ret = ff_decode_get_packet(avctx, pkt);
303  if (ret < 0 && ret != AVERROR_EOF)
304  return ret;
305  }
306 
307  // Some codecs (at least wma lossless) will crash when feeding drain packets
308  // after EOF was signaled.
309  if (avci->draining_done)
310  return AVERROR_EOF;
311 
312  if (!pkt->data &&
313  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
315  return AVERROR_EOF;
316 
317  got_frame = 0;
318 
319  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
320  ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
321  } else {
322  ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
323 
325  frame->pkt_dts = pkt->dts;
326  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
327  if(!avctx->has_b_frames)
328  frame->pkt_pos = pkt->pos;
329  //FIXME these should be under if(!avctx->has_b_frames)
330  /* get_buffer is supposed to set frame parameters */
331  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
332  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
333  if (!frame->width) frame->width = avctx->width;
334  if (!frame->height) frame->height = avctx->height;
335  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
336  }
337  }
338  }
339  emms_c();
340  actual_got_frame = got_frame;
341 
342  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
343  if (frame->flags & AV_FRAME_FLAG_DISCARD)
344  got_frame = 0;
345  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
346  uint8_t *side;
347  size_t side_size;
348  uint32_t discard_padding = 0;
349  uint8_t skip_reason = 0;
350  uint8_t discard_reason = 0;
351 
352  if (ret >= 0 && got_frame) {
353  if (frame->format == AV_SAMPLE_FMT_NONE)
354  frame->format = avctx->sample_fmt;
355  if (!frame->channel_layout)
356  frame->channel_layout = avctx->channel_layout;
357  if (!frame->channels)
358  frame->channels = avctx->channels;
359  if (!frame->sample_rate)
360  frame->sample_rate = avctx->sample_rate;
361  }
362 
364  if(side && side_size>=10) {
365  avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
366  discard_padding = AV_RL32(side + 4);
367  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
368  avci->skip_samples, (int)discard_padding);
369  skip_reason = AV_RL8(side + 8);
370  discard_reason = AV_RL8(side + 9);
371  }
372 
373  if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
374  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
375  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
376  got_frame = 0;
377  *discarded_samples += frame->nb_samples;
378  }
379 
380  if (avci->skip_samples > 0 && got_frame &&
381  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
382  if(frame->nb_samples <= avci->skip_samples){
383  got_frame = 0;
384  *discarded_samples += frame->nb_samples;
385  avci->skip_samples -= frame->nb_samples;
386  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
387  avci->skip_samples);
388  } else {
389  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
390  frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
391  if(avctx->pkt_timebase.num && avctx->sample_rate) {
392  int64_t diff_ts = av_rescale_q(avci->skip_samples,
393  (AVRational){1, avctx->sample_rate},
394  avctx->pkt_timebase);
395  if(frame->pts!=AV_NOPTS_VALUE)
396  frame->pts += diff_ts;
397  if(frame->pkt_dts!=AV_NOPTS_VALUE)
398  frame->pkt_dts += diff_ts;
399  if (frame->pkt_duration >= diff_ts)
400  frame->pkt_duration -= diff_ts;
401  } else {
402  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
403  }
404  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
405  avci->skip_samples, frame->nb_samples);
406  *discarded_samples += avci->skip_samples;
407  frame->nb_samples -= avci->skip_samples;
408  avci->skip_samples = 0;
409  }
410  }
411 
412  if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
413  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
414  if (discard_padding == frame->nb_samples) {
415  *discarded_samples += frame->nb_samples;
416  got_frame = 0;
417  } else {
418  if(avctx->pkt_timebase.num && avctx->sample_rate) {
419  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
420  (AVRational){1, avctx->sample_rate},
421  avctx->pkt_timebase);
422  frame->pkt_duration = diff_ts;
423  } else {
424  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
425  }
426  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
427  (int)discard_padding, frame->nb_samples);
428  frame->nb_samples -= discard_padding;
429  }
430  }
431 
432  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
434  if (fside) {
435  AV_WL32(fside->data, avci->skip_samples);
436  AV_WL32(fside->data + 4, discard_padding);
437  AV_WL8(fside->data + 8, skip_reason);
438  AV_WL8(fside->data + 9, discard_reason);
439  avci->skip_samples = 0;
440  }
441  }
442  }
443 
444  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
446  ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
447  av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
448  avci->showed_multi_packet_warning = 1;
449  }
450 
451  if (!got_frame)
453 
454  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
455  ret = pkt->size;
456 
457 #if FF_API_AVCTX_TIMEBASE
458  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
459  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
460 #endif
461 
462  /* do not stop draining when actual_got_frame != 0 or ret < 0 */
463  /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
464  if (avci->draining && !actual_got_frame) {
465  if (ret < 0) {
466  /* prevent infinite loop if a decoder wrongly always return error on draining */
467  /* reasonable nb_errors_max = maximum b frames + thread count */
468  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
469  avctx->thread_count : 1);
470 
471  if (avci->nb_draining_errors++ >= nb_errors_max) {
472  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
473  "Stop draining and force EOF.\n");
474  avci->draining_done = 1;
475  ret = AVERROR_BUG;
476  }
477  } else {
478  avci->draining_done = 1;
479  }
480  }
481 
482  if (ret >= pkt->size || ret < 0) {
485  } else {
486  int consumed = ret;
487 
488  pkt->data += consumed;
489  pkt->size -= consumed;
490  avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
495  }
496 
497  if (got_frame)
498  av_assert0(frame->buf[0]);
499 
500  return ret < 0 ? ret : 0;
501 }
502 
504 {
505  int ret;
506  int64_t discarded_samples = 0;
507 
508  while (!frame->buf[0]) {
509  if (discarded_samples > avctx->max_samples)
510  return AVERROR(EAGAIN);
511  ret = decode_simple_internal(avctx, frame, &discarded_samples);
512  if (ret < 0)
513  return ret;
514  }
515 
516  return 0;
517 }
518 
520 {
521  AVCodecInternal *avci = avctx->internal;
522  int ret;
523 
524  av_assert0(!frame->buf[0]);
525 
526  if (avctx->codec->receive_frame) {
527  ret = avctx->codec->receive_frame(avctx, frame);
528  if (ret != AVERROR(EAGAIN))
530  } else
532 
533  if (ret == AVERROR_EOF)
534  avci->draining_done = 1;
535 
536  if (!ret) {
537  frame->best_effort_timestamp = guess_correct_pts(avctx,
538  frame->pts,
539  frame->pkt_dts);
540 
541  /* the only case where decode data is not set should be decoders
542  * that do not call ff_get_buffer() */
543  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
544  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
545 
546  if (frame->private_ref) {
547  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
548 
549  if (fdd->post_process) {
550  ret = fdd->post_process(avctx, frame);
551  if (ret < 0) {
553  return ret;
554  }
555  }
556  }
557  }
558 
559  /* free the per-frame decode data */
560  av_buffer_unref(&frame->private_ref);
561 
562  return ret;
563 }
564 
565 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
566 {
567  AVCodecInternal *avci = avctx->internal;
568  int ret;
569 
570  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
571  return AVERROR(EINVAL);
572 
573  if (avctx->internal->draining)
574  return AVERROR_EOF;
575 
576  if (avpkt && !avpkt->size && avpkt->data)
577  return AVERROR(EINVAL);
578 
580  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
581  ret = av_packet_ref(avci->buffer_pkt, avpkt);
582  if (ret < 0)
583  return ret;
584  }
585 
586  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
587  if (ret < 0) {
589  return ret;
590  }
591 
592  if (!avci->buffer_frame->buf[0]) {
594  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
595  return ret;
596  }
597 
598  return 0;
599 }
600 
602 {
603  /* make sure we are noisy about decoders returning invalid cropping data */
604  if (frame->crop_left >= INT_MAX - frame->crop_right ||
605  frame->crop_top >= INT_MAX - frame->crop_bottom ||
606  (frame->crop_left + frame->crop_right) >= frame->width ||
607  (frame->crop_top + frame->crop_bottom) >= frame->height) {
608  av_log(avctx, AV_LOG_WARNING,
609  "Invalid cropping information set by a decoder: "
611  "(frame size %dx%d). This is a bug, please report it\n",
612  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
613  frame->width, frame->height);
614  frame->crop_left = 0;
615  frame->crop_right = 0;
616  frame->crop_top = 0;
617  frame->crop_bottom = 0;
618  return 0;
619  }
620 
621  if (!avctx->apply_cropping)
622  return 0;
623 
626 }
627 
628 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
629 {
630  AVCodecInternal *avci = avctx->internal;
631  int ret, changed;
632 
634 
635  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
636  return AVERROR(EINVAL);
637 
638  if (avci->buffer_frame->buf[0]) {
640  } else {
642  if (ret < 0)
643  return ret;
644  }
645 
646  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
647  ret = apply_cropping(avctx, frame);
648  if (ret < 0) {
650  return ret;
651  }
652  }
653 
654  avctx->frame_number++;
655 
656  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
657 
658  if (avctx->frame_number == 1) {
659  avci->initial_format = frame->format;
660  switch(avctx->codec_type) {
661  case AVMEDIA_TYPE_VIDEO:
662  avci->initial_width = frame->width;
663  avci->initial_height = frame->height;
664  break;
665  case AVMEDIA_TYPE_AUDIO:
666  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
667  avctx->sample_rate;
668  avci->initial_channels = frame->channels;
669  avci->initial_channel_layout = frame->channel_layout;
670  break;
671  }
672  }
673 
674  if (avctx->frame_number > 1) {
675  changed = avci->initial_format != frame->format;
676 
677  switch(avctx->codec_type) {
678  case AVMEDIA_TYPE_VIDEO:
679  changed |= avci->initial_width != frame->width ||
680  avci->initial_height != frame->height;
681  break;
682  case AVMEDIA_TYPE_AUDIO:
683  changed |= avci->initial_sample_rate != frame->sample_rate ||
684  avci->initial_sample_rate != avctx->sample_rate ||
685  avci->initial_channels != frame->channels ||
686  avci->initial_channel_layout != frame->channel_layout;
687  break;
688  }
689 
690  if (changed) {
691  avci->changed_frames_dropped++;
692  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
693  " drop count: %d \n",
694  avctx->frame_number, frame->pts,
695  avci->changed_frames_dropped);
697  return AVERROR_INPUT_CHANGED;
698  }
699  }
700  }
701  return 0;
702 }
703 
705 {
706  memset(sub, 0, sizeof(*sub));
707  sub->pts = AV_NOPTS_VALUE;
708 }
709 
710 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
711 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
712  AVPacket *inpkt, AVPacket *buf_pkt)
713 {
714 #if CONFIG_ICONV
715  iconv_t cd = (iconv_t)-1;
716  int ret = 0;
717  char *inb, *outb;
718  size_t inl, outl;
719 #endif
720 
721  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
722  *outpkt = inpkt;
723  return 0;
724  }
725 
726 #if CONFIG_ICONV
727  inb = inpkt->data;
728  inl = inpkt->size;
729 
730  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
731  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
732  return AVERROR(ERANGE);
733  }
734 
735  cd = iconv_open("UTF-8", avctx->sub_charenc);
736  av_assert0(cd != (iconv_t)-1);
737 
738  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
739  if (ret < 0)
740  goto end;
741  ret = av_packet_copy_props(buf_pkt, inpkt);
742  if (ret < 0)
743  goto end;
744  outb = buf_pkt->data;
745  outl = buf_pkt->size;
746 
747  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
748  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
749  outl >= buf_pkt->size || inl != 0) {
750  ret = FFMIN(AVERROR(errno), -1);
751  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
752  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
753  goto end;
754  }
755  buf_pkt->size -= outl;
756  memset(buf_pkt->data + buf_pkt->size, 0, outl);
757  *outpkt = buf_pkt;
758 
759  ret = 0;
760 end:
761  if (ret < 0)
762  av_packet_unref(buf_pkt);
763  if (cd != (iconv_t)-1)
764  iconv_close(cd);
765  return ret;
766 #else
767  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
768  return AVERROR(EINVAL);
769 #endif
770 }
771 
772 static int utf8_check(const uint8_t *str)
773 {
774  const uint8_t *byte;
775  uint32_t codepoint, min;
776 
777  while (*str) {
778  byte = str;
779  GET_UTF8(codepoint, *(byte++), return 0;);
780  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
781  1 << (5 * (byte - str) - 4);
782  if (codepoint < min || codepoint >= 0x110000 ||
783  codepoint == 0xFFFE /* BOM */ ||
784  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
785  return 0;
786  str = byte;
787  }
788  return 1;
789 }
790 
792  int *got_sub_ptr,
793  AVPacket *avpkt)
794 {
795  int ret = 0;
796 
797  if (!avpkt->data && avpkt->size) {
798  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
799  return AVERROR(EINVAL);
800  }
801  if (!avctx->codec)
802  return AVERROR(EINVAL);
803  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
804  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
805  return AVERROR(EINVAL);
806  }
807 
808  *got_sub_ptr = 0;
810 
811  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
812  AVCodecInternal *avci = avctx->internal;
813  AVPacket *pkt;
814 
815  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
816  if (ret < 0)
817  return ret;
818 
819  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
820  sub->pts = av_rescale_q(avpkt->pts,
821  avctx->pkt_timebase, AV_TIME_BASE_Q);
822  ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
823  av_assert1((ret >= 0) >= !!*got_sub_ptr &&
824  !!*got_sub_ptr >= !!sub->num_rects);
825 
826  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
827  avctx->pkt_timebase.num) {
828  AVRational ms = { 1, 1000 };
829  sub->end_display_time = av_rescale_q(avpkt->duration,
830  avctx->pkt_timebase, ms);
831  }
832 
834  sub->format = 0;
835  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
836  sub->format = 1;
837 
838  for (unsigned i = 0; i < sub->num_rects; i++) {
840  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
841  av_log(avctx, AV_LOG_ERROR,
842  "Invalid UTF-8 in decoded subtitles text; "
843  "maybe missing -sub_charenc option\n");
846  break;
847  }
848  }
849 
850  if (*got_sub_ptr)
851  avctx->frame_number++;
852 
853  if (pkt == avci->buffer_pkt) // did we recode?
855  }
856 
857  return ret;
858 }
859 
861  const enum AVPixelFormat *fmt)
862 {
863  const AVPixFmtDescriptor *desc;
864  const AVCodecHWConfig *config;
865  int i, n;
866 
867  // If a device was supplied when the codec was opened, assume that the
868  // user wants to use it.
869  if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
870  AVHWDeviceContext *device_ctx =
872  for (i = 0;; i++) {
873  config = &avctx->codec->hw_configs[i]->public;
874  if (!config)
875  break;
876  if (!(config->methods &
878  continue;
879  if (device_ctx->type != config->device_type)
880  continue;
881  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
882  if (config->pix_fmt == fmt[n])
883  return fmt[n];
884  }
885  }
886  }
887  // No device or other setup, so we have to choose from things which
888  // don't any other external information.
889 
890  // If the last element of the list is a software format, choose it
891  // (this should be best software format if any exist).
892  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
893  desc = av_pix_fmt_desc_get(fmt[n - 1]);
894  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
895  return fmt[n - 1];
896 
897  // Finally, traverse the list in order and choose the first entry
898  // with no external dependencies (if there is no hardware configuration
899  // information available then this just picks the first entry).
900  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
901  for (i = 0;; i++) {
902  config = avcodec_get_hw_config(avctx->codec, i);
903  if (!config)
904  break;
905  if (config->pix_fmt == fmt[n])
906  break;
907  }
908  if (!config) {
909  // No specific config available, so the decoder must be able
910  // to handle this format without any additional setup.
911  return fmt[n];
912  }
914  // Usable with only internal setup.
915  return fmt[n];
916  }
917  }
918 
919  // Nothing is usable, give up.
920  return AV_PIX_FMT_NONE;
921 }
922 
924  enum AVHWDeviceType dev_type)
925 {
926  AVHWDeviceContext *device_ctx;
927  AVHWFramesContext *frames_ctx;
928  int ret;
929 
930  if (!avctx->hwaccel)
931  return AVERROR(ENOSYS);
932 
933  if (avctx->hw_frames_ctx)
934  return 0;
935  if (!avctx->hw_device_ctx) {
936  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
937  "required for hardware accelerated decoding.\n");
938  return AVERROR(EINVAL);
939  }
940 
941  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
942  if (device_ctx->type != dev_type) {
943  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
944  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
945  av_hwdevice_get_type_name(device_ctx->type));
946  return AVERROR(EINVAL);
947  }
948 
950  avctx->hw_device_ctx,
951  avctx->hwaccel->pix_fmt,
952  &avctx->hw_frames_ctx);
953  if (ret < 0)
954  return ret;
955 
956  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
957 
958 
959  if (frames_ctx->initial_pool_size) {
960  // We guarantee 4 base work surfaces. The function above guarantees 1
961  // (the absolute minimum), so add the missing count.
962  frames_ctx->initial_pool_size += 3;
963  }
964 
966  if (ret < 0) {
968  return ret;
969  }
970 
971  return 0;
972 }
973 
975  AVBufferRef *device_ref,
977  AVBufferRef **out_frames_ref)
978 {
979  AVBufferRef *frames_ref = NULL;
980  const AVCodecHWConfigInternal *hw_config;
981  const AVHWAccel *hwa;
982  int i, ret;
983 
984  for (i = 0;; i++) {
985  hw_config = avctx->codec->hw_configs[i];
986  if (!hw_config)
987  return AVERROR(ENOENT);
988  if (hw_config->public.pix_fmt == hw_pix_fmt)
989  break;
990  }
991 
992  hwa = hw_config->hwaccel;
993  if (!hwa || !hwa->frame_params)
994  return AVERROR(ENOENT);
995 
996  frames_ref = av_hwframe_ctx_alloc(device_ref);
997  if (!frames_ref)
998  return AVERROR(ENOMEM);
999 
1000  ret = hwa->frame_params(avctx, frames_ref);
1001  if (ret >= 0) {
1002  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1003 
1004  if (frames_ctx->initial_pool_size) {
1005  // If the user has requested that extra output surfaces be
1006  // available then add them here.
1007  if (avctx->extra_hw_frames > 0)
1008  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1009 
1010  // If frame threading is enabled then an extra surface per thread
1011  // is also required.
1012  if (avctx->active_thread_type & FF_THREAD_FRAME)
1013  frames_ctx->initial_pool_size += avctx->thread_count;
1014  }
1015 
1016  *out_frames_ref = frames_ref;
1017  } else {
1018  av_buffer_unref(&frames_ref);
1019  }
1020  return ret;
1021 }
1022 
1023 static int hwaccel_init(AVCodecContext *avctx,
1024  const AVCodecHWConfigInternal *hw_config)
1025 {
1026  const AVHWAccel *hwaccel;
1027  int err;
1028 
1029  hwaccel = hw_config->hwaccel;
1032  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1033  hwaccel->name);
1034  return AVERROR_PATCHWELCOME;
1035  }
1036 
1037  if (hwaccel->priv_data_size) {
1038  avctx->internal->hwaccel_priv_data =
1039  av_mallocz(hwaccel->priv_data_size);
1040  if (!avctx->internal->hwaccel_priv_data)
1041  return AVERROR(ENOMEM);
1042  }
1043 
1044  avctx->hwaccel = hwaccel;
1045  if (hwaccel->init) {
1046  err = hwaccel->init(avctx);
1047  if (err < 0) {
1048  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1049  "hwaccel initialisation returned error.\n",
1050  av_get_pix_fmt_name(hw_config->public.pix_fmt));
1052  avctx->hwaccel = NULL;
1053  return err;
1054  }
1055  }
1056 
1057  return 0;
1058 }
1059 
1060 static void hwaccel_uninit(AVCodecContext *avctx)
1061 {
1062  if (avctx->hwaccel && avctx->hwaccel->uninit)
1063  avctx->hwaccel->uninit(avctx);
1064 
1066 
1067  avctx->hwaccel = NULL;
1068 
1069  av_buffer_unref(&avctx->hw_frames_ctx);
1070 }
1071 
1072 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1073 {
1074  const AVPixFmtDescriptor *desc;
1075  enum AVPixelFormat *choices;
1076  enum AVPixelFormat ret, user_choice;
1077  const AVCodecHWConfigInternal *hw_config;
1078  const AVCodecHWConfig *config;
1079  int i, n, err;
1080 
1081  // Find end of list.
1082  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1083  // Must contain at least one entry.
1084  av_assert0(n >= 1);
1085  // If a software format is available, it must be the last entry.
1086  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1087  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1088  // No software format is available.
1089  } else {
1090  avctx->sw_pix_fmt = fmt[n - 1];
1091  }
1092 
1093  choices = av_malloc_array(n + 1, sizeof(*choices));
1094  if (!choices)
1095  return AV_PIX_FMT_NONE;
1096 
1097  memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1098 
1099  for (;;) {
1100  // Remove the previous hwaccel, if there was one.
1101  hwaccel_uninit(avctx);
1102 
1103  user_choice = avctx->get_format(avctx, choices);
1104  if (user_choice == AV_PIX_FMT_NONE) {
1105  // Explicitly chose nothing, give up.
1106  ret = AV_PIX_FMT_NONE;
1107  break;
1108  }
1109 
1110  desc = av_pix_fmt_desc_get(user_choice);
1111  if (!desc) {
1112  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1113  "get_format() callback.\n");
1114  ret = AV_PIX_FMT_NONE;
1115  break;
1116  }
1117  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1118  desc->name);
1119 
1120  for (i = 0; i < n; i++) {
1121  if (choices[i] == user_choice)
1122  break;
1123  }
1124  if (i == n) {
1125  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1126  "%s not in possible list.\n", desc->name);
1127  ret = AV_PIX_FMT_NONE;
1128  break;
1129  }
1130 
1131  if (avctx->codec->hw_configs) {
1132  for (i = 0;; i++) {
1133  hw_config = avctx->codec->hw_configs[i];
1134  if (!hw_config)
1135  break;
1136  if (hw_config->public.pix_fmt == user_choice)
1137  break;
1138  }
1139  } else {
1140  hw_config = NULL;
1141  }
1142 
1143  if (!hw_config) {
1144  // No config available, so no extra setup required.
1145  ret = user_choice;
1146  break;
1147  }
1148  config = &hw_config->public;
1149 
1150  if (config->methods &
1152  avctx->hw_frames_ctx) {
1153  const AVHWFramesContext *frames_ctx =
1155  if (frames_ctx->format != user_choice) {
1156  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1157  "does not match the format of the provided frames "
1158  "context.\n", desc->name);
1159  goto try_again;
1160  }
1161  } else if (config->methods &
1163  avctx->hw_device_ctx) {
1164  const AVHWDeviceContext *device_ctx =
1166  if (device_ctx->type != config->device_type) {
1167  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1168  "does not match the type of the provided device "
1169  "context.\n", desc->name);
1170  goto try_again;
1171  }
1172  } else if (config->methods &
1174  // Internal-only setup, no additional configuration.
1175  } else if (config->methods &
1177  // Some ad-hoc configuration we can't see and can't check.
1178  } else {
1179  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1180  "missing configuration.\n", desc->name);
1181  goto try_again;
1182  }
1183  if (hw_config->hwaccel) {
1184  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1185  "initialisation.\n", desc->name);
1186  err = hwaccel_init(avctx, hw_config);
1187  if (err < 0)
1188  goto try_again;
1189  }
1190  ret = user_choice;
1191  break;
1192 
1193  try_again:
1194  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1195  "get_format() without it.\n", desc->name);
1196  for (i = 0; i < n; i++) {
1197  if (choices[i] == user_choice)
1198  break;
1199  }
1200  for (; i + 1 < n; i++)
1201  choices[i] = choices[i + 1];
1202  --n;
1203  }
1204 
1205  av_freep(&choices);
1206  return ret;
1207 }
1208 
1209 static void frame_pool_free(void *opaque, uint8_t *data)
1210 {
1211  FramePool *pool = (FramePool*)data;
1212  int i;
1213 
1214  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1215  av_buffer_pool_uninit(&pool->pools[i]);
1216 
1217  av_freep(&data);
1218 }
1219 
1221 {
1222  FramePool *pool = av_mallocz(sizeof(*pool));
1223  AVBufferRef *buf;
1224 
1225  if (!pool)
1226  return NULL;
1227 
1228  buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1229  frame_pool_free, NULL, 0);
1230  if (!buf) {
1231  av_freep(&pool);
1232  return NULL;
1233  }
1234 
1235  return buf;
1236 }
1237 
1239 {
1240  FramePool *pool = avctx->internal->pool ?
1241  (FramePool*)avctx->internal->pool->data : NULL;
1242  AVBufferRef *pool_buf;
1243  int i, ret, ch, planes;
1244 
1245  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1246  int planar = av_sample_fmt_is_planar(frame->format);
1247  ch = frame->channels;
1248  planes = planar ? ch : 1;
1249  }
1250 
1251  if (pool && pool->format == frame->format) {
1252  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1253  pool->width == frame->width && pool->height == frame->height)
1254  return 0;
1255  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1256  pool->channels == ch && frame->nb_samples == pool->samples)
1257  return 0;
1258  }
1259 
1260  pool_buf = frame_pool_alloc();
1261  if (!pool_buf)
1262  return AVERROR(ENOMEM);
1263  pool = (FramePool*)pool_buf->data;
1264 
1265  switch (avctx->codec_type) {
1266  case AVMEDIA_TYPE_VIDEO: {
1267  int linesize[4];
1268  int w = frame->width;
1269  int h = frame->height;
1270  int unaligned;
1271  ptrdiff_t linesize1[4];
1272  size_t size[4];
1273 
1274  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1275 
1276  do {
1277  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
1278  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1279  ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
1280  if (ret < 0)
1281  goto fail;
1282  // increase alignment of w for next try (rhs gives the lowest bit set in w)
1283  w += w & ~(w - 1);
1284 
1285  unaligned = 0;
1286  for (i = 0; i < 4; i++)
1287  unaligned |= linesize[i] % pool->stride_align[i];
1288  } while (unaligned);
1289 
1290  for (i = 0; i < 4; i++)
1291  linesize1[i] = linesize[i];
1292  ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1293  if (ret < 0)
1294  goto fail;
1295 
1296  for (i = 0; i < 4; i++) {
1297  pool->linesize[i] = linesize[i];
1298  if (size[i]) {
1299  if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1300  ret = AVERROR(EINVAL);
1301  goto fail;
1302  }
1303  pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1304  CONFIG_MEMORY_POISONING ?
1305  NULL :
1307  if (!pool->pools[i]) {
1308  ret = AVERROR(ENOMEM);
1309  goto fail;
1310  }
1311  }
1312  }
1313  pool->format = frame->format;
1314  pool->width = frame->width;
1315  pool->height = frame->height;
1316 
1317  break;
1318  }
1319  case AVMEDIA_TYPE_AUDIO: {
1320  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1321  frame->nb_samples, frame->format, 0);
1322  if (ret < 0)
1323  goto fail;
1324 
1325  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1326  if (!pool->pools[0]) {
1327  ret = AVERROR(ENOMEM);
1328  goto fail;
1329  }
1330 
1331  pool->format = frame->format;
1332  pool->planes = planes;
1333  pool->channels = ch;
1334  pool->samples = frame->nb_samples;
1335  break;
1336  }
1337  default: av_assert0(0);
1338  }
1339 
1340  av_buffer_unref(&avctx->internal->pool);
1341  avctx->internal->pool = pool_buf;
1342 
1343  return 0;
1344 fail:
1345  av_buffer_unref(&pool_buf);
1346  return ret;
1347 }
1348 
1350 {
1351  FramePool *pool = (FramePool*)avctx->internal->pool->data;
1352  int planes = pool->planes;
1353  int i;
1354 
1355  frame->linesize[0] = pool->linesize[0];
1356 
1358  frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
1359  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
1360  frame->extended_buf = av_mallocz_array(frame->nb_extended_buf,
1361  sizeof(*frame->extended_buf));
1362  if (!frame->extended_data || !frame->extended_buf) {
1363  av_freep(&frame->extended_data);
1364  av_freep(&frame->extended_buf);
1365  return AVERROR(ENOMEM);
1366  }
1367  } else {
1368  frame->extended_data = frame->data;
1369  av_assert0(frame->nb_extended_buf == 0);
1370  }
1371 
1372  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1373  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1374  if (!frame->buf[i])
1375  goto fail;
1376  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1377  }
1378  for (i = 0; i < frame->nb_extended_buf; i++) {
1379  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1380  if (!frame->extended_buf[i])
1381  goto fail;
1382  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1383  }
1384 
1385  if (avctx->debug & FF_DEBUG_BUFFERS)
1386  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1387 
1388  return 0;
1389 fail:
1391  return AVERROR(ENOMEM);
1392 }
1393 
1395 {
1396  FramePool *pool = (FramePool*)s->internal->pool->data;
1398  int i;
1399 
1400  if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1401  av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1402  return -1;
1403  }
1404 
1405  if (!desc) {
1407  "Unable to get pixel format descriptor for format %s\n",
1408  av_get_pix_fmt_name(pic->format));
1409  return AVERROR(EINVAL);
1410  }
1411 
1412  memset(pic->data, 0, sizeof(pic->data));
1413  pic->extended_data = pic->data;
1414 
1415  for (i = 0; i < 4 && pool->pools[i]; i++) {
1416  pic->linesize[i] = pool->linesize[i];
1417 
1418  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1419  if (!pic->buf[i])
1420  goto fail;
1421 
1422  pic->data[i] = pic->buf[i]->data;
1423  }
1424  for (; i < AV_NUM_DATA_POINTERS; i++) {
1425  pic->data[i] = NULL;
1426  pic->linesize[i] = 0;
1427  }
1428 
1429  if (s->debug & FF_DEBUG_BUFFERS)
1430  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1431 
1432  return 0;
1433 fail:
1434  av_frame_unref(pic);
1435  return AVERROR(ENOMEM);
1436 }
1437 
1439 {
1440  int ret;
1441 
1442  if (avctx->hw_frames_ctx) {
1444  frame->width = avctx->coded_width;
1445  frame->height = avctx->coded_height;
1446  return ret;
1447  }
1448 
1449  if ((ret = update_frame_pool(avctx, frame)) < 0)
1450  return ret;
1451 
1452  switch (avctx->codec_type) {
1453  case AVMEDIA_TYPE_VIDEO:
1454  return video_get_buffer(avctx, frame);
1455  case AVMEDIA_TYPE_AUDIO:
1456  return audio_get_buffer(avctx, frame);
1457  default:
1458  return -1;
1459  }
1460 }
1461 
1463 {
1464  size_t size;
1465  const uint8_t *side_metadata;
1466 
1467  AVDictionary **frame_md = &frame->metadata;
1468 
1469  side_metadata = av_packet_get_side_data(avpkt,
1471  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1472 }
1473 
1475 {
1476  AVPacket *pkt = avctx->internal->last_pkt_props;
1477  static const struct {
1478  enum AVPacketSideDataType packet;
1480  } sd[] = {
1491  };
1492 
1493  if (IS_EMPTY(pkt) && av_fifo_size(avctx->internal->pkt_props) >= sizeof(*pkt))
1495  pkt, sizeof(*pkt), NULL);
1496 
1497  frame->pts = pkt->pts;
1498  frame->pkt_pos = pkt->pos;
1499  frame->pkt_duration = pkt->duration;
1500  frame->pkt_size = pkt->size;
1501 
1502  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1503  size_t size;
1504  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1505  if (packet_sd) {
1507  sd[i].frame,
1508  size);
1509  if (!frame_sd)
1510  return AVERROR(ENOMEM);
1511 
1512  memcpy(frame_sd->data, packet_sd, size);
1513  }
1514  }
1516 
1517  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1518  frame->flags |= AV_FRAME_FLAG_DISCARD;
1519  } else {
1520  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1521  }
1522  frame->reordered_opaque = avctx->reordered_opaque;
1523 
1524  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1525  frame->color_primaries = avctx->color_primaries;
1526  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1527  frame->color_trc = avctx->color_trc;
1528  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1529  frame->colorspace = avctx->colorspace;
1530  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1531  frame->color_range = avctx->color_range;
1532  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1533  frame->chroma_location = avctx->chroma_sample_location;
1534 
1535  switch (avctx->codec->type) {
1536  case AVMEDIA_TYPE_VIDEO:
1537  frame->format = avctx->pix_fmt;
1538  if (!frame->sample_aspect_ratio.num)
1539  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1540 
1541  if (frame->width && frame->height &&
1542  av_image_check_sar(frame->width, frame->height,
1543  frame->sample_aspect_ratio) < 0) {
1544  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1545  frame->sample_aspect_ratio.num,
1546  frame->sample_aspect_ratio.den);
1547  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1548  }
1549 
1550  break;
1551  case AVMEDIA_TYPE_AUDIO:
1552  if (!frame->sample_rate)
1553  frame->sample_rate = avctx->sample_rate;
1554  if (frame->format < 0)
1555  frame->format = avctx->sample_fmt;
1556  if (!frame->channel_layout) {
1557  if (avctx->channel_layout) {
1559  avctx->channels) {
1560  av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1561  "configuration.\n");
1562  return AVERROR(EINVAL);
1563  }
1564 
1565  frame->channel_layout = avctx->channel_layout;
1566  } else {
1567  if (avctx->channels > FF_SANE_NB_CHANNELS) {
1568  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1569  avctx->channels);
1570  return AVERROR(ENOSYS);
1571  }
1572  }
1573  }
1574  frame->channels = avctx->channels;
1575  break;
1576  }
1577  return 0;
1578 }
1579 
1581 {
1582  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1583  int i;
1584  int num_planes = av_pix_fmt_count_planes(frame->format);
1586  int flags = desc ? desc->flags : 0;
1587  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1588  num_planes = 2;
1589  for (i = 0; i < num_planes; i++) {
1590  av_assert0(frame->data[i]);
1591  }
1592  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1593  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1594  if (frame->data[i])
1595  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1596  frame->data[i] = NULL;
1597  }
1598  }
1599 }
1600 
1601 static void decode_data_free(void *opaque, uint8_t *data)
1602 {
1604 
1605  if (fdd->post_process_opaque_free)
1607 
1608  if (fdd->hwaccel_priv_free)
1609  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1610 
1611  av_freep(&fdd);
1612 }
1613 
1615 {
1616  AVBufferRef *fdd_buf;
1617  FrameDecodeData *fdd;
1618 
1619  av_assert1(!frame->private_ref);
1620  av_buffer_unref(&frame->private_ref);
1621 
1622  fdd = av_mallocz(sizeof(*fdd));
1623  if (!fdd)
1624  return AVERROR(ENOMEM);
1625 
1626  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1628  if (!fdd_buf) {
1629  av_freep(&fdd);
1630  return AVERROR(ENOMEM);
1631  }
1632 
1633  frame->private_ref = fdd_buf;
1634 
1635  return 0;
1636 }
1637 
1639 {
1640  const AVHWAccel *hwaccel = avctx->hwaccel;
1641  int override_dimensions = 1;
1642  int ret;
1643 
1644  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1645  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1646  (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) {
1647  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1648  ret = AVERROR(EINVAL);
1649  goto fail;
1650  }
1651 
1652  if (frame->width <= 0 || frame->height <= 0) {
1653  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1654  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1655  override_dimensions = 0;
1656  }
1657 
1658  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1659  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1660  ret = AVERROR(EINVAL);
1661  goto fail;
1662  }
1663  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1664  if (frame->nb_samples * (int64_t)avctx->channels > avctx->max_samples) {
1665  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1666  ret = AVERROR(EINVAL);
1667  goto fail;
1668  }
1669  }
1670  ret = ff_decode_frame_props(avctx, frame);
1671  if (ret < 0)
1672  goto fail;
1673 
1674  if (hwaccel) {
1675  if (hwaccel->alloc_frame) {
1676  ret = hwaccel->alloc_frame(avctx, frame);
1677  goto end;
1678  }
1679  } else
1680  avctx->sw_pix_fmt = avctx->pix_fmt;
1681 
1682  ret = avctx->get_buffer2(avctx, frame, flags);
1683  if (ret < 0)
1684  goto fail;
1685 
1687 
1689  if (ret < 0)
1690  goto fail;
1691 
1692 end:
1693  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1695  frame->width = avctx->width;
1696  frame->height = avctx->height;
1697  }
1698 
1699 fail:
1700  if (ret < 0) {
1701  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1703  }
1704 
1705  return ret;
1706 }
1707 
1709 {
1710  AVFrame *tmp;
1711  int ret;
1712 
1714 
1715  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1716  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1717  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1719  }
1720 
1721  if (!frame->data[0])
1722  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1723 
1725  return ff_decode_frame_props(avctx, frame);
1726 
1727  tmp = av_frame_alloc();
1728  if (!tmp)
1729  return AVERROR(ENOMEM);
1730 
1732 
1734  if (ret < 0) {
1735  av_frame_free(&tmp);
1736  return ret;
1737  }
1738 
1740  av_frame_free(&tmp);
1741 
1742  return 0;
1743 }
1744 
1746 {
1747  int ret = reget_buffer_internal(avctx, frame, flags);
1748  if (ret < 0)
1749  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1750  return ret;
1751 }
1752 
1754 {
1755  int ret = 0;
1756 
1757  /* if the decoder init function was already called previously,
1758  * free the already allocated subtitle_header before overwriting it */
1759  av_freep(&avctx->subtitle_header);
1760 
1761 #if FF_API_THREAD_SAFE_CALLBACKS
1763  if ((avctx->thread_type & FF_THREAD_FRAME) &&
1765  !avctx->thread_safe_callbacks) {
1766  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
1767  "custom get_buffer2() implementation which is not marked as "
1768  "thread safe. This is not supported anymore, make your "
1769  "callback thread-safe.\n");
1770  }
1772 #endif
1773 
1774  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->channels == 0 &&
1776  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
1777  return AVERROR(EINVAL);
1778  }
1779  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1780  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1781  avctx->codec->max_lowres);
1782  avctx->lowres = avctx->codec->max_lowres;
1783  }
1784  if (avctx->sub_charenc) {
1785  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1786  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1787  "supported with subtitles codecs\n");
1788  return AVERROR(EINVAL);
1789  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1790  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1791  "subtitles character encoding will be ignored\n",
1792  avctx->codec_descriptor->name);
1794  } else {
1795  /* input character encoding is set for a text based subtitle
1796  * codec at this point */
1799 
1801 #if CONFIG_ICONV
1802  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1803  if (cd == (iconv_t)-1) {
1804  ret = AVERROR(errno);
1805  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1806  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1807  return ret;
1808  }
1809  iconv_close(cd);
1810 #else
1811  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1812  "conversion needs a libavcodec built with iconv support "
1813  "for this codec\n");
1814  return AVERROR(ENOSYS);
1815 #endif
1816  }
1817  }
1818  }
1819 
1821  avctx->pts_correction_num_faulty_dts = 0;
1822  avctx->pts_correction_last_pts =
1823  avctx->pts_correction_last_dts = INT64_MIN;
1824 
1825  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1827  av_log(avctx, AV_LOG_WARNING,
1828  "gray decoding requested but not enabled at configuration time\n");
1829  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1831  }
1832 
1833  ret = decode_bsfs_init(avctx);
1834  if (ret < 0)
1835  return ret;
1836 
1837  return 0;
1838 }
1839 
1840 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1841 {
1842  size_t size;
1843  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1844 
1845  if (pal && size == AVPALETTE_SIZE) {
1846  memcpy(dst, pal, AVPALETTE_SIZE);
1847  return 1;
1848  } else if (pal) {
1849  av_log(logctx, AV_LOG_ERROR,
1850  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1851  }
1852  return 0;
1853 }
frame_pool_free
static void frame_pool_free(void *opaque, uint8_t *data)
Definition: decode.c:1209
AVSubtitle
Definition: avcodec.h:2393
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:202
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:403
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1465
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:266
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:187
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
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:753
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1149
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1066
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
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1072
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:601
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1391
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1098
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:604
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
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:2541
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:2309
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:403
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:172
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1430
AV_CODEC_FLAG_UNALIGNED
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e....
Definition: avcodec.h:248
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
AV_WL8
#define AV_WL8(p, d)
Definition: intreadwrite.h:399
decode_simple_receive_frame
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:503
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:151
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
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:145
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:303
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:1059
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:791
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:365
AVHWAccel::capabilities
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2176
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:476
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:46
data
const char data[16]
Definition: mxf.c:142
AVHWAccel::init
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: avcodec.h:2273
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1789
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:420
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:196
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:860
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:383
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:1865
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:860
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:419
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:722
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
frame_pool_alloc
static AVBufferRef * frame_pool_alloc(void)
Definition: decode.c:1220
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:477
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:398
FF_SUB_CHARENC_MODE_AUTOMATIC
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:1864
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:139
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:766
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AVCodecInternal::initial_channel_layout
uint64_t initial_channel_layout
Definition: internal.h:204
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1816
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:2581
AVHWAccel
Definition: avcodec.h:2143
finish
static void finish(void)
Definition: movenc.c:342
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:510
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:113
fail
#define fail()
Definition: checkasm.h:134
AVCodecInternal::showed_multi_packet_warning
int showed_multi_packet_warning
Definition: internal.h:191
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1546
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:129
AVCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:336
FF_SUB_CHARENC_MODE_DO_NOTHING
#define FF_SUB_CHARENC_MODE_DO_NOTHING
do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for inst...
Definition: avcodec.h:1863
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:581
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:1462
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:689
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:260
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:2078
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:2287
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:286
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:436
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:98
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:1253
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:269
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1052
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:181
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:1844
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:426
hwaccel_uninit
static void hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1060
AVHWAccel::alloc_frame
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: avcodec.h:2189
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
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:785
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:421
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
get_subtitle_defaults
static void get_subtitle_defaults(AVSubtitle *sub)
Definition: decode.c:704
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:94
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1580
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:187
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:116
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:2281
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:479
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVERROR_INPUT_CHANGED
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
Definition: error.h: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:628
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:1556
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:202
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:454
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:1990
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:143
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:451
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1601
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:923
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecInternal::changed_frames_dropped
int changed_frames_dropped
Definition: internal.h:199
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:1854
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:361
FramePool::width
int width
Definition: decode.c:59
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:772
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
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:2048
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1073
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:520
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:536
audio_get_buffer
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1349
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
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:413
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:294
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:201
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:1585
FF_DEBUG_BUFFERS
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1420
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:193
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:410
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1441
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:189
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:710
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:144
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:542
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:433
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:150
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
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:624
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:1538
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:588
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1638
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:1238
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:285
AVPacket::size
int size
Definition: packet.h:366
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:502
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:2062
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:177
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:677
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:203
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:200
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1106
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1830
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:304
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:472
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:596
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
AVCodecHWConfigInternal
Definition: hwconfig.h:29
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:331
DecodeSimpleContext
Definition: internal.h:116
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:364
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:320
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:1845
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:1846
hwaccel_init
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
Definition: decode.c:1023
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:371
AVCodecInternal
Definition: internal.h:124
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1557
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:1099
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2149
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:1438
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:565
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:345
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:374
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:224
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:201
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1708
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:241
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:519
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:442
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:350
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVCodecInternal::pkt_props
AVFifoBuffer * pkt_props
Definition: internal.h:151
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:1847
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1753
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:460
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:436
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:243
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:2012
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:1080
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:505
AVCodecContext::height
int height
Definition: avcodec.h:674
video_get_buffer
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Definition: decode.c:1394
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:292
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:196
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:1963
avcodec.h
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1862
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
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:974
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:1745
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:330
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:1386
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: internal.h:297
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:102
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:192
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
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:1474
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1565
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1837
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
Definition: packet.h:418
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:2088
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:848
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1408
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:188
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:182
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:689
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:509
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:515
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:380
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:1614
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:1129
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt, AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:711
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:357
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:342
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:2302
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:385
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:1458
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:674
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:334
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:117
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:305
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecHWConfig
Definition: codec.h:445
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:1823
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:320
avstring.h
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1840
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:102
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:121
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
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2170
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:859
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:377
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:2461
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:1866
min
float min
Definition: vorbis_enc_data.h:456
intmath.h