FFmpeg
decode.c
Go to the documentation of this file.
1 /*
2  * generic decoding-related code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 #include <string.h>
23 
24 #include "config.h"
25 
26 #if CONFIG_ICONV
27 # include <iconv.h>
28 #endif
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/bprint.h"
34 #include "libavutil/common.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/intmath.h"
40 #include "libavutil/opt.h"
41 
42 #include "avcodec.h"
43 #include "bytestream.h"
44 #include "bsf.h"
45 #include "decode.h"
46 #include "hwconfig.h"
47 #include "internal.h"
48 #include "thread.h"
49 
50 typedef struct FramePool {
51  /**
52  * Pools for each data plane. For audio all the planes have the same size,
53  * so only pools[0] is used.
54  */
56 
57  /*
58  * Pool parameters
59  */
60  int format;
61  int width, height;
63  int linesize[4];
64  int planes;
65  int channels;
66  int samples;
67 } FramePool;
68 
69 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
70 {
71  int ret;
72  size_t size;
73  const uint8_t *data;
74  uint32_t flags;
75  int64_t val;
76 
78  if (!data)
79  return 0;
80 
81  if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
82  av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
83  "changes, but PARAM_CHANGE side data was sent to it.\n");
84  ret = AVERROR(EINVAL);
85  goto fail2;
86  }
87 
88  if (size < 4)
89  goto fail;
90 
91  flags = bytestream_get_le32(&data);
92  size -= 4;
93 
95  if (size < 4)
96  goto fail;
97  val = bytestream_get_le32(&data);
98  if (val <= 0 || val > INT_MAX) {
99  av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
101  goto fail2;
102  }
103  avctx->channels = val;
104  size -= 4;
105  }
107  if (size < 8)
108  goto fail;
109  avctx->channel_layout = bytestream_get_le64(&data);
110  size -= 8;
111  }
113  if (size < 4)
114  goto fail;
115  val = bytestream_get_le32(&data);
116  if (val <= 0 || val > INT_MAX) {
117  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
119  goto fail2;
120  }
121  avctx->sample_rate = val;
122  size -= 4;
123  }
125  if (size < 8)
126  goto fail;
127  avctx->width = bytestream_get_le32(&data);
128  avctx->height = bytestream_get_le32(&data);
129  size -= 8;
130  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
131  if (ret < 0)
132  goto fail2;
133  }
134 
135  return 0;
136 fail:
137  av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
139 fail2:
140  if (ret < 0) {
141  av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
142  if (avctx->err_recognition & AV_EF_EXPLODE)
143  return ret;
144  }
145  return 0;
146 }
147 
148 #define IS_EMPTY(pkt) (!(pkt)->data)
149 
150 static int copy_packet_props(AVPacket *dst, const AVPacket *src)
151 {
152  int ret = av_packet_copy_props(dst, src);
153  if (ret < 0)
154  return ret;
155 
156  dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
157  dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
158 
159  return 0;
160 }
161 
163 {
164  AVPacket tmp = { 0 };
165  int ret = 0;
166 
167  if (IS_EMPTY(avci->last_pkt_props)) {
168  if (av_fifo_size(avci->pkt_props) >= sizeof(*pkt)) {
170  sizeof(*avci->last_pkt_props), NULL);
171  } else
172  return copy_packet_props(avci->last_pkt_props, pkt);
173  }
174 
175  if (av_fifo_space(avci->pkt_props) < sizeof(*pkt)) {
176  ret = av_fifo_grow(avci->pkt_props, sizeof(*pkt));
177  if (ret < 0)
178  return ret;
179  }
180 
182  if (ret < 0)
183  return ret;
184 
185  av_fifo_generic_write(avci->pkt_props, &tmp, sizeof(tmp), NULL);
186 
187  return 0;
188 }
189 
191 {
192  AVCodecInternal *avci = avctx->internal;
193  int ret;
194 
195  if (avci->bsf)
196  return 0;
197 
198  ret = av_bsf_list_parse_str(avctx->codec->bsfs, &avci->bsf);
199  if (ret < 0) {
200  av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", avctx->codec->bsfs, av_err2str(ret));
201  if (ret != AVERROR(ENOMEM))
202  ret = AVERROR_BUG;
203  goto fail;
204  }
205 
206  /* We do not currently have an API for passing the input timebase into decoders,
207  * but no filters used here should actually need it.
208  * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
209  avci->bsf->time_base_in = (AVRational){ 1, 90000 };
211  if (ret < 0)
212  goto fail;
213 
214  ret = av_bsf_init(avci->bsf);
215  if (ret < 0)
216  goto fail;
217 
218  return 0;
219 fail:
220  av_bsf_free(&avci->bsf);
221  return ret;
222 }
223 
225 {
226  AVCodecInternal *avci = avctx->internal;
227  int ret;
228 
229  if (avci->draining)
230  return AVERROR_EOF;
231 
232  ret = av_bsf_receive_packet(avci->bsf, pkt);
233  if (ret == AVERROR_EOF)
234  avci->draining = 1;
235  if (ret < 0)
236  return ret;
237 
240  if (ret < 0)
241  goto finish;
242  }
243 
244  ret = apply_param_change(avctx, pkt);
245  if (ret < 0)
246  goto finish;
247 
248  return 0;
249 finish:
251  return ret;
252 }
253 
254 /**
255  * Attempt to guess proper monotonic timestamps for decoded video frames
256  * which might have incorrect times. Input timestamps may wrap around, in
257  * which case the output will as well.
258  *
259  * @param pts the pts field of the decoded AVPacket, as passed through
260  * AVFrame.pts
261  * @param dts the dts field of the decoded AVPacket
262  * @return one of the input values, may be AV_NOPTS_VALUE
263  */
265  int64_t reordered_pts, int64_t dts)
266 {
267  int64_t pts = AV_NOPTS_VALUE;
268 
269  if (dts != AV_NOPTS_VALUE) {
270  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
271  ctx->pts_correction_last_dts = dts;
272  } else if (reordered_pts != AV_NOPTS_VALUE)
273  ctx->pts_correction_last_dts = reordered_pts;
274 
275  if (reordered_pts != AV_NOPTS_VALUE) {
276  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
277  ctx->pts_correction_last_pts = reordered_pts;
278  } else if(dts != AV_NOPTS_VALUE)
279  ctx->pts_correction_last_pts = dts;
280 
281  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
282  && reordered_pts != AV_NOPTS_VALUE)
283  pts = reordered_pts;
284  else
285  pts = dts;
286 
287  return pts;
288 }
289 
290 /*
291  * The core of the receive_frame_wrapper for the decoders implementing
292  * the simple API. Certain decoders might consume partial packets without
293  * returning any output, so this function needs to be called in a loop until it
294  * returns EAGAIN.
295  **/
296 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
297 {
298  AVCodecInternal *avci = avctx->internal;
299  DecodeSimpleContext *ds = &avci->ds;
300  AVPacket *pkt = ds->in_pkt;
301  int got_frame, actual_got_frame;
302  int ret;
303 
304  if (!pkt->data && !avci->draining) {
306  ret = ff_decode_get_packet(avctx, pkt);
307  if (ret < 0 && ret != AVERROR_EOF)
308  return ret;
309  }
310 
311  // Some codecs (at least wma lossless) will crash when feeding drain packets
312  // after EOF was signaled.
313  if (avci->draining_done)
314  return AVERROR_EOF;
315 
316  if (!pkt->data &&
317  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
319  return AVERROR_EOF;
320 
321  got_frame = 0;
322 
323  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
324  ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
325  } else {
326  ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
327 
329  frame->pkt_dts = pkt->dts;
330  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
331  if(!avctx->has_b_frames)
332  frame->pkt_pos = pkt->pos;
333  //FIXME these should be under if(!avctx->has_b_frames)
334  /* get_buffer is supposed to set frame parameters */
335  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
336  if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
337  if (!frame->width) frame->width = avctx->width;
338  if (!frame->height) frame->height = avctx->height;
339  if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
340  }
341  }
342  }
343  emms_c();
344  actual_got_frame = got_frame;
345 
346  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
347  if (frame->flags & AV_FRAME_FLAG_DISCARD)
348  got_frame = 0;
349  } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
350  uint8_t *side;
351  size_t side_size;
352  uint32_t discard_padding = 0;
353  uint8_t skip_reason = 0;
354  uint8_t discard_reason = 0;
355 
356  if (ret >= 0 && got_frame) {
357  if (frame->format == AV_SAMPLE_FMT_NONE)
358  frame->format = avctx->sample_fmt;
359  if (!frame->channel_layout)
360  frame->channel_layout = avctx->channel_layout;
361  if (!frame->channels)
362  frame->channels = avctx->channels;
363  if (!frame->sample_rate)
364  frame->sample_rate = avctx->sample_rate;
365  }
366 
368  if(side && side_size>=10) {
369  avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
370  discard_padding = AV_RL32(side + 4);
371  av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
372  avci->skip_samples, (int)discard_padding);
373  skip_reason = AV_RL8(side + 8);
374  discard_reason = AV_RL8(side + 9);
375  }
376 
377  if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
378  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
379  avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
380  got_frame = 0;
381  *discarded_samples += frame->nb_samples;
382  }
383 
384  if (avci->skip_samples > 0 && got_frame &&
385  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
386  if(frame->nb_samples <= avci->skip_samples){
387  got_frame = 0;
388  *discarded_samples += frame->nb_samples;
389  avci->skip_samples -= frame->nb_samples;
390  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
391  avci->skip_samples);
392  } else {
393  av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
394  frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
395  if(avctx->pkt_timebase.num && avctx->sample_rate) {
396  int64_t diff_ts = av_rescale_q(avci->skip_samples,
397  (AVRational){1, avctx->sample_rate},
398  avctx->pkt_timebase);
399  if(frame->pts!=AV_NOPTS_VALUE)
400  frame->pts += diff_ts;
401  if(frame->pkt_dts!=AV_NOPTS_VALUE)
402  frame->pkt_dts += diff_ts;
403  if (frame->pkt_duration >= diff_ts)
404  frame->pkt_duration -= diff_ts;
405  } else {
406  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
407  }
408  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
409  avci->skip_samples, frame->nb_samples);
410  *discarded_samples += avci->skip_samples;
411  frame->nb_samples -= avci->skip_samples;
412  avci->skip_samples = 0;
413  }
414  }
415 
416  if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
417  !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
418  if (discard_padding == frame->nb_samples) {
419  *discarded_samples += frame->nb_samples;
420  got_frame = 0;
421  } else {
422  if(avctx->pkt_timebase.num && avctx->sample_rate) {
423  int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
424  (AVRational){1, avctx->sample_rate},
425  avctx->pkt_timebase);
426  frame->pkt_duration = diff_ts;
427  } else {
428  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
429  }
430  av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
431  (int)discard_padding, frame->nb_samples);
432  frame->nb_samples -= discard_padding;
433  }
434  }
435 
436  if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
438  if (fside) {
439  AV_WL32(fside->data, avci->skip_samples);
440  AV_WL32(fside->data + 4, discard_padding);
441  AV_WL8(fside->data + 8, skip_reason);
442  AV_WL8(fside->data + 9, discard_reason);
443  avci->skip_samples = 0;
444  }
445  }
446  }
447 
448  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
450  ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
451  av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
452  avci->showed_multi_packet_warning = 1;
453  }
454 
455  if (!got_frame)
457 
458 #if FF_API_FLAG_TRUNCATED
459  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
460 #else
461  if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
462 #endif
463  ret = pkt->size;
464 
465 #if FF_API_AVCTX_TIMEBASE
466  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
467  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
468 #endif
469 
470  /* do not stop draining when actual_got_frame != 0 or ret < 0 */
471  /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
472  if (avci->draining && !actual_got_frame) {
473  if (ret < 0) {
474  /* prevent infinite loop if a decoder wrongly always return error on draining */
475  /* reasonable nb_errors_max = maximum b frames + thread count */
476  int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
477  avctx->thread_count : 1);
478 
479  if (avci->nb_draining_errors++ >= nb_errors_max) {
480  av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
481  "Stop draining and force EOF.\n");
482  avci->draining_done = 1;
483  ret = AVERROR_BUG;
484  }
485  } else {
486  avci->draining_done = 1;
487  }
488  }
489 
490  if (ret >= pkt->size || ret < 0) {
493  } else {
494  int consumed = ret;
495 
496  pkt->data += consumed;
497  pkt->size -= consumed;
501  avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
504  }
505  }
506 
507  if (got_frame)
508  av_assert0(frame->buf[0]);
509 
510  return ret < 0 ? ret : 0;
511 }
512 
514 {
515  int ret;
516  int64_t discarded_samples = 0;
517 
518  while (!frame->buf[0]) {
519  if (discarded_samples > avctx->max_samples)
520  return AVERROR(EAGAIN);
521  ret = decode_simple_internal(avctx, frame, &discarded_samples);
522  if (ret < 0)
523  return ret;
524  }
525 
526  return 0;
527 }
528 
530 {
531  AVCodecInternal *avci = avctx->internal;
532  int ret;
533 
534  av_assert0(!frame->buf[0]);
535 
536  if (avctx->codec->receive_frame) {
537  ret = avctx->codec->receive_frame(avctx, frame);
538  if (ret != AVERROR(EAGAIN))
540  } else
542 
543  if (ret == AVERROR_EOF)
544  avci->draining_done = 1;
545 
547  IS_EMPTY(avci->last_pkt_props) && av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props))
549  avci->last_pkt_props, sizeof(*avci->last_pkt_props), NULL);
550 
551  if (!ret) {
552  frame->best_effort_timestamp = guess_correct_pts(avctx,
553  frame->pts,
554  frame->pkt_dts);
555 
556  /* the only case where decode data is not set should be decoders
557  * that do not call ff_get_buffer() */
558  av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
559  !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
560 
561  if (frame->private_ref) {
562  FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
563 
564  if (fdd->post_process) {
565  ret = fdd->post_process(avctx, frame);
566  if (ret < 0) {
568  return ret;
569  }
570  }
571  }
572  }
573 
574  /* free the per-frame decode data */
575  av_buffer_unref(&frame->private_ref);
576 
577  return ret;
578 }
579 
580 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
581 {
582  AVCodecInternal *avci = avctx->internal;
583  int ret;
584 
585  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
586  return AVERROR(EINVAL);
587 
588  if (avctx->internal->draining)
589  return AVERROR_EOF;
590 
591  if (avpkt && !avpkt->size && avpkt->data)
592  return AVERROR(EINVAL);
593 
595  if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
596  ret = av_packet_ref(avci->buffer_pkt, avpkt);
597  if (ret < 0)
598  return ret;
599  }
600 
601  ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
602  if (ret < 0) {
604  return ret;
605  }
606 
607  if (!avci->buffer_frame->buf[0]) {
609  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
610  return ret;
611  }
612 
613  return 0;
614 }
615 
617 {
618  /* make sure we are noisy about decoders returning invalid cropping data */
619  if (frame->crop_left >= INT_MAX - frame->crop_right ||
620  frame->crop_top >= INT_MAX - frame->crop_bottom ||
621  (frame->crop_left + frame->crop_right) >= frame->width ||
622  (frame->crop_top + frame->crop_bottom) >= frame->height) {
623  av_log(avctx, AV_LOG_WARNING,
624  "Invalid cropping information set by a decoder: "
626  "(frame size %dx%d). This is a bug, please report it\n",
627  frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
628  frame->width, frame->height);
629  frame->crop_left = 0;
630  frame->crop_right = 0;
631  frame->crop_top = 0;
632  frame->crop_bottom = 0;
633  return 0;
634  }
635 
636  if (!avctx->apply_cropping)
637  return 0;
638 
641 }
642 
643 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
644 {
645  AVCodecInternal *avci = avctx->internal;
646  int ret, changed;
647 
649 
650  if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
651  return AVERROR(EINVAL);
652 
653  if (avci->buffer_frame->buf[0]) {
655  } else {
657  if (ret < 0)
658  return ret;
659  }
660 
661  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
662  ret = apply_cropping(avctx, frame);
663  if (ret < 0) {
665  return ret;
666  }
667  }
668 
669  avctx->frame_number++;
670 
671  if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
672 
673  if (avctx->frame_number == 1) {
674  avci->initial_format = frame->format;
675  switch(avctx->codec_type) {
676  case AVMEDIA_TYPE_VIDEO:
677  avci->initial_width = frame->width;
678  avci->initial_height = frame->height;
679  break;
680  case AVMEDIA_TYPE_AUDIO:
681  avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
682  avctx->sample_rate;
683  avci->initial_channels = frame->channels;
684  avci->initial_channel_layout = frame->channel_layout;
685  break;
686  }
687  }
688 
689  if (avctx->frame_number > 1) {
690  changed = avci->initial_format != frame->format;
691 
692  switch(avctx->codec_type) {
693  case AVMEDIA_TYPE_VIDEO:
694  changed |= avci->initial_width != frame->width ||
695  avci->initial_height != frame->height;
696  break;
697  case AVMEDIA_TYPE_AUDIO:
698  changed |= avci->initial_sample_rate != frame->sample_rate ||
699  avci->initial_sample_rate != avctx->sample_rate ||
700  avci->initial_channels != frame->channels ||
701  avci->initial_channel_layout != frame->channel_layout;
702  break;
703  }
704 
705  if (changed) {
706  avci->changed_frames_dropped++;
707  av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
708  " drop count: %d \n",
709  avctx->frame_number, frame->pts,
710  avci->changed_frames_dropped);
712  return AVERROR_INPUT_CHANGED;
713  }
714  }
715  }
716  return 0;
717 }
718 
720 {
721  memset(sub, 0, sizeof(*sub));
722  sub->pts = AV_NOPTS_VALUE;
723 }
724 
725 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
726 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
727  AVPacket *inpkt, AVPacket *buf_pkt)
728 {
729 #if CONFIG_ICONV
730  iconv_t cd = (iconv_t)-1;
731  int ret = 0;
732  char *inb, *outb;
733  size_t inl, outl;
734 #endif
735 
736  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
737  *outpkt = inpkt;
738  return 0;
739  }
740 
741 #if CONFIG_ICONV
742  inb = inpkt->data;
743  inl = inpkt->size;
744 
745  if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
746  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
747  return AVERROR(ERANGE);
748  }
749 
750  cd = iconv_open("UTF-8", avctx->sub_charenc);
751  av_assert0(cd != (iconv_t)-1);
752 
753  ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
754  if (ret < 0)
755  goto end;
756  ret = av_packet_copy_props(buf_pkt, inpkt);
757  if (ret < 0)
758  goto end;
759  outb = buf_pkt->data;
760  outl = buf_pkt->size;
761 
762  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
763  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
764  outl >= buf_pkt->size || inl != 0) {
765  ret = FFMIN(AVERROR(errno), -1);
766  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
767  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
768  goto end;
769  }
770  buf_pkt->size -= outl;
771  memset(buf_pkt->data + buf_pkt->size, 0, outl);
772  *outpkt = buf_pkt;
773 
774  ret = 0;
775 end:
776  if (ret < 0)
777  av_packet_unref(buf_pkt);
778  if (cd != (iconv_t)-1)
779  iconv_close(cd);
780  return ret;
781 #else
782  av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
783  return AVERROR(EINVAL);
784 #endif
785 }
786 
787 static int utf8_check(const uint8_t *str)
788 {
789  const uint8_t *byte;
790  uint32_t codepoint, min;
791 
792  while (*str) {
793  byte = str;
794  GET_UTF8(codepoint, *(byte++), return 0;);
795  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
796  1 << (5 * (byte - str) - 4);
797  if (codepoint < min || codepoint >= 0x110000 ||
798  codepoint == 0xFFFE /* BOM */ ||
799  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
800  return 0;
801  str = byte;
802  }
803  return 1;
804 }
805 
807  int *got_sub_ptr,
808  AVPacket *avpkt)
809 {
810  int ret = 0;
811 
812  if (!avpkt->data && avpkt->size) {
813  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
814  return AVERROR(EINVAL);
815  }
816  if (!avctx->codec)
817  return AVERROR(EINVAL);
818  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
819  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
820  return AVERROR(EINVAL);
821  }
822 
823  *got_sub_ptr = 0;
825 
826  if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
827  AVCodecInternal *avci = avctx->internal;
828  AVPacket *pkt;
829 
830  ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
831  if (ret < 0)
832  return ret;
833 
834  if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
835  sub->pts = av_rescale_q(avpkt->pts,
836  avctx->pkt_timebase, AV_TIME_BASE_Q);
837  ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
838  av_assert1((ret >= 0) >= !!*got_sub_ptr &&
839  !!*got_sub_ptr >= !!sub->num_rects);
840 
841  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
842  avctx->pkt_timebase.num) {
843  AVRational ms = { 1, 1000 };
844  sub->end_display_time = av_rescale_q(avpkt->duration,
845  avctx->pkt_timebase, ms);
846  }
847 
849  sub->format = 0;
850  else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
851  sub->format = 1;
852 
853  for (unsigned i = 0; i < sub->num_rects; i++) {
855  sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
856  av_log(avctx, AV_LOG_ERROR,
857  "Invalid UTF-8 in decoded subtitles text; "
858  "maybe missing -sub_charenc option\n");
861  break;
862  }
863  }
864 
865  if (*got_sub_ptr)
866  avctx->frame_number++;
867 
868  if (pkt == avci->buffer_pkt) // did we recode?
870  }
871 
872  return ret;
873 }
874 
876  const enum AVPixelFormat *fmt)
877 {
878  const AVPixFmtDescriptor *desc;
879  const AVCodecHWConfig *config;
880  int i, n;
881 
882  // If a device was supplied when the codec was opened, assume that the
883  // user wants to use it.
884  if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
885  AVHWDeviceContext *device_ctx =
887  for (i = 0;; i++) {
888  config = &avctx->codec->hw_configs[i]->public;
889  if (!config)
890  break;
891  if (!(config->methods &
893  continue;
894  if (device_ctx->type != config->device_type)
895  continue;
896  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
897  if (config->pix_fmt == fmt[n])
898  return fmt[n];
899  }
900  }
901  }
902  // No device or other setup, so we have to choose from things which
903  // don't any other external information.
904 
905  // If the last element of the list is a software format, choose it
906  // (this should be best software format if any exist).
907  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
908  desc = av_pix_fmt_desc_get(fmt[n - 1]);
909  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
910  return fmt[n - 1];
911 
912  // Finally, traverse the list in order and choose the first entry
913  // with no external dependencies (if there is no hardware configuration
914  // information available then this just picks the first entry).
915  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
916  for (i = 0;; i++) {
917  config = avcodec_get_hw_config(avctx->codec, i);
918  if (!config)
919  break;
920  if (config->pix_fmt == fmt[n])
921  break;
922  }
923  if (!config) {
924  // No specific config available, so the decoder must be able
925  // to handle this format without any additional setup.
926  return fmt[n];
927  }
929  // Usable with only internal setup.
930  return fmt[n];
931  }
932  }
933 
934  // Nothing is usable, give up.
935  return AV_PIX_FMT_NONE;
936 }
937 
939  enum AVHWDeviceType dev_type)
940 {
941  AVHWDeviceContext *device_ctx;
942  AVHWFramesContext *frames_ctx;
943  int ret;
944 
945  if (!avctx->hwaccel)
946  return AVERROR(ENOSYS);
947 
948  if (avctx->hw_frames_ctx)
949  return 0;
950  if (!avctx->hw_device_ctx) {
951  av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
952  "required for hardware accelerated decoding.\n");
953  return AVERROR(EINVAL);
954  }
955 
956  device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
957  if (device_ctx->type != dev_type) {
958  av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
959  "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
960  av_hwdevice_get_type_name(device_ctx->type));
961  return AVERROR(EINVAL);
962  }
963 
965  avctx->hw_device_ctx,
966  avctx->hwaccel->pix_fmt,
967  &avctx->hw_frames_ctx);
968  if (ret < 0)
969  return ret;
970 
971  frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
972 
973 
974  if (frames_ctx->initial_pool_size) {
975  // We guarantee 4 base work surfaces. The function above guarantees 1
976  // (the absolute minimum), so add the missing count.
977  frames_ctx->initial_pool_size += 3;
978  }
979 
981  if (ret < 0) {
983  return ret;
984  }
985 
986  return 0;
987 }
988 
990  AVBufferRef *device_ref,
992  AVBufferRef **out_frames_ref)
993 {
994  AVBufferRef *frames_ref = NULL;
995  const AVCodecHWConfigInternal *hw_config;
996  const AVHWAccel *hwa;
997  int i, ret;
998 
999  for (i = 0;; i++) {
1000  hw_config = avctx->codec->hw_configs[i];
1001  if (!hw_config)
1002  return AVERROR(ENOENT);
1003  if (hw_config->public.pix_fmt == hw_pix_fmt)
1004  break;
1005  }
1006 
1007  hwa = hw_config->hwaccel;
1008  if (!hwa || !hwa->frame_params)
1009  return AVERROR(ENOENT);
1010 
1011  frames_ref = av_hwframe_ctx_alloc(device_ref);
1012  if (!frames_ref)
1013  return AVERROR(ENOMEM);
1014 
1015  ret = hwa->frame_params(avctx, frames_ref);
1016  if (ret >= 0) {
1017  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1018 
1019  if (frames_ctx->initial_pool_size) {
1020  // If the user has requested that extra output surfaces be
1021  // available then add them here.
1022  if (avctx->extra_hw_frames > 0)
1023  frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1024 
1025  // If frame threading is enabled then an extra surface per thread
1026  // is also required.
1027  if (avctx->active_thread_type & FF_THREAD_FRAME)
1028  frames_ctx->initial_pool_size += avctx->thread_count;
1029  }
1030 
1031  *out_frames_ref = frames_ref;
1032  } else {
1033  av_buffer_unref(&frames_ref);
1034  }
1035  return ret;
1036 }
1037 
1038 static int hwaccel_init(AVCodecContext *avctx,
1039  const AVCodecHWConfigInternal *hw_config)
1040 {
1041  const AVHWAccel *hwaccel;
1042  int err;
1043 
1044  hwaccel = hw_config->hwaccel;
1047  av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1048  hwaccel->name);
1049  return AVERROR_PATCHWELCOME;
1050  }
1051 
1052  if (hwaccel->priv_data_size) {
1053  avctx->internal->hwaccel_priv_data =
1054  av_mallocz(hwaccel->priv_data_size);
1055  if (!avctx->internal->hwaccel_priv_data)
1056  return AVERROR(ENOMEM);
1057  }
1058 
1059  avctx->hwaccel = hwaccel;
1060  if (hwaccel->init) {
1061  err = hwaccel->init(avctx);
1062  if (err < 0) {
1063  av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1064  "hwaccel initialisation returned error.\n",
1065  av_get_pix_fmt_name(hw_config->public.pix_fmt));
1067  avctx->hwaccel = NULL;
1068  return err;
1069  }
1070  }
1071 
1072  return 0;
1073 }
1074 
1075 static void hwaccel_uninit(AVCodecContext *avctx)
1076 {
1077  if (avctx->hwaccel && avctx->hwaccel->uninit)
1078  avctx->hwaccel->uninit(avctx);
1079 
1081 
1082  avctx->hwaccel = NULL;
1083 
1084  av_buffer_unref(&avctx->hw_frames_ctx);
1085 }
1086 
1087 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1088 {
1089  const AVPixFmtDescriptor *desc;
1090  enum AVPixelFormat *choices;
1091  enum AVPixelFormat ret, user_choice;
1092  const AVCodecHWConfigInternal *hw_config;
1093  const AVCodecHWConfig *config;
1094  int i, n, err;
1095 
1096  // Find end of list.
1097  for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1098  // Must contain at least one entry.
1099  av_assert0(n >= 1);
1100  // If a software format is available, it must be the last entry.
1101  desc = av_pix_fmt_desc_get(fmt[n - 1]);
1102  if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1103  // No software format is available.
1104  } else {
1105  avctx->sw_pix_fmt = fmt[n - 1];
1106  }
1107 
1108  choices = av_malloc_array(n + 1, sizeof(*choices));
1109  if (!choices)
1110  return AV_PIX_FMT_NONE;
1111 
1112  memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1113 
1114  for (;;) {
1115  // Remove the previous hwaccel, if there was one.
1116  hwaccel_uninit(avctx);
1117 
1118  user_choice = avctx->get_format(avctx, choices);
1119  if (user_choice == AV_PIX_FMT_NONE) {
1120  // Explicitly chose nothing, give up.
1121  ret = AV_PIX_FMT_NONE;
1122  break;
1123  }
1124 
1125  desc = av_pix_fmt_desc_get(user_choice);
1126  if (!desc) {
1127  av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1128  "get_format() callback.\n");
1129  ret = AV_PIX_FMT_NONE;
1130  break;
1131  }
1132  av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1133  desc->name);
1134 
1135  for (i = 0; i < n; i++) {
1136  if (choices[i] == user_choice)
1137  break;
1138  }
1139  if (i == n) {
1140  av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1141  "%s not in possible list.\n", desc->name);
1142  ret = AV_PIX_FMT_NONE;
1143  break;
1144  }
1145 
1146  if (avctx->codec->hw_configs) {
1147  for (i = 0;; i++) {
1148  hw_config = avctx->codec->hw_configs[i];
1149  if (!hw_config)
1150  break;
1151  if (hw_config->public.pix_fmt == user_choice)
1152  break;
1153  }
1154  } else {
1155  hw_config = NULL;
1156  }
1157 
1158  if (!hw_config) {
1159  // No config available, so no extra setup required.
1160  ret = user_choice;
1161  break;
1162  }
1163  config = &hw_config->public;
1164 
1165  if (config->methods &
1167  avctx->hw_frames_ctx) {
1168  const AVHWFramesContext *frames_ctx =
1170  if (frames_ctx->format != user_choice) {
1171  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1172  "does not match the format of the provided frames "
1173  "context.\n", desc->name);
1174  goto try_again;
1175  }
1176  } else if (config->methods &
1178  avctx->hw_device_ctx) {
1179  const AVHWDeviceContext *device_ctx =
1181  if (device_ctx->type != config->device_type) {
1182  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1183  "does not match the type of the provided device "
1184  "context.\n", desc->name);
1185  goto try_again;
1186  }
1187  } else if (config->methods &
1189  // Internal-only setup, no additional configuration.
1190  } else if (config->methods &
1192  // Some ad-hoc configuration we can't see and can't check.
1193  } else {
1194  av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1195  "missing configuration.\n", desc->name);
1196  goto try_again;
1197  }
1198  if (hw_config->hwaccel) {
1199  av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1200  "initialisation.\n", desc->name);
1201  err = hwaccel_init(avctx, hw_config);
1202  if (err < 0)
1203  goto try_again;
1204  }
1205  ret = user_choice;
1206  break;
1207 
1208  try_again:
1209  av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1210  "get_format() without it.\n", desc->name);
1211  for (i = 0; i < n; i++) {
1212  if (choices[i] == user_choice)
1213  break;
1214  }
1215  for (; i + 1 < n; i++)
1216  choices[i] = choices[i + 1];
1217  --n;
1218  }
1219 
1220  av_freep(&choices);
1221  return ret;
1222 }
1223 
1224 static void frame_pool_free(void *opaque, uint8_t *data)
1225 {
1226  FramePool *pool = (FramePool*)data;
1227  int i;
1228 
1229  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1230  av_buffer_pool_uninit(&pool->pools[i]);
1231 
1232  av_freep(&data);
1233 }
1234 
1236 {
1237  FramePool *pool = av_mallocz(sizeof(*pool));
1238  AVBufferRef *buf;
1239 
1240  if (!pool)
1241  return NULL;
1242 
1243  buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1244  frame_pool_free, NULL, 0);
1245  if (!buf) {
1246  av_freep(&pool);
1247  return NULL;
1248  }
1249 
1250  return buf;
1251 }
1252 
1254 {
1255  FramePool *pool = avctx->internal->pool ?
1256  (FramePool*)avctx->internal->pool->data : NULL;
1257  AVBufferRef *pool_buf;
1258  int i, ret, ch, planes;
1259 
1260  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1261  int planar = av_sample_fmt_is_planar(frame->format);
1262  ch = frame->channels;
1263  planes = planar ? ch : 1;
1264  }
1265 
1266  if (pool && pool->format == frame->format) {
1267  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1268  pool->width == frame->width && pool->height == frame->height)
1269  return 0;
1270  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1271  pool->channels == ch && frame->nb_samples == pool->samples)
1272  return 0;
1273  }
1274 
1275  pool_buf = frame_pool_alloc();
1276  if (!pool_buf)
1277  return AVERROR(ENOMEM);
1278  pool = (FramePool*)pool_buf->data;
1279 
1280  switch (avctx->codec_type) {
1281  case AVMEDIA_TYPE_VIDEO: {
1282  int linesize[4];
1283  int w = frame->width;
1284  int h = frame->height;
1285  int unaligned;
1286  ptrdiff_t linesize1[4];
1287  size_t size[4];
1288 
1289  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1290 
1291  do {
1292  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
1293  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1294  ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
1295  if (ret < 0)
1296  goto fail;
1297  // increase alignment of w for next try (rhs gives the lowest bit set in w)
1298  w += w & ~(w - 1);
1299 
1300  unaligned = 0;
1301  for (i = 0; i < 4; i++)
1302  unaligned |= linesize[i] % pool->stride_align[i];
1303  } while (unaligned);
1304 
1305  for (i = 0; i < 4; i++)
1306  linesize1[i] = linesize[i];
1307  ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1308  if (ret < 0)
1309  goto fail;
1310 
1311  for (i = 0; i < 4; i++) {
1312  pool->linesize[i] = linesize[i];
1313  if (size[i]) {
1314  if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1315  ret = AVERROR(EINVAL);
1316  goto fail;
1317  }
1318  pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1319  CONFIG_MEMORY_POISONING ?
1320  NULL :
1322  if (!pool->pools[i]) {
1323  ret = AVERROR(ENOMEM);
1324  goto fail;
1325  }
1326  }
1327  }
1328  pool->format = frame->format;
1329  pool->width = frame->width;
1330  pool->height = frame->height;
1331 
1332  break;
1333  }
1334  case AVMEDIA_TYPE_AUDIO: {
1335  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1336  frame->nb_samples, frame->format, 0);
1337  if (ret < 0)
1338  goto fail;
1339 
1340  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1341  if (!pool->pools[0]) {
1342  ret = AVERROR(ENOMEM);
1343  goto fail;
1344  }
1345 
1346  pool->format = frame->format;
1347  pool->planes = planes;
1348  pool->channels = ch;
1349  pool->samples = frame->nb_samples;
1350  break;
1351  }
1352  default: av_assert0(0);
1353  }
1354 
1355  av_buffer_unref(&avctx->internal->pool);
1356  avctx->internal->pool = pool_buf;
1357 
1358  return 0;
1359 fail:
1360  av_buffer_unref(&pool_buf);
1361  return ret;
1362 }
1363 
1365 {
1366  FramePool *pool = (FramePool*)avctx->internal->pool->data;
1367  int planes = pool->planes;
1368  int i;
1369 
1370  frame->linesize[0] = pool->linesize[0];
1371 
1373  frame->extended_data = av_calloc(planes, sizeof(*frame->extended_data));
1374  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
1375  frame->extended_buf = av_calloc(frame->nb_extended_buf,
1376  sizeof(*frame->extended_buf));
1377  if (!frame->extended_data || !frame->extended_buf) {
1378  av_freep(&frame->extended_data);
1379  av_freep(&frame->extended_buf);
1380  return AVERROR(ENOMEM);
1381  }
1382  } else {
1383  frame->extended_data = frame->data;
1384  av_assert0(frame->nb_extended_buf == 0);
1385  }
1386 
1387  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1388  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1389  if (!frame->buf[i])
1390  goto fail;
1391  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1392  }
1393  for (i = 0; i < frame->nb_extended_buf; i++) {
1394  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1395  if (!frame->extended_buf[i])
1396  goto fail;
1397  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1398  }
1399 
1400  if (avctx->debug & FF_DEBUG_BUFFERS)
1401  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1402 
1403  return 0;
1404 fail:
1406  return AVERROR(ENOMEM);
1407 }
1408 
1410 {
1411  FramePool *pool = (FramePool*)s->internal->pool->data;
1413  int i;
1414 
1415  if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1416  av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1417  return -1;
1418  }
1419 
1420  if (!desc) {
1422  "Unable to get pixel format descriptor for format %s\n",
1423  av_get_pix_fmt_name(pic->format));
1424  return AVERROR(EINVAL);
1425  }
1426 
1427  memset(pic->data, 0, sizeof(pic->data));
1428  pic->extended_data = pic->data;
1429 
1430  for (i = 0; i < 4 && pool->pools[i]; i++) {
1431  pic->linesize[i] = pool->linesize[i];
1432 
1433  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1434  if (!pic->buf[i])
1435  goto fail;
1436 
1437  pic->data[i] = pic->buf[i]->data;
1438  }
1439  for (; i < AV_NUM_DATA_POINTERS; i++) {
1440  pic->data[i] = NULL;
1441  pic->linesize[i] = 0;
1442  }
1443 
1444  if (s->debug & FF_DEBUG_BUFFERS)
1445  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1446 
1447  return 0;
1448 fail:
1449  av_frame_unref(pic);
1450  return AVERROR(ENOMEM);
1451 }
1452 
1454 {
1455  int ret;
1456 
1457  if (avctx->hw_frames_ctx) {
1459  frame->width = avctx->coded_width;
1460  frame->height = avctx->coded_height;
1461  return ret;
1462  }
1463 
1464  if ((ret = update_frame_pool(avctx, frame)) < 0)
1465  return ret;
1466 
1467  switch (avctx->codec_type) {
1468  case AVMEDIA_TYPE_VIDEO:
1469  return video_get_buffer(avctx, frame);
1470  case AVMEDIA_TYPE_AUDIO:
1471  return audio_get_buffer(avctx, frame);
1472  default:
1473  return -1;
1474  }
1475 }
1476 
1478 {
1479  size_t size;
1480  const uint8_t *side_metadata;
1481 
1482  AVDictionary **frame_md = &frame->metadata;
1483 
1484  side_metadata = av_packet_get_side_data(avpkt,
1486  return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1487 }
1488 
1490 {
1491  AVPacket *pkt = avctx->internal->last_pkt_props;
1492  static const struct {
1493  enum AVPacketSideDataType packet;
1495  } sd[] = {
1507  };
1508 
1510  frame->pts = pkt->pts;
1511  frame->pkt_pos = pkt->pos;
1512  frame->pkt_duration = pkt->duration;
1513  frame->pkt_size = pkt->size;
1514 
1515  for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1516  size_t size;
1517  uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1518  if (packet_sd) {
1520  sd[i].frame,
1521  size);
1522  if (!frame_sd)
1523  return AVERROR(ENOMEM);
1524 
1525  memcpy(frame_sd->data, packet_sd, size);
1526  }
1527  }
1529 
1530  if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1531  frame->flags |= AV_FRAME_FLAG_DISCARD;
1532  } else {
1533  frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1534  }
1535  }
1536  frame->reordered_opaque = avctx->reordered_opaque;
1537 
1538  if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1539  frame->color_primaries = avctx->color_primaries;
1540  if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1541  frame->color_trc = avctx->color_trc;
1542  if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1543  frame->colorspace = avctx->colorspace;
1544  if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1545  frame->color_range = avctx->color_range;
1546  if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1547  frame->chroma_location = avctx->chroma_sample_location;
1548 
1549  switch (avctx->codec->type) {
1550  case AVMEDIA_TYPE_VIDEO:
1551  frame->format = avctx->pix_fmt;
1552  if (!frame->sample_aspect_ratio.num)
1553  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1554 
1555  if (frame->width && frame->height &&
1556  av_image_check_sar(frame->width, frame->height,
1557  frame->sample_aspect_ratio) < 0) {
1558  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1559  frame->sample_aspect_ratio.num,
1560  frame->sample_aspect_ratio.den);
1561  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1562  }
1563 
1564  break;
1565  case AVMEDIA_TYPE_AUDIO:
1566  if (!frame->sample_rate)
1567  frame->sample_rate = avctx->sample_rate;
1568  if (frame->format < 0)
1569  frame->format = avctx->sample_fmt;
1570  if (!frame->channel_layout) {
1571  if (avctx->channel_layout) {
1573  avctx->channels) {
1574  av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1575  "configuration.\n");
1576  return AVERROR(EINVAL);
1577  }
1578 
1579  frame->channel_layout = avctx->channel_layout;
1580  } else {
1581  if (avctx->channels > FF_SANE_NB_CHANNELS) {
1582  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1583  avctx->channels);
1584  return AVERROR(ENOSYS);
1585  }
1586  }
1587  }
1588  frame->channels = avctx->channels;
1589  break;
1590  }
1591  return 0;
1592 }
1593 
1595 {
1596  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1597  int i;
1598  int num_planes = av_pix_fmt_count_planes(frame->format);
1600  int flags = desc ? desc->flags : 0;
1601  if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1602  num_planes = 2;
1603  for (i = 0; i < num_planes; i++) {
1604  av_assert0(frame->data[i]);
1605  }
1606  // For formats without data like hwaccel allow unused pointers to be non-NULL.
1607  for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1608  if (frame->data[i])
1609  av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1610  frame->data[i] = NULL;
1611  }
1612  }
1613 }
1614 
1615 static void decode_data_free(void *opaque, uint8_t *data)
1616 {
1618 
1619  if (fdd->post_process_opaque_free)
1621 
1622  if (fdd->hwaccel_priv_free)
1623  fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1624 
1625  av_freep(&fdd);
1626 }
1627 
1629 {
1630  AVBufferRef *fdd_buf;
1631  FrameDecodeData *fdd;
1632 
1633  av_assert1(!frame->private_ref);
1634  av_buffer_unref(&frame->private_ref);
1635 
1636  fdd = av_mallocz(sizeof(*fdd));
1637  if (!fdd)
1638  return AVERROR(ENOMEM);
1639 
1640  fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1642  if (!fdd_buf) {
1643  av_freep(&fdd);
1644  return AVERROR(ENOMEM);
1645  }
1646 
1647  frame->private_ref = fdd_buf;
1648 
1649  return 0;
1650 }
1651 
1653 {
1654  const AVHWAccel *hwaccel = avctx->hwaccel;
1655  int override_dimensions = 1;
1656  int ret;
1657 
1658  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1659  if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1660  (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) {
1661  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1662  ret = AVERROR(EINVAL);
1663  goto fail;
1664  }
1665 
1666  if (frame->width <= 0 || frame->height <= 0) {
1667  frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1668  frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1669  override_dimensions = 0;
1670  }
1671 
1672  if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1673  av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1674  ret = AVERROR(EINVAL);
1675  goto fail;
1676  }
1677  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1678  if (frame->nb_samples * (int64_t)avctx->channels > avctx->max_samples) {
1679  av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1680  ret = AVERROR(EINVAL);
1681  goto fail;
1682  }
1683  }
1684  ret = ff_decode_frame_props(avctx, frame);
1685  if (ret < 0)
1686  goto fail;
1687 
1688  if (hwaccel) {
1689  if (hwaccel->alloc_frame) {
1690  ret = hwaccel->alloc_frame(avctx, frame);
1691  goto end;
1692  }
1693  } else
1694  avctx->sw_pix_fmt = avctx->pix_fmt;
1695 
1696  ret = avctx->get_buffer2(avctx, frame, flags);
1697  if (ret < 0)
1698  goto fail;
1699 
1701 
1703  if (ret < 0)
1704  goto fail;
1705 
1706 end:
1707  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1709  frame->width = avctx->width;
1710  frame->height = avctx->height;
1711  }
1712 
1713 fail:
1714  if (ret < 0) {
1715  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1717  }
1718 
1719  return ret;
1720 }
1721 
1723 {
1724  AVFrame *tmp;
1725  int ret;
1726 
1728 
1729  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1730  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1731  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1733  }
1734 
1735  if (!frame->data[0])
1736  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1737 
1739  return ff_decode_frame_props(avctx, frame);
1740 
1741  tmp = av_frame_alloc();
1742  if (!tmp)
1743  return AVERROR(ENOMEM);
1744 
1746 
1748  if (ret < 0) {
1749  av_frame_free(&tmp);
1750  return ret;
1751  }
1752 
1754  av_frame_free(&tmp);
1755 
1756  return 0;
1757 }
1758 
1760 {
1761  int ret = reget_buffer_internal(avctx, frame, flags);
1762  if (ret < 0)
1763  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1764  return ret;
1765 }
1766 
1768 {
1769  int ret = 0;
1770 
1771  /* if the decoder init function was already called previously,
1772  * free the already allocated subtitle_header before overwriting it */
1773  av_freep(&avctx->subtitle_header);
1774 
1775 #if FF_API_THREAD_SAFE_CALLBACKS
1777  if ((avctx->thread_type & FF_THREAD_FRAME) &&
1779  !avctx->thread_safe_callbacks) {
1780  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
1781  "custom get_buffer2() implementation which is not marked as "
1782  "thread safe. This is not supported anymore, make your "
1783  "callback thread-safe.\n");
1784  }
1786 #endif
1787 
1788  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->channels == 0 &&
1790  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
1791  return AVERROR(EINVAL);
1792  }
1793  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1794  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1795  avctx->codec->max_lowres);
1796  avctx->lowres = avctx->codec->max_lowres;
1797  }
1798  if (avctx->sub_charenc) {
1799  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1800  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1801  "supported with subtitles codecs\n");
1802  return AVERROR(EINVAL);
1803  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1804  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1805  "subtitles character encoding will be ignored\n",
1806  avctx->codec_descriptor->name);
1808  } else {
1809  /* input character encoding is set for a text based subtitle
1810  * codec at this point */
1813 
1815 #if CONFIG_ICONV
1816  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1817  if (cd == (iconv_t)-1) {
1818  ret = AVERROR(errno);
1819  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1820  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1821  return ret;
1822  }
1823  iconv_close(cd);
1824 #else
1825  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1826  "conversion needs a libavcodec built with iconv support "
1827  "for this codec\n");
1828  return AVERROR(ENOSYS);
1829 #endif
1830  }
1831  }
1832  }
1833 
1835  avctx->pts_correction_num_faulty_dts = 0;
1836  avctx->pts_correction_last_pts =
1837  avctx->pts_correction_last_dts = INT64_MIN;
1838 
1839  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1841  av_log(avctx, AV_LOG_WARNING,
1842  "gray decoding requested but not enabled at configuration time\n");
1843  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1845  }
1846 
1847  ret = decode_bsfs_init(avctx);
1848  if (ret < 0)
1849  return ret;
1850 
1851  return 0;
1852 }
1853 
1854 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1855 {
1856  size_t size;
1857  const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1858 
1859  if (pal && size == AVPALETTE_SIZE) {
1860  memcpy(dst, pal, AVPALETTE_SIZE);
1861  return 1;
1862  } else if (pal) {
1863  av_log(logctx, AV_LOG_ERROR,
1864  "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1865  }
1866  return 0;
1867 }
frame_pool_free
static void frame_pool_free(void *opaque, uint8_t *data)
Definition: decode.c:1224
AVSubtitle
Definition: avcodec.h:2289
AVCodecInternal::initial_sample_rate
int initial_sample_rate
Definition: internal.h:206
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
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:280
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:69
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:224
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:57
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 pixel format.
Definition: avcodec.h:647
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
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:1087
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:616
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1285
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
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:605
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:89
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:31
FramePool::planes
int planes
Definition: decode.c:64
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2564
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
Definition: avcodec.h:2205
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:432
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:176
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1324
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:206
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:513
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:112
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:26
FramePool::pools
AVBufferPool * pools[4]
Pools for each data plane.
Definition: decode.c:55
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:221
w
uint8_t w
Definition: llviddspenc.c:38
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:806
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:373
AVHWAccel::capabilities
int capabilities
Hardware accelerated codec capabilities.
Definition: avcodec.h:2072
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:479
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:143
AVHWAccel::init
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
Definition: avcodec.h:2169
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1683
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
@ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
Definition: packet.h:449
FrameDecodeData::hwaccel_priv_free
void(* hwaccel_priv_free)(void *priv)
Definition: decode.h:53
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:391
FramePool::channels
int channels
Definition: decode.c:65
FramePool::height
int height
Definition: decode.c:61
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:1759
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Definition: decode.c:875
FramePool::stride_align
int stride_align[AV_NUM_DATA_POINTERS]
Definition: decode.c:62
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
Definition: packet.h:448
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:1235
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:1758
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:136
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:767
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:208
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1710
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:2604
AVHWAccel
Definition: avcodec.h:2039
finish
static void finish(void)
Definition: movenc.c:342
bsf.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:112
fail
#define fail()
Definition: checkasm.h:127
AVCodecInternal::showed_multi_packet_warning
int showed_multi_packet_warning
Definition: internal.h:195
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
AVCodec::bsfs
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding.
Definition: codec.h:342
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:1757
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
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:653
add_metadata_from_side_data
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
Definition: decode.c:1477
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
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:264
AVCodecContext::max_samples
int64_t max_samples
The number of samples per frame to maximally accept.
Definition: avcodec.h:1974
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:2183
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:425
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:99
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:1147
GET_UTF8
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:470
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:227
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:1738
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:441
hwaccel_uninit
static void hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1075
AVHWAccel::alloc_frame
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
Definition: avcodec.h:2085
copy_packet_props
static int copy_packet_props(AVPacket *dst, const AVPacket *src)
Definition: decode.c:150
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:387
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
@ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
Definition: packet.h:450
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:719
FrameDecodeData::post_process_opaque
void * post_process_opaque
Definition: decode.h:46
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
validate_avframe_allocation
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1594
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:191
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2177
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:361
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVERROR_INPUT_CHANGED
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
Definition: error.h:75
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h: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:643
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:1450
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:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:81
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:299
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:141
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:469
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:60
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1886
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:140
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:454
decode_data_free
static void decode_data_free(void *opaque, uint8_t *data)
Definition: decode.c:1615
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:938
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:203
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:1748
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:323
FramePool::width
int width
Definition: decode.c:61
utf8_check
static int utf8_check(const uint8_t *str)
Definition: decode.c:787
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:64
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1944
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
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:522
AVCodec::type
enum AVMediaType type
Definition: codec.h:215
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:418
audio_get_buffer
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:1364
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:428
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:322
FramePool::linesize
int linesize[4]
Definition: decode.c:63
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:255
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:205
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:1479
FF_DEBUG_BUFFERS
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1314
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:197
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:425
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:193
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:68
UTF8_MAX_BYTES
#define UTF8_MAX_BYTES
Definition: decode.c:725
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:141
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:545
AV_CODEC_HW_CONFIG_METHOD_INTERNAL
@ AV_CODEC_HW_CONFIG_METHOD_INTERNAL
The codec supports this format by some internal method.
Definition: codec.h:448
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:147
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
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:109
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:506
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:1432
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:470
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
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:1253
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:243
AVPacket::size
int size
Definition: packet.h:374
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:503
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:1958
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:181
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:678
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
AVCodecInternal::initial_channels
int initial_channels
Definition: internal.h:207
AVCodecInternal::initial_format
int initial_format
Definition: internal.h:204
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1724
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:473
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:599
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:86
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:337
DecodeSimpleContext
Definition: internal.h:115
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:331
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:1739
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:1740
hwaccel_init
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
Definition: decode.c:1038
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:379
AVCodecInternal
Definition: internal.h:123
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1451
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:993
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2045
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:1453
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:580
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:351
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:162
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:380
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
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:226
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecInternal::initial_width
int initial_width
Definition: internal.h:205
reget_buffer_internal
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
Definition: decode.c:1722
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:246
decode_receive_frame_internal
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:529
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:457
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:350
planes
static const struct @319 planes[]
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVCodecInternal::pkt_props
AVFifoBuffer * pkt_props
Definition: internal.h:148
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:1741
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1767
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:63
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:461
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
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:263
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:1908
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:974
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:508
AVCodecContext::height
int height
Definition: avcodec.h:556
video_get_buffer
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Definition: decode.c:1409
decode_simple_internal
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
Definition: decode.c:296
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:200
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
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:1858
avcodec.h
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:1756
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:93
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:989
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:1759
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:254
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:1280
FF_REGET_BUFFER_FLAG_READONLY
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
Definition: internal.h:273
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:50
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:69
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:1489
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:158
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1459
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1731
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
channel_layout.h
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
@ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
Definition: packet.h:447
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:1984
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:82
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:865
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:192
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:121
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:186
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
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:391
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:82
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:342
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:100
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1628
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:1023
recode_subtitle
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt, AVPacket *inpkt, AVPacket *buf_pkt)
Definition: decode.c:726
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:69
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:319
IS_EMPTY
#define IS_EMPTY(pkt)
Definition: decode.c:148
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
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:2198
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:393
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:1352
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:48
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
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:52
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:116
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:316
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:61
AVCodecHWConfig
Definition: codec.h:460
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:1717
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:1854
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:101
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:190
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
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:66
AVHWAccel::pix_fmt
enum AVPixelFormat pix_fmt
Supported pixel format.
Definition: avcodec.h:2066
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:753
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:385
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:2484
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:1760
min
float min
Definition: vorbis_enc_data.h:429
intmath.h