FFmpeg
ffmpeg_dec.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <stdbit.h>
20 
21 #include "libavutil/avassert.h"
22 #include "libavutil/avstring.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/error.h"
25 #include "libavutil/log.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/pixfmt.h"
30 #include "libavutil/stereo3d.h"
31 #include "libavutil/time.h"
32 #include "libavutil/timestamp.h"
33 
34 #include "libavcodec/avcodec.h"
35 #include "libavcodec/codec.h"
36 
37 #include "ffmpeg.h"
38 
39 typedef struct DecoderPriv {
41 
43 
47 
48  // override output video sample aspect ratio with this value
50 
52 
53  // a combination of DECODER_FLAG_*, provided to dec_open()
54  int flags;
56 
61 
62  // pts/estimated duration of the last decoded frame
63  // * in decoder timebase for video,
64  // * in last_frame_tb (may change during decoding) for audio
70 
71  /* previous decoded subtitles */
74 
76  unsigned sch_idx;
77 
78  // this decoder's index in decoders or -1
79  int index;
80  void *log_parent;
81  char log_name[32];
82  char *parent_name;
83 
84  // user specified decoder multiview options manually
86 
87  struct {
89  unsigned out_idx;
90  } *views_requested;
92 
93  /* A map of view ID to decoder outputs.
94  * MUST NOT be accessed outside of get_format()/get_buffer() */
95  struct {
96  unsigned id;
97  uintptr_t out_mask;
98  } *view_map;
100 
101  struct {
103  const AVCodec *codec;
104  } standalone_init;
105 } DecoderPriv;
106 
108 {
109  return (DecoderPriv*)d;
110 }
111 
112 // data that is local to the decoder thread and not visible outside of it
113 typedef struct DecThreadContext {
117 
118 void dec_free(Decoder **pdec)
119 {
120  Decoder *dec = *pdec;
121  DecoderPriv *dp;
122 
123  if (!dec)
124  return;
125  dp = dp_from_dec(dec);
126 
128 
129  av_frame_free(&dp->frame);
131  av_packet_free(&dp->pkt);
132 
134 
135  for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++)
136  av_frame_free(&dp->sub_prev[i]);
138 
139  av_freep(&dp->parent_name);
140 
142  av_freep(&dp->view_map);
143 
144  av_freep(pdec);
145 }
146 
147 static const char *dec_item_name(void *obj)
148 {
149  const DecoderPriv *dp = obj;
150 
151  return dp->log_name;
152 }
153 
154 static const AVClass dec_class = {
155  .class_name = "Decoder",
156  .version = LIBAVUTIL_VERSION_INT,
157  .parent_log_context_offset = offsetof(DecoderPriv, log_parent),
158  .item_name = dec_item_name,
159 };
160 
161 static int decoder_thread(void *arg);
162 
163 static int dec_alloc(DecoderPriv **pdec, Scheduler *sch, int send_end_ts)
164 {
165  DecoderPriv *dp;
166  int ret = 0;
167 
168  *pdec = NULL;
169 
170  dp = av_mallocz(sizeof(*dp));
171  if (!dp)
172  return AVERROR(ENOMEM);
173 
174  dp->frame = av_frame_alloc();
175  if (!dp->frame)
176  goto fail;
177 
178  dp->pkt = av_packet_alloc();
179  if (!dp->pkt)
180  goto fail;
181 
182  dp->index = -1;
183  dp->dec.class = &dec_class;
186  dp->last_frame_tb = (AVRational){ 1, 1 };
188 
189  ret = sch_add_dec(sch, decoder_thread, dp, send_end_ts);
190  if (ret < 0)
191  goto fail;
192  dp->sch = sch;
193  dp->sch_idx = ret;
194 
195  *pdec = dp;
196 
197  return 0;
198 fail:
199  dec_free((Decoder**)&dp);
200  return ret >= 0 ? AVERROR(ENOMEM) : ret;
201 }
202 
204  const AVFrame *frame)
205 {
206  const int prev = dp->last_frame_tb.den;
207  const int sr = frame->sample_rate;
208 
209  AVRational tb_new;
210  int64_t gcd;
211 
212  if (frame->sample_rate == dp->last_frame_sample_rate)
213  goto finish;
214 
215  gcd = av_gcd(prev, sr);
216 
217  if (prev / gcd >= INT_MAX / sr) {
219  "Audio timestamps cannot be represented exactly after "
220  "sample rate change: %d -> %d\n", prev, sr);
221 
222  // LCM of 192000, 44100, allows to represent all common samplerates
223  tb_new = (AVRational){ 1, 28224000 };
224  } else
225  tb_new = (AVRational){ 1, prev / gcd * sr };
226 
227  // keep the frame timebase if it is strictly better than
228  // the samplerate-defined one
229  if (frame->time_base.num == 1 && frame->time_base.den > tb_new.den &&
230  !(frame->time_base.den % tb_new.den))
231  tb_new = frame->time_base;
232 
235  dp->last_frame_tb, tb_new);
237  dp->last_frame_tb, tb_new);
238 
239  dp->last_frame_tb = tb_new;
240  dp->last_frame_sample_rate = frame->sample_rate;
241 
242 finish:
243  return dp->last_frame_tb;
244 }
245 
247 {
248  AVRational tb_filter = (AVRational){1, frame->sample_rate};
249  AVRational tb;
250  int64_t pts_pred;
251 
252  // on samplerate change, choose a new internal timebase for timestamp
253  // generation that can represent timestamps from all the samplerates
254  // seen so far
255  tb = audio_samplerate_update(dp, frame);
256  pts_pred = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 :
258 
259  if (frame->pts == AV_NOPTS_VALUE) {
260  frame->pts = pts_pred;
261  frame->time_base = tb;
262  } else if (dp->last_frame_pts != AV_NOPTS_VALUE &&
263  frame->pts > av_rescale_q_rnd(pts_pred, tb, frame->time_base,
264  AV_ROUND_UP)) {
265  // there was a gap in timestamps, reset conversion state
267  }
268 
269  frame->pts = av_rescale_delta(frame->time_base, frame->pts,
270  tb, frame->nb_samples,
272 
273  dp->last_frame_pts = frame->pts;
274  dp->last_frame_duration_est = av_rescale_q(frame->nb_samples,
275  tb_filter, tb);
276 
277  // finally convert to filtering timebase
278  frame->pts = av_rescale_q(frame->pts, tb, tb_filter);
279  frame->duration = frame->nb_samples;
280  frame->time_base = tb_filter;
281 }
282 
284 {
285  const int ts_unreliable = dp->flags & DECODER_FLAG_TS_UNRELIABLE;
286  const int fr_forced = dp->flags & DECODER_FLAG_FRAMERATE_FORCED;
287  int64_t codec_duration = 0;
288  // difference between this and last frame's timestamps
289  const int64_t ts_diff =
290  (frame->pts != AV_NOPTS_VALUE && dp->last_frame_pts != AV_NOPTS_VALUE) ?
291  frame->pts - dp->last_frame_pts : -1;
292 
293  // XXX lavf currently makes up frame durations when they are not provided by
294  // the container. As there is no way to reliably distinguish real container
295  // durations from the fake made-up ones, we use heuristics based on whether
296  // the container has timestamps. Eventually lavf should stop making up
297  // durations, then this should be simplified.
298 
299  // frame duration is unreliable (typically guessed by lavf) when it is equal
300  // to 1 and the actual duration of the last frame is more than 2x larger
301  const int duration_unreliable = frame->duration == 1 && ts_diff > 2 * frame->duration;
302 
303  // prefer frame duration for containers with timestamps
304  if (fr_forced ||
305  (frame->duration > 0 && !ts_unreliable && !duration_unreliable))
306  return frame->duration;
307 
308  if (dp->dec_ctx->framerate.den && dp->dec_ctx->framerate.num) {
309  int fields = frame->repeat_pict + 2;
310  AVRational field_rate = av_mul_q(dp->dec_ctx->framerate,
311  (AVRational){ 2, 1 });
312  codec_duration = av_rescale_q(fields, av_inv_q(field_rate),
313  frame->time_base);
314  }
315 
316  // prefer codec-layer duration for containers without timestamps
317  if (codec_duration > 0 && ts_unreliable)
318  return codec_duration;
319 
320  // when timestamps are available, repeat last frame's actual duration
321  // (i.e. pts difference between this and last frame)
322  if (ts_diff > 0)
323  return ts_diff;
324 
325  // try frame/codec duration
326  if (frame->duration > 0)
327  return frame->duration;
328  if (codec_duration > 0)
329  return codec_duration;
330 
331  // try average framerate
332  if (dp->framerate_in.num && dp->framerate_in.den) {
334  frame->time_base);
335  if (d > 0)
336  return d;
337  }
338 
339  // last resort is last frame's estimated duration, and 1
340  return FFMAX(dp->last_frame_duration_est, 1);
341 }
342 
344 {
345  DecoderPriv *dp = avctx->opaque;
346  AVFrame *output = NULL;
348  int err;
349 
350  if (input->format == output_format) {
351  // Nothing to do.
352  return 0;
353  }
354 
356  if (!output)
357  return AVERROR(ENOMEM);
358 
359  output->format = output_format;
360 
362  if (err < 0) {
363  av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
364  "output frame: %d.\n", err);
365  goto fail;
366  }
367 
369  if (err < 0) {
371  goto fail;
372  }
373 
377 
378  return 0;
379 
380 fail:
382  return err;
383 }
384 
386  unsigned *outputs_mask)
387 {
388 #if FFMPEG_OPT_TOP
390  av_log(dp, AV_LOG_WARNING, "-top is deprecated, use the setfield filter instead\n");
392  }
393 #endif
394 
395  if (frame->format == dp->hwaccel_pix_fmt) {
396  int err = hwaccel_retrieve_data(dp->dec_ctx, frame);
397  if (err < 0)
398  return err;
399  }
400 
401  frame->pts = frame->best_effort_timestamp;
402 
403  // forced fixed framerate
405  frame->pts = AV_NOPTS_VALUE;
406  frame->duration = 1;
407  frame->time_base = av_inv_q(dp->framerate_in);
408  }
409 
410  // no timestamp available - extrapolate from previous frame duration
411  if (frame->pts == AV_NOPTS_VALUE)
412  frame->pts = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 :
414 
415  // update timestamp history
417  dp->last_frame_pts = frame->pts;
418  dp->last_frame_tb = frame->time_base;
419 
420  if (debug_ts) {
421  av_log(dp, AV_LOG_INFO,
422  "decoder -> pts:%s pts_time:%s "
423  "pkt_dts:%s pkt_dts_time:%s "
424  "duration:%s duration_time:%s "
425  "keyframe:%d frame_type:%d time_base:%d/%d\n",
426  av_ts2str(frame->pts),
427  av_ts2timestr(frame->pts, &frame->time_base),
428  av_ts2str(frame->pkt_dts),
429  av_ts2timestr(frame->pkt_dts, &frame->time_base),
430  av_ts2str(frame->duration),
431  av_ts2timestr(frame->duration, &frame->time_base),
432  !!(frame->flags & AV_FRAME_FLAG_KEY), frame->pict_type,
433  frame->time_base.num, frame->time_base.den);
434  }
435 
436  if (dp->sar_override.num)
437  frame->sample_aspect_ratio = dp->sar_override;
438 
439  if (dp->apply_cropping) {
440  // lavfi does not require aligned frame data
442  if (ret < 0) {
443  av_log(dp, AV_LOG_ERROR, "Error applying decoder cropping\n");
444  return ret;
445  }
446  }
447 
448  if (frame->opaque)
449  *outputs_mask = (uintptr_t)frame->opaque;
450 
451  return 0;
452 }
453 
455 {
456  int ret = AVERROR_BUG;
457  AVSubtitle tmp = {
458  .format = src->format,
459  .start_display_time = src->start_display_time,
460  .end_display_time = src->end_display_time,
461  .num_rects = 0,
462  .rects = NULL,
463  .pts = src->pts
464  };
465 
466  if (!src->num_rects)
467  goto success;
468 
469  if (!(tmp.rects = av_calloc(src->num_rects, sizeof(*tmp.rects))))
470  return AVERROR(ENOMEM);
471 
472  for (int i = 0; i < src->num_rects; i++) {
473  AVSubtitleRect *src_rect = src->rects[i];
474  AVSubtitleRect *dst_rect;
475 
476  if (!(dst_rect = tmp.rects[i] = av_mallocz(sizeof(*tmp.rects[0])))) {
477  ret = AVERROR(ENOMEM);
478  goto cleanup;
479  }
480 
481  tmp.num_rects++;
482 
483  dst_rect->type = src_rect->type;
484  dst_rect->flags = src_rect->flags;
485 
486  dst_rect->x = src_rect->x;
487  dst_rect->y = src_rect->y;
488  dst_rect->w = src_rect->w;
489  dst_rect->h = src_rect->h;
490  dst_rect->nb_colors = src_rect->nb_colors;
491 
492  if (src_rect->text)
493  if (!(dst_rect->text = av_strdup(src_rect->text))) {
494  ret = AVERROR(ENOMEM);
495  goto cleanup;
496  }
497 
498  if (src_rect->ass)
499  if (!(dst_rect->ass = av_strdup(src_rect->ass))) {
500  ret = AVERROR(ENOMEM);
501  goto cleanup;
502  }
503 
504  for (int j = 0; j < 4; j++) {
505  // SUBTITLE_BITMAP images are special in the sense that they
506  // are like PAL8 images. first pointer to data, second to
507  // palette. This makes the size calculation match this.
508  size_t buf_size = src_rect->type == SUBTITLE_BITMAP && j == 1 ?
510  src_rect->h * src_rect->linesize[j];
511 
512  if (!src_rect->data[j])
513  continue;
514 
515  if (!(dst_rect->data[j] = av_memdup(src_rect->data[j], buf_size))) {
516  ret = AVERROR(ENOMEM);
517  goto cleanup;
518  }
519  dst_rect->linesize[j] = src_rect->linesize[j];
520  }
521  }
522 
523 success:
524  *dst = tmp;
525 
526  return 0;
527 
528 cleanup:
530 
531  return ret;
532 }
533 
534 static void subtitle_free(void *opaque, uint8_t *data)
535 {
536  AVSubtitle *sub = (AVSubtitle*)data;
537  avsubtitle_free(sub);
538  av_free(sub);
539 }
540 
541 static int subtitle_wrap_frame(AVFrame *frame, AVSubtitle *subtitle, int copy)
542 {
543  AVBufferRef *buf;
544  AVSubtitle *sub;
545  int ret;
546 
547  if (copy) {
548  sub = av_mallocz(sizeof(*sub));
549  ret = sub ? copy_av_subtitle(sub, subtitle) : AVERROR(ENOMEM);
550  if (ret < 0) {
551  av_freep(&sub);
552  return ret;
553  }
554  } else {
555  sub = av_memdup(subtitle, sizeof(*subtitle));
556  if (!sub)
557  return AVERROR(ENOMEM);
558  memset(subtitle, 0, sizeof(*subtitle));
559  }
560 
561  buf = av_buffer_create((uint8_t*)sub, sizeof(*sub),
562  subtitle_free, NULL, 0);
563  if (!buf) {
564  avsubtitle_free(sub);
565  av_freep(&sub);
566  return AVERROR(ENOMEM);
567  }
568 
569  frame->buf[0] = buf;
570 
571  return 0;
572 }
573 
575 {
576  const AVSubtitle *subtitle = (AVSubtitle*)frame->buf[0]->data;
577  int ret = 0;
578 
580  AVSubtitle *sub_prev = dp->sub_prev[0]->buf[0] ?
581  (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL;
582  int end = 1;
583  if (sub_prev) {
584  end = av_rescale(subtitle->pts - sub_prev->pts,
585  1000, AV_TIME_BASE);
586  if (end < sub_prev->end_display_time) {
587  av_log(dp, AV_LOG_DEBUG,
588  "Subtitle duration reduced from %"PRId32" to %d%s\n",
589  sub_prev->end_display_time, end,
590  end <= 0 ? ", dropping it" : "");
591  sub_prev->end_display_time = end;
592  }
593  }
594 
595  av_frame_unref(dp->sub_prev[1]);
597 
598  frame = dp->sub_prev[0];
599  subtitle = frame->buf[0] ? (AVSubtitle*)frame->buf[0]->data : NULL;
600 
601  FFSWAP(AVFrame*, dp->sub_prev[0], dp->sub_prev[1]);
602 
603  if (end <= 0)
604  return 0;
605  }
606 
607  if (!subtitle)
608  return 0;
609 
610  ret = sch_dec_send(dp->sch, dp->sch_idx, 0, frame);
611  if (ret < 0)
613 
614  return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
615 }
616 
617 static int fix_sub_duration_heartbeat(DecoderPriv *dp, int64_t signal_pts)
618 {
619  int ret = AVERROR_BUG;
620  AVSubtitle *prev_subtitle = dp->sub_prev[0]->buf[0] ?
621  (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL;
622  AVSubtitle *subtitle;
623 
624  if (!(dp->flags & DECODER_FLAG_FIX_SUB_DURATION) || !prev_subtitle ||
625  !prev_subtitle->num_rects || signal_pts <= prev_subtitle->pts)
626  return 0;
627 
629  ret = subtitle_wrap_frame(dp->sub_heartbeat, prev_subtitle, 1);
630  if (ret < 0)
631  return ret;
632 
633  subtitle = (AVSubtitle*)dp->sub_heartbeat->buf[0]->data;
634  subtitle->pts = signal_pts;
635 
636  return process_subtitle(dp, dp->sub_heartbeat);
637 }
638 
640  AVFrame *frame)
641 {
642  AVPacket *flush_pkt = NULL;
643  AVSubtitle subtitle;
644  int got_output;
645  int ret;
646 
647  if (pkt && (intptr_t)pkt->opaque == PKT_OPAQUE_SUB_HEARTBEAT) {
648  frame->pts = pkt->pts;
649  frame->time_base = pkt->time_base;
650  frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_SUB_HEARTBEAT;
651 
652  ret = sch_dec_send(dp->sch, dp->sch_idx, 0, frame);
653  return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
654  } else if (pkt && (intptr_t)pkt->opaque == PKT_OPAQUE_FIX_SUB_DURATION) {
656  AV_TIME_BASE_Q));
657  }
658 
659  if (!pkt) {
660  flush_pkt = av_packet_alloc();
661  if (!flush_pkt)
662  return AVERROR(ENOMEM);
663  }
664 
665  ret = avcodec_decode_subtitle2(dp->dec_ctx, &subtitle, &got_output,
666  pkt ? pkt : flush_pkt);
667  av_packet_free(&flush_pkt);
668 
669  if (ret < 0) {
670  av_log(dp, AV_LOG_ERROR, "Error decoding subtitles: %s\n",
671  av_err2str(ret));
672  dp->dec.decode_errors++;
673  return exit_on_error ? ret : 0;
674  }
675 
676  if (!got_output)
677  return pkt ? 0 : AVERROR_EOF;
678 
679  dp->dec.frames_decoded++;
680 
681  // XXX the queue for transferring data to consumers runs
682  // on AVFrames, so we wrap AVSubtitle in an AVBufferRef and put that
683  // inside the frame
684  // eventually, subtitles should be switched to use AVFrames natively
685  ret = subtitle_wrap_frame(frame, &subtitle, 0);
686  if (ret < 0) {
687  avsubtitle_free(&subtitle);
688  return ret;
689  }
690 
691  frame->width = dp->dec_ctx->width;
692  frame->height = dp->dec_ctx->height;
693 
694  return process_subtitle(dp, frame);
695 }
696 
698 {
699  AVCodecContext *dec = dp->dec_ctx;
700  const char *type_desc = av_get_media_type_string(dec->codec_type);
701  int ret;
702 
703  if (dec->codec_type == AVMEDIA_TYPE_SUBTITLE)
704  return transcode_subtitles(dp, pkt, frame);
705 
706  // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
707  // reason. This seems like a semi-critical bug. Don't trigger EOF, and
708  // skip the packet.
709  if (pkt && pkt->size == 0)
710  return 0;
711 
712  if (pkt && (dp->flags & DECODER_FLAG_TS_UNRELIABLE)) {
715  }
716 
717  if (pkt) {
718  FrameData *fd = packet_data(pkt);
719  if (!fd)
720  return AVERROR(ENOMEM);
722  }
723 
724  ret = avcodec_send_packet(dec, pkt);
725  if (ret < 0 && !(ret == AVERROR_EOF && !pkt)) {
726  // In particular, we don't expect AVERROR(EAGAIN), because we read all
727  // decoded frames with avcodec_receive_frame() until done.
728  if (ret == AVERROR(EAGAIN)) {
729  av_log(dp, AV_LOG_FATAL, "A decoder returned an unexpected error code. "
730  "This is a bug, please report it.\n");
731  return AVERROR_BUG;
732  }
733  av_log(dp, AV_LOG_ERROR, "Error submitting %s to decoder: %s\n",
734  pkt ? "packet" : "EOF", av_err2str(ret));
735 
736  if (ret != AVERROR_EOF) {
737  dp->dec.decode_errors++;
738  if (!exit_on_error)
739  ret = 0;
740  }
741 
742  return ret;
743  }
744 
745  while (1) {
746  FrameData *fd;
747  unsigned outputs_mask = 1;
748 
750 
753  update_benchmark("decode_%s %s", type_desc, dp->parent_name);
754 
755  if (ret == AVERROR(EAGAIN)) {
756  av_assert0(pkt); // should never happen during flushing
757  return 0;
758  } else if (ret == AVERROR_EOF) {
759  return ret;
760  } else if (ret < 0) {
761  av_log(dp, AV_LOG_ERROR, "Decoding error: %s\n", av_err2str(ret));
762  dp->dec.decode_errors++;
763 
764  if (exit_on_error)
765  return ret;
766 
767  continue;
768  }
769 
770  if (frame->decode_error_flags || (frame->flags & AV_FRAME_FLAG_CORRUPT)) {
772  "corrupt decoded frame\n");
773  if (exit_on_error)
774  return AVERROR_INVALIDDATA;
775  }
776 
777  fd = frame_data(frame);
778  if (!fd) {
780  return AVERROR(ENOMEM);
781  }
782  fd->dec.pts = frame->pts;
783  fd->dec.tb = dec->pkt_timebase;
784  fd->dec.frame_num = dec->frame_num - 1;
786 
788 
789  frame->time_base = dec->pkt_timebase;
790 
791  if (dec->codec_type == AVMEDIA_TYPE_AUDIO) {
792  dp->dec.samples_decoded += frame->nb_samples;
793 
794  audio_ts_process(dp, frame);
795  } else {
796  ret = video_frame_process(dp, frame, &outputs_mask);
797  if (ret < 0) {
798  av_log(dp, AV_LOG_FATAL,
799  "Error while processing the decoded data\n");
800  return ret;
801  }
802  }
803 
804  dp->dec.frames_decoded++;
805 
806  for (int i = 0; i < stdc_count_ones(outputs_mask); i++) {
807  AVFrame *to_send = frame;
808  int pos;
809 
810  av_assert0(outputs_mask);
811  pos = stdc_trailing_zeros(outputs_mask);
812  outputs_mask &= ~(1U << pos);
813 
814  // this is not the last output and sch_dec_send() consumes the frame
815  // given to it, so make a temporary reference
816  if (outputs_mask) {
817  to_send = dp->frame_tmp_ref;
818  ret = av_frame_ref(to_send, frame);
819  if (ret < 0)
820  return ret;
821  }
822 
823  ret = sch_dec_send(dp->sch, dp->sch_idx, pos, to_send);
824  if (ret < 0) {
825  av_frame_unref(to_send);
826  return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
827  }
828  }
829  }
830 }
831 
832 static int dec_open(DecoderPriv *dp, AVDictionary **dec_opts,
833  const DecoderOpts *o, AVFrame *param_out);
834 
836 {
837  DecoderOpts o;
838  const FrameData *fd;
839  char name[16];
840 
841  if (!pkt->opaque_ref)
842  return AVERROR_BUG;
843  fd = (FrameData *)pkt->opaque_ref->data;
844 
845  if (!fd->par_enc)
846  return AVERROR_BUG;
847 
848  memset(&o, 0, sizeof(o));
849 
850  o.par = fd->par_enc;
851  o.time_base = pkt->time_base;
852 
853  o.codec = dp->standalone_init.codec;
854  if (!o.codec)
856  if (!o.codec) {
858 
859  av_log(dp, AV_LOG_ERROR, "Cannot find a decoder for codec ID '%s'\n",
860  desc ? desc->name : "?");
862  }
863 
864  snprintf(name, sizeof(name), "dec%d", dp->index);
865  o.name = name;
866 
867  return dec_open(dp, &dp->standalone_init.opts, &o, NULL);
868 }
869 
870 static void dec_thread_set_name(const DecoderPriv *dp)
871 {
872  char name[16] = "dec";
873 
874  if (dp->index >= 0)
875  av_strlcatf(name, sizeof(name), "%d", dp->index);
876  else if (dp->parent_name)
877  av_strlcat(name, dp->parent_name, sizeof(name));
878 
879  if (dp->dec_ctx)
880  av_strlcatf(name, sizeof(name), ":%s", dp->dec_ctx->codec->name);
881 
883 }
884 
886 {
887  av_packet_free(&dt->pkt);
888  av_frame_free(&dt->frame);
889 
890  memset(dt, 0, sizeof(*dt));
891 }
892 
894 {
895  memset(dt, 0, sizeof(*dt));
896 
897  dt->frame = av_frame_alloc();
898  if (!dt->frame)
899  goto fail;
900 
901  dt->pkt = av_packet_alloc();
902  if (!dt->pkt)
903  goto fail;
904 
905  return 0;
906 
907 fail:
908  dec_thread_uninit(dt);
909  return AVERROR(ENOMEM);
910 }
911 
912 static int decoder_thread(void *arg)
913 {
914  DecoderPriv *dp = arg;
915  DecThreadContext dt;
916  int ret = 0, input_status = 0;
917 
918  ret = dec_thread_init(&dt);
919  if (ret < 0)
920  goto finish;
921 
923 
924  while (!input_status) {
925  int flush_buffers, have_data;
926 
927  input_status = sch_dec_receive(dp->sch, dp->sch_idx, dt.pkt);
928  have_data = input_status >= 0 &&
929  (dt.pkt->buf || dt.pkt->side_data_elems ||
930  (intptr_t)dt.pkt->opaque == PKT_OPAQUE_SUB_HEARTBEAT ||
931  (intptr_t)dt.pkt->opaque == PKT_OPAQUE_FIX_SUB_DURATION);
932  flush_buffers = input_status >= 0 && !have_data;
933  if (!have_data)
934  av_log(dp, AV_LOG_VERBOSE, "Decoder thread received %s packet\n",
935  flush_buffers ? "flush" : "EOF");
936 
937  // this is a standalone decoder that has not been initialized yet
938  if (!dp->dec_ctx) {
939  if (flush_buffers)
940  continue;
941  if (input_status < 0) {
942  av_log(dp, AV_LOG_ERROR,
943  "Cannot initialize a standalone decoder\n");
944  ret = input_status;
945  goto finish;
946  }
947 
948  ret = dec_standalone_open(dp, dt.pkt);
949  if (ret < 0)
950  goto finish;
951  }
952 
953  ret = packet_decode(dp, have_data ? dt.pkt : NULL, dt.frame);
954 
955  av_packet_unref(dt.pkt);
956  av_frame_unref(dt.frame);
957 
958  // AVERROR_EOF - EOF from the decoder
959  // AVERROR_EXIT - EOF from the scheduler
960  // we treat them differently when flushing
961  if (ret == AVERROR_EXIT) {
962  ret = AVERROR_EOF;
963  flush_buffers = 0;
964  }
965 
966  if (ret == AVERROR_EOF) {
967  av_log(dp, AV_LOG_VERBOSE, "Decoder returned EOF, %s\n",
968  flush_buffers ? "resetting" : "finishing");
969 
970  if (!flush_buffers)
971  break;
972 
973  /* report last frame duration to the scheduler */
974  if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
976  dt.pkt->time_base = dp->last_frame_tb;
977  }
978 
980  } else if (ret < 0) {
981  av_log(dp, AV_LOG_ERROR, "Error processing packet in decoder: %s\n",
982  av_err2str(ret));
983  break;
984  }
985  }
986 
987  // EOF is normal thread termination
988  if (ret == AVERROR_EOF)
989  ret = 0;
990 
991  // on success send EOF timestamp to our downstreams
992  if (ret >= 0) {
993  float err_rate;
994 
995  av_frame_unref(dt.frame);
996 
997  dt.frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_EOF;
1000  dt.frame->time_base = dp->last_frame_tb;
1001 
1002  ret = sch_dec_send(dp->sch, dp->sch_idx, 0, dt.frame);
1003  if (ret < 0 && ret != AVERROR_EOF) {
1004  av_log(dp, AV_LOG_FATAL,
1005  "Error signalling EOF timestamp: %s\n", av_err2str(ret));
1006  goto finish;
1007  }
1008  ret = 0;
1009 
1010  err_rate = (dp->dec.frames_decoded || dp->dec.decode_errors) ?
1011  dp->dec.decode_errors / (dp->dec.frames_decoded + dp->dec.decode_errors) : 0.f;
1012  if (err_rate > max_error_rate) {
1013  av_log(dp, AV_LOG_FATAL, "Decode error rate %g exceeds maximum %g\n",
1014  err_rate, max_error_rate);
1016  } else if (err_rate)
1017  av_log(dp, AV_LOG_VERBOSE, "Decode error rate %g\n", err_rate);
1018  }
1019 
1020 finish:
1021  dec_thread_uninit(&dt);
1022 
1023  return ret;
1024 }
1025 
1027  SchedulerNode *src)
1028 {
1029  DecoderPriv *dp = dp_from_dec(d);
1030  unsigned out_idx = 0;
1031  int ret;
1032 
1033  if (dp->multiview_user_config) {
1034  if (!vs || vs->type == VIEW_SPECIFIER_TYPE_NONE) {
1035  *src = SCH_DEC_OUT(dp->sch_idx, 0);
1036  return 0;
1037  }
1038 
1039  av_log(dp, AV_LOG_ERROR,
1040  "Manually selecting views with -view_ids cannot be combined "
1041  "with view selection via stream specifiers. It is strongly "
1042  "recommended you always use stream specifiers only.\n");
1043  return AVERROR(EINVAL);
1044  }
1045 
1046  // when multiview_user_config is not set, NONE specifier is treated
1047  // as requesting the base view
1048  vs = (vs && vs->type != VIEW_SPECIFIER_TYPE_NONE) ? vs :
1049  &(ViewSpecifier){ .type = VIEW_SPECIFIER_TYPE_IDX, .val = 0 };
1050 
1051  // check if the specifier matches an already-existing one
1052  for (int i = 0; i < dp->nb_views_requested; i++) {
1053  const ViewSpecifier *vs1 = &dp->views_requested[i].vs;
1054 
1055  if (vs->type == vs1->type &&
1056  (vs->type == VIEW_SPECIFIER_TYPE_ALL || vs->val == vs1->val)) {
1058  return 0;
1059  }
1060  }
1061 
1062  // we use a bitmask to map view IDs to decoder outputs, which
1063  // limits the number of outputs allowed
1064  if (dp->nb_views_requested >= sizeof(dp->view_map[0].out_mask) * 8) {
1065  av_log(dp, AV_LOG_ERROR, "Too many view specifiers\n");
1066  return AVERROR(ENOSYS);
1067  }
1068 
1070  if (ret < 0)
1071  return ret;
1072 
1073  if (dp->nb_views_requested > 1) {
1074  ret = sch_add_dec_output(dp->sch, dp->sch_idx);
1075  if (ret < 0)
1076  return ret;
1077  out_idx = ret;
1078  }
1079 
1080  dp->views_requested[dp->nb_views_requested - 1].out_idx = out_idx;
1081  dp->views_requested[dp->nb_views_requested - 1].vs = *vs;
1082 
1083  *src = SCH_DEC_OUT(dp->sch_idx,
1085 
1086  return 0;
1087 }
1088 
1090 {
1091  unsigned views_wanted = 0;
1092 
1093  unsigned nb_view_ids_av, nb_view_ids;
1094  unsigned *view_ids_av = NULL, *view_pos_av = NULL;
1095  int *view_ids = NULL;
1096  int ret;
1097 
1098  // no views/only base view were requested - do nothing
1099  if (!dp->nb_views_requested ||
1100  (dp->nb_views_requested == 1 &&
1102  dp->views_requested[0].vs.val == 0))
1103  return 0;
1104 
1105  av_freep(&dp->view_map);
1106  dp->nb_view_map = 0;
1107 
1108  // retrieve views available in current CVS
1109  ret = av_opt_get_array_size(dec_ctx, "view_ids_available",
1110  AV_OPT_SEARCH_CHILDREN, &nb_view_ids_av);
1111  if (ret < 0) {
1112  av_log(dp, AV_LOG_ERROR,
1113  "Multiview decoding requested, but decoder '%s' does not "
1114  "support it\n", dec_ctx->codec->name);
1115  return AVERROR(ENOSYS);
1116  }
1117 
1118  if (nb_view_ids_av) {
1119  unsigned nb_view_pos_av;
1120 
1121  if (nb_view_ids_av >= sizeof(views_wanted) * 8) {
1122  av_log(dp, AV_LOG_ERROR, "Too many views in video: %u\n", nb_view_ids_av);
1123  ret = AVERROR(ENOSYS);
1124  goto fail;
1125  }
1126 
1127  view_ids_av = av_calloc(nb_view_ids_av, sizeof(*view_ids_av));
1128  if (!view_ids_av) {
1129  ret = AVERROR(ENOMEM);
1130  goto fail;
1131  }
1132 
1133  ret = av_opt_get_array(dec_ctx, "view_ids_available",
1134  AV_OPT_SEARCH_CHILDREN, 0, nb_view_ids_av,
1135  AV_OPT_TYPE_UINT, view_ids_av);
1136  if (ret < 0)
1137  goto fail;
1138 
1139  ret = av_opt_get_array_size(dec_ctx, "view_pos_available",
1140  AV_OPT_SEARCH_CHILDREN, &nb_view_pos_av);
1141  if (ret >= 0 && nb_view_pos_av == nb_view_ids_av) {
1142  view_pos_av = av_calloc(nb_view_ids_av, sizeof(*view_pos_av));
1143  if (!view_pos_av) {
1144  ret = AVERROR(ENOMEM);
1145  goto fail;
1146  }
1147 
1148  ret = av_opt_get_array(dec_ctx, "view_pos_available",
1149  AV_OPT_SEARCH_CHILDREN, 0, nb_view_ids_av,
1150  AV_OPT_TYPE_UINT, view_pos_av);
1151  if (ret < 0)
1152  goto fail;
1153  }
1154  } else {
1155  // assume there is a single view with ID=0
1156  nb_view_ids_av = 1;
1157  view_ids_av = av_calloc(nb_view_ids_av, sizeof(*view_ids_av));
1158  view_pos_av = av_calloc(nb_view_ids_av, sizeof(*view_pos_av));
1159  if (!view_ids_av || !view_pos_av) {
1160  ret = AVERROR(ENOMEM);
1161  goto fail;
1162  }
1163  view_pos_av[0] = AV_STEREO3D_VIEW_UNSPEC;
1164  }
1165 
1166  dp->view_map = av_calloc(nb_view_ids_av, sizeof(*dp->view_map));
1167  if (!dp->view_map) {
1168  ret = AVERROR(ENOMEM);
1169  goto fail;
1170  }
1171  dp->nb_view_map = nb_view_ids_av;
1172 
1173  for (int i = 0; i < dp->nb_view_map; i++)
1174  dp->view_map[i].id = view_ids_av[i];
1175 
1176  // figure out which views should go to which output
1177  for (int i = 0; i < dp->nb_views_requested; i++) {
1178  const ViewSpecifier *vs = &dp->views_requested[i].vs;
1179 
1180  switch (vs->type) {
1182  if (vs->val >= nb_view_ids_av) {
1184  "View with index %u requested, but only %u views available "
1185  "in current video sequence (more views may or may not be "
1186  "available in later sequences).\n",
1187  vs->val, nb_view_ids_av);
1188  if (exit_on_error) {
1189  ret = AVERROR(EINVAL);
1190  goto fail;
1191  }
1192 
1193  continue;
1194  }
1195  views_wanted |= 1U << vs->val;
1196  dp->view_map[vs->val].out_mask |= 1ULL << i;
1197 
1198  break;
1199  case VIEW_SPECIFIER_TYPE_ID: {
1200  int view_idx = -1;
1201 
1202  for (unsigned j = 0; j < nb_view_ids_av; j++) {
1203  if (view_ids_av[j] == vs->val) {
1204  view_idx = j;
1205  break;
1206  }
1207  }
1208  if (view_idx < 0) {
1210  "View with ID %u requested, but is not available "
1211  "in the video sequence\n", vs->val);
1212  if (exit_on_error) {
1213  ret = AVERROR(EINVAL);
1214  goto fail;
1215  }
1216 
1217  continue;
1218  }
1219  views_wanted |= 1U << view_idx;
1220  dp->view_map[view_idx].out_mask |= 1ULL << i;
1221 
1222  break;
1223  }
1224  case VIEW_SPECIFIER_TYPE_POS: {
1225  int view_idx = -1;
1226 
1227  for (unsigned j = 0; view_pos_av && j < nb_view_ids_av; j++) {
1228  if (view_pos_av[j] == vs->val) {
1229  view_idx = j;
1230  break;
1231  }
1232  }
1233  if (view_idx < 0) {
1235  "View position '%s' requested, but is not available "
1236  "in the video sequence\n", av_stereo3d_view_name(vs->val));
1237  if (exit_on_error) {
1238  ret = AVERROR(EINVAL);
1239  goto fail;
1240  }
1241 
1242  continue;
1243  }
1244  views_wanted |= 1U << view_idx;
1245  dp->view_map[view_idx].out_mask |= 1ULL << i;
1246 
1247  break;
1248  }
1250  views_wanted |= (1U << nb_view_ids_av) - 1;
1251 
1252  for (int j = 0; j < dp->nb_view_map; j++)
1253  dp->view_map[j].out_mask |= 1ULL << i;
1254 
1255  break;
1256  }
1257  }
1258  if (!views_wanted) {
1259  av_log(dp, AV_LOG_ERROR, "No views were selected for decoding\n");
1260  ret = AVERROR(EINVAL);
1261  goto fail;
1262  }
1263 
1264  // signal to decoder which views we want
1265  nb_view_ids = stdc_count_ones(views_wanted);
1266  view_ids = av_malloc_array(nb_view_ids, sizeof(*view_ids));
1267  if (!view_ids) {
1268  ret = AVERROR(ENOMEM);
1269  goto fail;
1270  }
1271 
1272  for (unsigned i = 0; i < nb_view_ids; i++) {
1273  int pos;
1274 
1275  av_assert0(views_wanted);
1276  pos = stdc_trailing_zeros(views_wanted);
1277  views_wanted &= ~(1U << pos);
1278 
1279  view_ids[i] = view_ids_av[pos];
1280  }
1281 
1282  // unset view_ids in case we set it earlier
1284 
1286  0, nb_view_ids, AV_OPT_TYPE_INT, view_ids);
1287  if (ret < 0)
1288  goto fail;
1289 
1290  if (!dp->frame_tmp_ref) {
1291  dp->frame_tmp_ref = av_frame_alloc();
1292  if (!dp->frame_tmp_ref) {
1293  ret = AVERROR(ENOMEM);
1294  goto fail;
1295  }
1296  }
1297 
1298 fail:
1299  av_freep(&view_ids_av);
1300  av_freep(&view_pos_av);
1301  av_freep(&view_ids);
1302 
1303  return ret;
1304 }
1305 
1306 static void multiview_check_manual(DecoderPriv *dp, const AVDictionary *dec_opts)
1307 {
1308  if (av_dict_get(dec_opts, "view_ids", NULL, 0)) {
1309  av_log(dp, AV_LOG_WARNING, "Manually selecting views with -view_ids "
1310  "is not recommended, use view specifiers instead\n");
1311  dp->multiview_user_config = 1;
1312  }
1313 }
1314 
1316 {
1317  DecoderPriv *dp = s->opaque;
1318  const enum AVPixelFormat *p;
1319  int ret;
1320 
1321  ret = multiview_setup(dp, s);
1322  if (ret < 0) {
1323  av_log(dp, AV_LOG_ERROR, "Error setting up multiview decoding: %s\n",
1324  av_err2str(ret));
1325  return AV_PIX_FMT_NONE;
1326  }
1327 
1328  for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
1330  const AVCodecHWConfig *config = NULL;
1331 
1332  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1333  break;
1334 
1335  if (dp->hwaccel_id == HWACCEL_GENERIC ||
1336  dp->hwaccel_id == HWACCEL_AUTO) {
1337  for (int i = 0;; i++) {
1338  config = avcodec_get_hw_config(s->codec, i);
1339  if (!config)
1340  break;
1341  if (!(config->methods &
1343  continue;
1344  if (config->pix_fmt == *p)
1345  break;
1346  }
1347  }
1348  if (config && config->device_type == dp->hwaccel_device_type) {
1349  dp->hwaccel_pix_fmt = *p;
1350  break;
1351  }
1352  }
1353 
1354  return *p;
1355 }
1356 
1358 {
1359  DecoderPriv *dp = dec_ctx->opaque;
1360 
1361  // for multiview video, store the output mask in frame opaque
1362  if (dp->nb_view_map) {
1364  int view_id = sd ? *(int*)sd->data : 0;
1365 
1366  for (int i = 0; i < dp->nb_view_map; i++) {
1367  if (dp->view_map[i].id == view_id) {
1368  frame->opaque = (void*)dp->view_map[i].out_mask;
1369  break;
1370  }
1371  }
1372  }
1373 
1375 }
1376 
1378 {
1379  const AVCodecHWConfig *config;
1380  HWDevice *dev;
1381  for (int i = 0;; i++) {
1382  config = avcodec_get_hw_config(codec, i);
1383  if (!config)
1384  return NULL;
1386  continue;
1387  dev = hw_device_get_by_type(config->device_type);
1388  if (dev)
1389  return dev;
1390  }
1391 }
1392 
1394  const AVCodec *codec,
1395  const char *hwaccel_device)
1396 {
1397  const AVCodecHWConfig *config;
1398  enum AVHWDeviceType type;
1399  HWDevice *dev = NULL;
1400  int err, auto_device = 0;
1401 
1402  if (hwaccel_device) {
1403  dev = hw_device_get_by_name(hwaccel_device);
1404  if (!dev) {
1405  if (dp->hwaccel_id == HWACCEL_AUTO) {
1406  auto_device = 1;
1407  } else if (dp->hwaccel_id == HWACCEL_GENERIC) {
1408  type = dp->hwaccel_device_type;
1409  err = hw_device_init_from_type(type, hwaccel_device,
1410  &dev);
1411  } else {
1412  // This will be dealt with by API-specific initialisation
1413  // (using hwaccel_device), so nothing further needed here.
1414  return 0;
1415  }
1416  } else {
1417  if (dp->hwaccel_id == HWACCEL_AUTO) {
1418  dp->hwaccel_device_type = dev->type;
1419  } else if (dp->hwaccel_device_type != dev->type) {
1420  av_log(dp, AV_LOG_ERROR, "Invalid hwaccel device "
1421  "specified for decoder: device %s of type %s is not "
1422  "usable with hwaccel %s.\n", dev->name,
1425  return AVERROR(EINVAL);
1426  }
1427  }
1428  } else {
1429  if (dp->hwaccel_id == HWACCEL_AUTO) {
1430  auto_device = 1;
1431  } else if (dp->hwaccel_id == HWACCEL_GENERIC) {
1432  type = dp->hwaccel_device_type;
1433  dev = hw_device_get_by_type(type);
1434 
1435  // When "-qsv_device device" is used, an internal QSV device named
1436  // as "__qsv_device" is created. Another QSV device is created too
1437  // if "-init_hw_device qsv=name:device" is used. There are 2 QSV devices
1438  // if both "-qsv_device device" and "-init_hw_device qsv=name:device"
1439  // are used, hw_device_get_by_type(AV_HWDEVICE_TYPE_QSV) returns NULL.
1440  // To keep back-compatibility with the removed ad-hoc libmfx setup code,
1441  // call hw_device_get_by_name("__qsv_device") to select the internal QSV
1442  // device.
1443  if (!dev && type == AV_HWDEVICE_TYPE_QSV)
1444  dev = hw_device_get_by_name("__qsv_device");
1445 
1446  if (!dev)
1447  err = hw_device_init_from_type(type, NULL, &dev);
1448  } else {
1449  dev = hw_device_match_by_codec(codec);
1450  if (!dev) {
1451  // No device for this codec, but not using generic hwaccel
1452  // and therefore may well not need one - ignore.
1453  return 0;
1454  }
1455  }
1456  }
1457 
1458  if (auto_device) {
1459  if (!avcodec_get_hw_config(codec, 0)) {
1460  // Decoder does not support any hardware devices.
1461  return 0;
1462  }
1463  for (int i = 0; !dev; i++) {
1464  config = avcodec_get_hw_config(codec, i);
1465  if (!config)
1466  break;
1467  type = config->device_type;
1468  dev = hw_device_get_by_type(type);
1469  if (dev) {
1470  av_log(dp, AV_LOG_INFO, "Using auto "
1471  "hwaccel type %s with existing device %s.\n",
1473  }
1474  }
1475  for (int i = 0; !dev; i++) {
1476  config = avcodec_get_hw_config(codec, i);
1477  if (!config)
1478  break;
1479  type = config->device_type;
1480  // Try to make a new device of this type.
1481  err = hw_device_init_from_type(type, hwaccel_device,
1482  &dev);
1483  if (err < 0) {
1484  // Can't make a device of this type.
1485  continue;
1486  }
1487  if (hwaccel_device) {
1488  av_log(dp, AV_LOG_INFO, "Using auto "
1489  "hwaccel type %s with new device created "
1490  "from %s.\n", av_hwdevice_get_type_name(type),
1491  hwaccel_device);
1492  } else {
1493  av_log(dp, AV_LOG_INFO, "Using auto "
1494  "hwaccel type %s with new default device.\n",
1496  }
1497  }
1498  if (dev) {
1499  dp->hwaccel_device_type = type;
1500  } else {
1501  av_log(dp, AV_LOG_INFO, "Auto hwaccel "
1502  "disabled: no device found.\n");
1503  dp->hwaccel_id = HWACCEL_NONE;
1504  return 0;
1505  }
1506  }
1507 
1508  if (!dev) {
1509  av_log(dp, AV_LOG_ERROR, "No device available "
1510  "for decoder: device type %s needed for codec %s.\n",
1512  return err;
1513  }
1514 
1516  if (!dp->dec_ctx->hw_device_ctx)
1517  return AVERROR(ENOMEM);
1518 
1519  return 0;
1520 }
1521 
1522 static int dec_open(DecoderPriv *dp, AVDictionary **dec_opts,
1523  const DecoderOpts *o, AVFrame *param_out)
1524 {
1525  const AVCodec *codec = o->codec;
1526  int ret;
1527 
1528  dp->flags = o->flags;
1529  dp->log_parent = o->log_parent;
1530 
1531  dp->dec.type = codec->type;
1532  dp->framerate_in = o->framerate;
1533 
1534  dp->hwaccel_id = o->hwaccel_id;
1537 
1538  snprintf(dp->log_name, sizeof(dp->log_name), "dec:%s", codec->name);
1539 
1540  dp->parent_name = av_strdup(o->name ? o->name : "");
1541  if (!dp->parent_name)
1542  return AVERROR(ENOMEM);
1543 
1544  if (codec->type == AVMEDIA_TYPE_SUBTITLE &&
1546  for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++) {
1547  dp->sub_prev[i] = av_frame_alloc();
1548  if (!dp->sub_prev[i])
1549  return AVERROR(ENOMEM);
1550  }
1551  dp->sub_heartbeat = av_frame_alloc();
1552  if (!dp->sub_heartbeat)
1553  return AVERROR(ENOMEM);
1554  }
1555 
1557 
1558  dp->dec_ctx = avcodec_alloc_context3(codec);
1559  if (!dp->dec_ctx)
1560  return AVERROR(ENOMEM);
1561 
1563  if (ret < 0) {
1564  av_log(dp, AV_LOG_ERROR, "Error initializing the decoder context.\n");
1565  return ret;
1566  }
1567 
1568  dp->dec_ctx->opaque = dp;
1569  dp->dec_ctx->get_format = get_format;
1571  dp->dec_ctx->pkt_timebase = o->time_base;
1572 
1573  if (!av_dict_get(*dec_opts, "threads", NULL, 0))
1574  av_dict_set(dec_opts, "threads", "auto", 0);
1575 
1577  if (ret < 0) {
1578  av_log(dp, AV_LOG_ERROR,
1579  "Hardware device setup failed for decoder: %s\n",
1580  av_err2str(ret));
1581  return ret;
1582  }
1583 
1585  if (ret < 0) {
1586  av_log(dp, AV_LOG_ERROR, "Error applying decoder options: %s\n",
1587  av_err2str(ret));
1588  return ret;
1589  }
1590  ret = check_avoptions(*dec_opts);
1591  if (ret < 0)
1592  return ret;
1593 
1595  if (o->flags & DECODER_FLAG_BITEXACT)
1597 
1598  // we apply cropping outselves
1600  dp->dec_ctx->apply_cropping = 0;
1601 
1602  if ((ret = avcodec_open2(dp->dec_ctx, codec, NULL)) < 0) {
1603  av_log(dp, AV_LOG_ERROR, "Error while opening decoder: %s\n",
1604  av_err2str(ret));
1605  return ret;
1606  }
1607 
1608  if (dp->dec_ctx->hw_device_ctx) {
1609  // Update decoder extra_hw_frames option to account for the
1610  // frames held in queues inside the ffmpeg utility. This is
1611  // called after avcodec_open2() because the user-set value of
1612  // extra_hw_frames becomes valid in there, and we need to add
1613  // this on top of it.
1614  int extra_frames = DEFAULT_FRAME_THREAD_QUEUE_SIZE;
1615  if (dp->dec_ctx->extra_hw_frames >= 0)
1616  dp->dec_ctx->extra_hw_frames += extra_frames;
1617  else
1618  dp->dec_ctx->extra_hw_frames = extra_frames;
1619  }
1620 
1623 
1624  if (param_out) {
1625  if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1626  param_out->format = dp->dec_ctx->sample_fmt;
1627  param_out->sample_rate = dp->dec_ctx->sample_rate;
1628 
1629  ret = av_channel_layout_copy(&param_out->ch_layout, &dp->dec_ctx->ch_layout);
1630  if (ret < 0)
1631  return ret;
1632  } else if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1633  param_out->format = dp->dec_ctx->pix_fmt;
1634  param_out->width = dp->dec_ctx->width;
1635  param_out->height = dp->dec_ctx->height;
1637  param_out->colorspace = dp->dec_ctx->colorspace;
1638  param_out->color_range = dp->dec_ctx->color_range;
1639  }
1640 
1641  param_out->time_base = dp->dec_ctx->pkt_timebase;
1642  }
1643 
1644  return 0;
1645 }
1646 
1647 int dec_init(Decoder **pdec, Scheduler *sch,
1648  AVDictionary **dec_opts, const DecoderOpts *o,
1649  AVFrame *param_out)
1650 {
1651  DecoderPriv *dp;
1652  int ret;
1653 
1654  *pdec = NULL;
1655 
1656  ret = dec_alloc(&dp, sch, !!(o->flags & DECODER_FLAG_SEND_END_TS));
1657  if (ret < 0)
1658  return ret;
1659 
1660  multiview_check_manual(dp, *dec_opts);
1661 
1662  ret = dec_open(dp, dec_opts, o, param_out);
1663  if (ret < 0)
1664  goto fail;
1665 
1666  *pdec = &dp->dec;
1667 
1668  return dp->sch_idx;
1669 fail:
1670  dec_free((Decoder**)&dp);
1671  return ret;
1672 }
1673 
1674 int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch)
1675 {
1676  DecoderPriv *dp;
1677 
1678  OutputFile *of;
1679  OutputStream *ost;
1680  int of_index, ost_index;
1681  char *p;
1682 
1683  unsigned enc_idx;
1684  int ret;
1685 
1686  ret = dec_alloc(&dp, sch, 0);
1687  if (ret < 0)
1688  return ret;
1689 
1690  dp->index = nb_decoders;
1691 
1693  if (ret < 0) {
1694  dec_free((Decoder **)&dp);
1695  return ret;
1696  }
1697 
1698  decoders[nb_decoders - 1] = (Decoder *)dp;
1699 
1700  of_index = strtol(arg, &p, 0);
1701  if (of_index < 0 || of_index >= nb_output_files) {
1702  av_log(dp, AV_LOG_ERROR, "Invalid output file index '%d' in %s\n", of_index, arg);
1703  return AVERROR(EINVAL);
1704  }
1705  of = output_files[of_index];
1706 
1707  ost_index = strtol(p + 1, NULL, 0);
1708  if (ost_index < 0 || ost_index >= of->nb_streams) {
1709  av_log(dp, AV_LOG_ERROR, "Invalid output stream index '%d' in %s\n", ost_index, arg);
1710  return AVERROR(EINVAL);
1711  }
1712  ost = of->streams[ost_index];
1713 
1714  if (!ost->enc) {
1715  av_log(dp, AV_LOG_ERROR, "Output stream %s has no encoder\n", arg);
1716  return AVERROR(EINVAL);
1717  }
1718 
1719  dp->dec.type = ost->type;
1720 
1721  ret = enc_loopback(ost->enc);
1722  if (ret < 0)
1723  return ret;
1724  enc_idx = ret;
1725 
1726  ret = sch_connect(sch, SCH_ENC(enc_idx), SCH_DEC_IN(dp->sch_idx));
1727  if (ret < 0)
1728  return ret;
1729 
1730  ret = av_dict_copy(&dp->standalone_init.opts, o->g->codec_opts, 0);
1731  if (ret < 0)
1732  return ret;
1733 
1735 
1736  if (o->codec_names.nb_opt) {
1737  const char *name = o->codec_names.opt[o->codec_names.nb_opt - 1].u.str;
1739  if (!dp->standalone_init.codec) {
1740  av_log(dp, AV_LOG_ERROR, "No such decoder: %s\n", name);
1742  }
1743  }
1744 
1745  return 0;
1746 }
1747 
1749  const ViewSpecifier *vs, SchedulerNode *src)
1750 {
1751  DecoderPriv *dp = dp_from_dec(d);
1752  char name[16];
1753 
1754  snprintf(name, sizeof(name), "dec%d", dp->index);
1755  opts->name = av_strdup(name);
1756  if (!opts->name)
1757  return AVERROR(ENOMEM);
1758 
1759  return dec_request_view(d, vs, src);
1760 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
DecoderPriv::last_frame_tb
AVRational last_frame_tb
Definition: ffmpeg_dec.c:67
AVSubtitle
Definition: avcodec.h:2238
Decoder::subtitle_header
const uint8_t * subtitle_header
Definition: ffmpeg.h:425
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:674
AVCodec
AVCodec.
Definition: codec.h:187
copy_av_subtitle
static int copy_av_subtitle(AVSubtitle *dst, const AVSubtitle *src)
Definition: ffmpeg_dec.c:454
stdc_trailing_zeros
#define stdc_trailing_zeros(value)
Definition: stdbit.h:220
fix_sub_duration_heartbeat
static int fix_sub_duration_heartbeat(DecoderPriv *dp, int64_t signal_pts)
Definition: ffmpeg_dec.c:617
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:668
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:47
dec_class
static const AVClass dec_class
Definition: ffmpeg_dec.c:154
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:793
DecoderPriv::views_requested
struct DecoderPriv::@5 * views_requested
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
FrameData
Definition: ffmpeg.h:655
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: cmdutils.c:1529
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
DecoderPriv::last_frame_duration_est
int64_t last_frame_duration_est
Definition: ffmpeg_dec.c:66
DecoderOpts
Definition: ffmpeg.h:398
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:963
audio_samplerate_update
static AVRational audio_samplerate_update(DecoderPriv *dp, const AVFrame *frame)
Definition: ffmpeg_dec.c:203
DECODER_FLAG_SEND_END_TS
@ DECODER_FLAG_SEND_END_TS
Definition: ffmpeg.h:393
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
LATENCY_PROBE_DEC_POST
@ LATENCY_PROBE_DEC_POST
Definition: ffmpeg.h:101
DecoderPriv::last_frame_pts
int64_t last_frame_pts
Definition: ffmpeg_dec.c:65
dec_thread_uninit
static void dec_thread_uninit(DecThreadContext *dt)
Definition: ffmpeg_dec.c:885
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
dec_alloc
static int dec_alloc(DecoderPriv **pdec, Scheduler *sch, int send_end_ts)
Definition: ffmpeg_dec.c:163
int64_t
long long int64_t
Definition: coverity.c:34
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
AVSubtitleRect
Definition: avcodec.h:2211
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2242
hw_device_match_by_codec
static HWDevice * hw_device_match_by_codec(const AVCodec *codec)
Definition: ffmpeg_dec.c:1377
DecThreadContext::pkt
AVPacket * pkt
Definition: ffmpeg_dec.c:115
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:537
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:679
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
cleanup
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:130
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:501
AVFrame::width
int width
Definition: frame.h:461
DECODER_FLAG_FRAMERATE_FORCED
@ DECODER_FLAG_FRAMERATE_FORCED
Definition: ffmpeg.h:389
DecoderOpts::par
const AVCodecParameters * par
Definition: ffmpeg.h:405
dec_item_name
static const char * dec_item_name(void *obj)
Definition: ffmpeg_dec.c:147
dec_thread_init
static int dec_thread_init(DecThreadContext *dt)
Definition: ffmpeg_dec.c:893
DecoderPriv::hwaccel_device_type
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg_dec.c:59
DecoderPriv::sub_prev
AVFrame * sub_prev[2]
Definition: ffmpeg_dec.c:72
DecoderPriv::hwaccel_output_format
enum AVPixelFormat hwaccel_output_format
Definition: ffmpeg_dec.c:60
data
const char data[16]
Definition: mxf.c:149
DecoderOpts::hwaccel_id
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:408
DecoderPriv::pkt
AVPacket * pkt
Definition: ffmpeg_dec.c:46
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1902
AVSubtitleRect::linesize
int linesize[4]
Definition: avcodec.h:2223
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
DecoderPriv::index
int index
Definition: ffmpeg_dec.c:79
DecoderPriv::sub_heartbeat
AVFrame * sub_heartbeat
Definition: ffmpeg_dec.c:73
DecoderPriv::multiview_user_config
int multiview_user_config
Definition: ffmpeg_dec.c:85
ViewSpecifier
Definition: ffmpeg.h:128
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
HWDevice
Definition: ffmpeg.h:109
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
VIEW_SPECIFIER_TYPE_ALL
@ VIEW_SPECIFIER_TYPE_ALL
Definition: ffmpeg.h:125
DECODER_FLAG_BITEXACT
@ DECODER_FLAG_BITEXACT
Definition: ffmpeg.h:395
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:602
DecoderPriv::hwaccel_id
enum HWAccelID hwaccel_id
Definition: ffmpeg_dec.c:58
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
AV_STEREO3D_VIEW_UNSPEC
@ AV_STEREO3D_VIEW_UNSPEC
Content is unspecified.
Definition: stereo3d.h:168
tf_sess_config.config
config
Definition: tf_sess_config.py:33
enc_loopback
int enc_loopback(Encoder *enc)
Definition: ffmpeg_enc.c:932
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
dec_free
void dec_free(Decoder **pdec)
Definition: ffmpeg_dec.c:118
DEFAULT_FRAME_THREAD_QUEUE_SIZE
#define DEFAULT_FRAME_THREAD_QUEUE_SIZE
Default size of a frame thread queue.
Definition: ffmpeg_sched.h:260
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:1078
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
FrameData::frame_num
uint64_t frame_num
Definition: ffmpeg.h:662
OutputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:646
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
DecoderPriv::dec_ctx
AVCodecContext * dec_ctx
Definition: ffmpeg_dec.c:42
DecoderPriv::apply_cropping
int apply_cropping
Definition: ffmpeg_dec.c:55
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
DecoderOpts::hwaccel_output_format
enum AVPixelFormat hwaccel_output_format
Definition: ffmpeg.h:411
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:70
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:374
FRAME_OPAQUE_SUB_HEARTBEAT
@ FRAME_OPAQUE_SUB_HEARTBEAT
Definition: ffmpeg.h:88
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
DecoderPriv
Definition: ffmpeg_dec.c:39
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:144
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
Decoder::frames_decoded
uint64_t frames_decoded
Definition: ffmpeg.h:429
fail
#define fail()
Definition: checkasm.h:200
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
get_format
static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
Definition: ffmpeg_dec.c:1315
AVSubtitleRect::x
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2212
VIEW_SPECIFIER_TYPE_POS
@ VIEW_SPECIFIER_TYPE_POS
Definition: ffmpeg.h:123
DecoderPriv::log_parent
void * log_parent
Definition: ffmpeg_dec.c:80
DecoderOpts::log_parent
void * log_parent
Definition: ffmpeg.h:402
DecoderPriv::out_idx
unsigned out_idx
Definition: ffmpeg_dec.c:89
DecoderPriv::dec
Decoder dec
Definition: ffmpeg_dec.c:40
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
update_benchmark
void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:527
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:790
SCH_ENC
#define SCH_ENC(encoder)
Definition: ffmpeg_sched.h:123
multiview_setup
static int multiview_setup(DecoderPriv *dp, AVCodecContext *dec_ctx)
Definition: ffmpeg_dec.c:1089
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
OptionsContext
Definition: ffmpeg.h:143
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
FrameData::tb
AVRational tb
Definition: ffmpeg.h:665
codec.h
AVRational::num
int num
Numerator.
Definition: rational.h:59
DecoderPriv::parent_name
char * parent_name
Definition: ffmpeg_dec.c:82
Decoder::samples_decoded
uint64_t samples_decoded
Definition: ffmpeg.h:430
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2235
av_stereo3d_view_name
const char * av_stereo3d_view_name(unsigned int view)
Provide a human-readable name of a given stereo3d view.
Definition: stereo3d.c:113
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
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:1232
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:983
avassert.h
DecThreadContext
Definition: ffmpeg_dec.c:113
DecoderPriv::log_name
char log_name[32]
Definition: ffmpeg_dec.c:81
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
dec_create
int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch)
Create a standalone decoder.
Definition: ffmpeg_dec.c:1674
DecoderPriv::frame
AVFrame * frame
Definition: ffmpeg_dec.c:44
hwaccel_retrieve_data
static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
Definition: ffmpeg_dec.c:343
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:343
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:181
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
DecThreadContext::frame
AVFrame * frame
Definition: ffmpeg_dec.c:114
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
HWACCEL_GENERIC
@ HWACCEL_GENERIC
Definition: ffmpeg.h:84
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
stereo3d.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
subtitle_wrap_frame
static int subtitle_wrap_frame(AVFrame *frame, AVSubtitle *subtitle, int copy)
Definition: ffmpeg_dec.c:541
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVSubtitleRect::y
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:2213
VIEW_SPECIFIER_TYPE_NONE
@ VIEW_SPECIFIER_TYPE_NONE
Definition: ffmpeg.h:117
InputFilter
Definition: ffmpeg.h:349
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition: avcodec.c:713
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1585
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
sch_dec_send
int sch_dec_send(Scheduler *sch, unsigned dec_idx, unsigned out_idx, AVFrame *frame)
Called by decoder tasks to send a decoded frame downstream.
Definition: ffmpeg_sched.c:2241
FrameData::dec
struct FrameData::@4 dec
av_opt_get_array_size
int av_opt_get_array_size(void *obj, const char *name, int search_flags, unsigned int *out_val)
For an array-type option, get the number of elements in the array.
Definition: opt.c:2177
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
max_error_rate
float max_error_rate
Definition: ffmpeg_opt.c:75
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2244
DecoderOpts::hwaccel_device
char * hwaccel_device
Definition: ffmpeg.h:410
av_opt_set_array
int av_opt_set_array(void *obj, const char *name, int search_flags, unsigned int start_elem, unsigned int nb_elems, enum AVOptionType val_type, const void *val)
Add, replace, or remove elements for an array option.
Definition: opt.c:2283
DecoderPriv::last_filter_in_rescale_delta
int64_t last_filter_in_rescale_delta
Definition: ffmpeg_dec.c:68
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:112
stdc_count_ones
#define stdc_count_ones(value)
Definition: stdbit.h:455
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
AVSubtitleRect::text
char * text
0 terminated plain UTF-8 text
Definition: avcodec.h:2228
SCH_DEC_IN
#define SCH_DEC_IN(decoder)
Definition: ffmpeg_sched.h:117
av_rescale_delta
int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb)
Rescale a timestamp while preserving known durations.
Definition: mathematics.c:168
get_buffer
static int get_buffer(AVCodecContext *dec_ctx, AVFrame *frame, int flags)
Definition: ffmpeg_dec.c:1357
arg
const char * arg
Definition: jacosubdec.c:67
video_frame_process
static int video_frame_process(DecoderPriv *dp, AVFrame *frame, unsigned *outputs_mask)
Definition: ffmpeg_dec.c:385
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
if
if(ret)
Definition: filter_design.txt:179
opts
AVDictionary * opts
Definition: movenc.c:51
audio_ts_process
static void audio_ts_process(DecoderPriv *dp, AVFrame *frame)
Definition: ffmpeg_dec.c:246
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVSubtitleRect::w
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:2214
dec_request_view
int dec_request_view(Decoder *d, const ViewSpecifier *vs, SchedulerNode *src)
Definition: ffmpeg_dec.c:1026
hw_device_setup_for_decode
static int hw_device_setup_for_decode(DecoderPriv *dp, const AVCodec *codec, const char *hwaccel_device)
Definition: ffmpeg_dec.c:1393
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:1040
Decoder::decode_errors
uint64_t decode_errors
Definition: ffmpeg.h:431
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:725
AVCodecContext::apply_cropping
int apply_cropping
Video decoding only.
Definition: avcodec.h:1972
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
DecoderPriv::framerate_in
AVRational framerate_in
Definition: ffmpeg_dec.c:51
dec_open
static int dec_open(DecoderPriv *dp, AVDictionary **dec_opts, const DecoderOpts *o, AVFrame *param_out)
Definition: ffmpeg_dec.c:1522
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
Decoder
Definition: ffmpeg.h:420
dec_thread_set_name
static void dec_thread_set_name(const DecoderPriv *dp)
Definition: ffmpeg_dec.c:870
hw_device_init_from_type
int hw_device_init_from_type(enum AVHWDeviceType type, const char *device, HWDevice **dev_out)
Definition: ffmpeg_hw.c:243
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
transcode_subtitles
static int transcode_subtitles(DecoderPriv *dp, const AVPacket *pkt, AVFrame *frame)
Definition: ffmpeg_dec.c:639
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AVCodecContext::subtitle_header_size
int subtitle_header_size
Header containing style information for text subtitles.
Definition: avcodec.h:1901
AVSubtitleRect::data
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2222
sch_add_dec
int sch_add_dec(Scheduler *sch, SchThreadFunc func, void *ctx, int send_end_ts)
Add a decoder to the scheduler.
Definition: ffmpeg_sched.c:748
ViewSpecifier::val
unsigned val
Definition: ffmpeg.h:130
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:672
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:143
time.h
av_opt_get_array
int av_opt_get_array(void *obj, const char *name, int search_flags, unsigned int start_elem, unsigned int nb_elems, enum AVOptionType out_type, void *out_val)
For an array-type option, retrieve the values of one or more array elements.
Definition: opt.c:2195
AV_OPT_TYPE_UINT
@ AV_OPT_TYPE_UINT
Underlying C type is unsigned int.
Definition: opt.h:335
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:313
InputFilterOptions
Definition: ffmpeg.h:266
DecoderPriv::hwaccel_pix_fmt
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg_dec.c:57
DECODER_FLAG_FIX_SUB_DURATION
@ DECODER_FLAG_FIX_SUB_DURATION
Definition: ffmpeg.h:384
DecoderPriv::last_frame_sample_rate
int last_frame_sample_rate
Definition: ffmpeg_dec.c:69
DecoderPriv::frame_tmp_ref
AVFrame * frame_tmp_ref
Definition: ffmpeg_dec.c:45
DecoderPriv::out_mask
uintptr_t out_mask
Definition: ffmpeg_dec.c:97
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
OutputFile::streams
OutputStream ** streams
Definition: ffmpeg.h:645
error.h
Scheduler
Definition: ffmpeg_sched.c:275
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1012
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
AVPacket::size
int size
Definition: packet.h:540
DecoderPriv::sch
Scheduler * sch
Definition: ffmpeg_dec.c:75
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
AVCodecContext::extra_hw_frames
int extra_hw_frames
Video decoding only.
Definition: avcodec.h:1530
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:400
DecoderPriv::standalone_init
struct DecoderPriv::@7 standalone_init
dec_init
int dec_init(Decoder **pdec, Scheduler *sch, AVDictionary **dec_opts, const DecoderOpts *o, AVFrame *param_out)
Definition: ffmpeg_dec.c:1647
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
output_files
OutputFile ** output_files
Definition: ffmpeg.c:107
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:122
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:588
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:557
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:516
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
HWDevice::device_ref
AVBufferRef * device_ref
Definition: ffmpeg.h:112
hw_device_get_by_type
HWDevice * hw_device_get_by_type(enum AVHWDeviceType type)
Definition: ffmpeg_hw.c:28
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:476
frame_data
FrameData * frame_data(AVFrame *frame)
Get our axiliary frame data attached to the frame, allocating it if needed.
Definition: ffmpeg.c:453
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2241
AVSubtitleRect::type
enum AVSubtitleType type
Definition: avcodec.h:2226
LATENCY_PROBE_DEC_PRE
@ LATENCY_PROBE_DEC_PRE
Definition: ffmpeg.h:100
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
FrameData::pts
int64_t pts
Definition: ffmpeg.h:664
DecoderPriv::codec
const AVCodec * codec
Definition: ffmpeg_dec.c:103
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:180
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
multiview_check_manual
static void multiview_check_manual(DecoderPriv *dp, const AVDictionary *dec_opts)
Definition: ffmpeg_dec.c:1306
decoders
Decoder ** decoders
Definition: ffmpeg.c:113
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
nb_decoders
int nb_decoders
Definition: ffmpeg.c:114
SUBTITLE_BITMAP
@ SUBTITLE_BITMAP
A bitmap, pict will be set.
Definition: avcodec.h:2194
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
HWACCEL_AUTO
@ HWACCEL_AUTO
Definition: ffmpeg.h:83
AVSubtitleRect::flags
int flags
Definition: avcodec.h:2225
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:250
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:728
video_duration_estimate
static int64_t video_duration_estimate(const DecoderPriv *dp, const AVFrame *frame)
Definition: ffmpeg_dec.c:283
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
process_subtitle
static int process_subtitle(DecoderPriv *dp, AVFrame *frame)
Definition: ffmpeg_dec.c:574
FrameData::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffmpeg.h:670
AV_FRAME_FLAG_CORRUPT
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
Definition: frame.h:636
AVSubtitleRect::nb_colors
int nb_colors
number of colors in pict, undefined when pict is not set
Definition: avcodec.h:2216
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:152
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1962
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
DecoderPriv::view_map
struct DecoderPriv::@6 * view_map
packet_decode
static int packet_decode(DecoderPriv *dp, AVPacket *pkt, AVFrame *frame)
Definition: ffmpeg_dec.c:697
DecoderOpts::time_base
AVRational time_base
Definition: ffmpeg.h:413
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
DecoderPriv::nb_views_requested
int nb_views_requested
Definition: ffmpeg_dec.c:91
SCH_DEC_OUT
#define SCH_DEC_OUT(decoder, out_idx)
Definition: ffmpeg_sched.h:120
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:71
FRAME_OPAQUE_EOF
@ FRAME_OPAQUE_EOF
Definition: ffmpeg.h:89
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:649
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
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:1507
SchedulerNode
Definition: ffmpeg_sched.h:103
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
nb_output_files
int nb_output_files
Definition: ffmpeg.c:108
sch_connect
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
Definition: ffmpeg_sched.c:927
DecoderPriv::nb_view_map
int nb_view_map
Definition: ffmpeg_dec.c:99
avcodec.h
DecoderPriv::vs
ViewSpecifier vs
Definition: ffmpeg_dec.c:88
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2041
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:203
AVSubtitleRect::h
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:2215
pixfmt.h
sch_dec_receive
int sch_dec_receive(Scheduler *sch, unsigned dec_idx, AVPacket *pkt)
Called by decoder tasks to receive a packet for decoding.
Definition: ffmpeg_sched.c:2165
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:374
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
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
VIEW_SPECIFIER_TYPE_IDX
@ VIEW_SPECIFIER_TYPE_IDX
Definition: ffmpeg.h:119
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:95
DecoderPriv::flags
int flags
Definition: ffmpeg_dec.c:54
AVCodecContext::opaque
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:493
DECODER_FLAG_TOP_FIELD_FIRST
@ DECODER_FLAG_TOP_FIELD_FIRST
Definition: ffmpeg.h:391
pos
unsigned int pos
Definition: spdifenc.c:414
HWAccelID
HWAccelID
Definition: ffmpeg.h:81
dict.h
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:496
av_hwframe_transfer_data
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:433
U
#define U(x)
Definition: vpx_arith.h:37
DecoderPriv::sar_override
AVRational sar_override
Definition: ffmpeg_dec.c:49
AV_HWDEVICE_TYPE_QSV
@ AV_HWDEVICE_TYPE_QSV
Definition: hwcontext.h:33
dec_filter_add
int dec_filter_add(Decoder *d, InputFilter *ifilter, InputFilterOptions *opts, const ViewSpecifier *vs, SchedulerNode *src)
Definition: ffmpeg_dec.c:1748
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVFrame::height
int height
Definition: frame.h:461
DecoderPriv::opts
AVDictionary * opts
Definition: ffmpeg_dec.c:102
PKT_OPAQUE_SUB_HEARTBEAT
@ PKT_OPAQUE_SUB_HEARTBEAT
Definition: ffmpeg.h:94
HWDevice::name
const char * name
Definition: ffmpeg.h:110
dp_from_dec
static DecoderPriv * dp_from_dec(Decoder *d)
Definition: ffmpeg_dec.c:107
AVRational::den
int den
Denominator.
Definition: rational.h:60
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:170
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
output_format
static char * output_format
Definition: ffprobe.c:150
Decoder::subtitle_header_size
int subtitle_header_size
Definition: ffmpeg.h:426
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:532
HWACCEL_NONE
@ HWACCEL_NONE
Definition: ffmpeg.h:82
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:833
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:447
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:54
DecoderOpts::flags
int flags
Definition: ffmpeg.h:399
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ViewSpecifier::type
enum ViewSpecifierType type
Definition: ffmpeg.h:129
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
SpecifierOpt::u
union SpecifierOpt::@0 u
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
DECODER_FLAG_TS_UNRELIABLE
@ DECODER_FLAG_TS_UNRELIABLE
Definition: ffmpeg.h:386
DecoderOpts::codec
const AVCodec * codec
Definition: ffmpeg.h:404
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
decoder_thread
static int decoder_thread(void *arg)
Definition: ffmpeg_dec.c:912
sch_add_dec_output
int sch_add_dec_output(Scheduler *sch, unsigned dec_idx)
Add another output to decoder (e.g.
Definition: ffmpeg_sched.c:727
FFMPEG_ERROR_RATE_EXCEEDED
#define FFMPEG_ERROR_RATE_EXCEEDED
Definition: ffmpeg.h:63
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
VIEW_SPECIFIER_TYPE_ID
@ VIEW_SPECIFIER_TYPE_ID
Definition: ffmpeg.h:121
Decoder::class
const AVClass * class
Definition: ffmpeg.h:421
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
HWDevice::type
enum AVHWDeviceType type
Definition: ffmpeg.h:111
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
Decoder::type
enum AVMediaType type
Definition: ffmpeg.h:423
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:465
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
timestamp.h
OutputStream
Definition: mux.c:53
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
DecoderOpts::framerate
AVRational framerate
Definition: ffmpeg.h:417
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
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:1015
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVCodecHWConfig
Definition: codec.h:345
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
subtitle_free
static void subtitle_free(void *opaque, uint8_t *data)
Definition: ffmpeg_dec.c:534
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3759
DecoderPriv::sch_idx
unsigned sch_idx
Definition: ffmpeg_dec.c:76
avstring.h
DecoderPriv::id
unsigned id
Definition: ffmpeg_dec.c:96
hw_device_get_by_name
HWDevice * hw_device_get_by_name(const char *name)
Definition: ffmpeg_hw.c:42
snprintf
#define snprintf
Definition: snprintf.h:34
PKT_OPAQUE_FIX_SUB_DURATION
@ PKT_OPAQUE_FIX_SUB_DURATION
Definition: ffmpeg.h:95
DecoderOpts::hwaccel_device_type
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg.h:409
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:648
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
src
#define src
Definition: vp8dsp.c:248
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:583
AVPacket::side_data_elems
int side_data_elems
Definition: packet.h:551
stdbit.h
dec_standalone_open
static int dec_standalone_open(DecoderPriv *dp, const AVPacket *pkt)
Definition: ffmpeg_dec.c:835
OutputFile
Definition: ffmpeg.h:638
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216
DecoderOpts::name
char * name
Definition: ffmpeg.h:401