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