FFmpeg
img2dec.c
Go to the documentation of this file.
1 /*
2  * Image format
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  * Copyright (c) 2004 Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "config_components.h"
24 
25 #define _DEFAULT_SOURCE
26 #define _BSD_SOURCE
27 #include <sys/stat.h>
28 #include "libavutil/avstring.h"
29 #include "libavutil/log.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavcodec/gif.h"
35 #include "avformat.h"
36 #include "avio_internal.h"
37 #include "demux.h"
38 #include "internal.h"
39 #include "img2.h"
40 #include "os_support.h"
42 #include "libavcodec/mjpeg.h"
43 #include "libavcodec/vbn.h"
44 #include "libavcodec/xwd.h"
45 #include "subtitles.h"
46 
47 #if HAVE_GLOB
48 /* Locally define as 0 (bitwise-OR no-op) any missing glob options that
49  are non-posix glibc/bsd extensions. */
50 #ifndef GLOB_NOMAGIC
51 #define GLOB_NOMAGIC 0
52 #endif
53 #ifndef GLOB_BRACE
54 #define GLOB_BRACE 0
55 #endif
56 
57 #endif /* HAVE_GLOB */
58 
59 static const int sizes[][2] = {
60  { 640, 480 },
61  { 720, 480 },
62  { 720, 576 },
63  { 352, 288 },
64  { 352, 240 },
65  { 160, 128 },
66  { 512, 384 },
67  { 640, 352 },
68  { 640, 240 },
69 };
70 
71 static int infer_size(int *width_ptr, int *height_ptr, int size)
72 {
73  int i;
74 
75  for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
76  if ((sizes[i][0] * sizes[i][1]) == size) {
77  *width_ptr = sizes[i][0];
78  *height_ptr = sizes[i][1];
79  return 0;
80  }
81  }
82 
83  return -1;
84 }
85 
86 static int is_glob(const char *path)
87 {
88 #if HAVE_GLOB
89  size_t span = 0;
90  const char *p = path;
91 
92  while (p = strchr(p, '%')) {
93  if (*(++p) == '%') {
94  ++p;
95  continue;
96  }
97  if (span = strspn(p, "*?[]{}"))
98  break;
99  }
100  /* Did we hit a glob char or get to the end? */
101  return span != 0;
102 #else
103  return 0;
104 #endif
105 }
106 
107 /**
108  * Get index range of image files matched by path.
109  *
110  * @param pfirst_index pointer to index updated with the first number in the range
111  * @param plast_index pointer to index updated with the last number in the range
112  * @param path path which has to be matched by the image files in the range
113  * @param start_index minimum accepted value for the first index in the range
114  * @return -1 if no image file could be found
115  */
116 static int find_image_range(AVIOContext *pb, int *pfirst_index, int *plast_index,
117  const char *path, int start_index, int start_index_range)
118 {
119  char buf[1024];
120  int range, last_index, range1, first_index;
121 
122  /* find the first image */
123  for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
124  if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
125  *pfirst_index =
126  *plast_index = 1;
127  if (pb || avio_check(buf, AVIO_FLAG_READ) > 0)
128  return 0;
129  return -1;
130  }
131  if (avio_check(buf, AVIO_FLAG_READ) > 0)
132  break;
133  }
134  if (first_index == start_index + start_index_range)
135  goto fail;
136 
137  /* find the last image */
138  last_index = first_index;
139  for (;;) {
140  range = 0;
141  for (;;) {
142  if (!range)
143  range1 = 1;
144  else
145  range1 = 2 * range;
146  if (av_get_frame_filename(buf, sizeof(buf), path,
147  last_index + range1) < 0)
148  goto fail;
149  if (avio_check(buf, AVIO_FLAG_READ) <= 0)
150  break;
151  range = range1;
152  /* just in case... */
153  if (range >= (1 << 30))
154  goto fail;
155  }
156  /* we are sure than image last_index + range exists */
157  if (!range)
158  break;
159  last_index += range;
160  }
161  *pfirst_index = first_index;
162  *plast_index = last_index;
163  return 0;
164 
165 fail:
166  return -1;
167 }
168 
169 static int img_read_probe(const AVProbeData *p)
170 {
171  if (p->filename && ff_guess_image2_codec(p->filename)) {
173  return AVPROBE_SCORE_MAX;
174  else if (is_glob(p->filename))
175  return AVPROBE_SCORE_MAX;
176  else if (p->filename[strcspn(p->filename, "*?{")]) // probably PT_GLOB
177  return AVPROBE_SCORE_EXTENSION + 2; // score chosen to be a tad above the image pipes
178  else if (p->buf_size == 0)
179  return 0;
180  else if (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif"))
181  return 5;
182  else
184  }
185  return 0;
186 }
187 
189 {
190  VideoDemuxData *s = s1->priv_data;
191  int first_index = 1, last_index = 1;
192  AVStream *st;
194 
195  s1->ctx_flags |= AVFMTCTX_NOHEADER;
196 
197  st = avformat_new_stream(s1, NULL);
198  if (!st) {
199  return AVERROR(ENOMEM);
200  }
201 
202  if (s->pixel_format &&
203  (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) {
204  av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n",
205  s->pixel_format);
206  return AVERROR(EINVAL);
207  }
208 
209  av_strlcpy(s->path, s1->url, sizeof(s->path));
210  s->img_number = 0;
211  s->img_count = 0;
212 
213  /* find format */
214  if (s1->iformat->flags & AVFMT_NOFILE)
215  s->is_pipe = 0;
216  else {
217  s->is_pipe = 1;
219  }
220 
221  if (s->ts_from_file == 2) {
222 #if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
223  av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n");
224  return AVERROR(ENOSYS);
225 #endif
226  avpriv_set_pts_info(st, 64, 1, 1000000000);
227  } else if (s->ts_from_file)
228  avpriv_set_pts_info(st, 64, 1, 1);
229  else {
230  avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
231  st->avg_frame_rate = st->r_frame_rate = s->framerate;
232  }
233 
234  if (s->width && s->height) {
235  st->codecpar->width = s->width;
236  st->codecpar->height = s->height;
237  }
238 
239  if (!s->is_pipe) {
240  if (s->pattern_type == PT_DEFAULT) {
241  if (s1->pb) {
242  s->pattern_type = PT_NONE;
243  } else
244  s->pattern_type = PT_GLOB_SEQUENCE;
245  }
246 
247  if (s->pattern_type == PT_GLOB_SEQUENCE) {
248  s->use_glob = is_glob(s->path);
249  if (s->use_glob) {
250 #if HAVE_GLOB
251  char *p = s->path, *q, *dup;
252  int gerr;
253 #endif
254 
255  av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
256  "use pattern_type 'glob' instead\n");
257 #if HAVE_GLOB
258  dup = q = av_strdup(p);
259  while (*q) {
260  /* Do we have room for the next char and a \ insertion? */
261  if ((p - s->path) >= (sizeof(s->path) - 2))
262  break;
263  if (*q == '%' && strspn(q + 1, "%*?[]{}"))
264  ++q;
265  else if (strspn(q, "\\*?[]{}"))
266  *p++ = '\\';
267  *p++ = *q++;
268  }
269  *p = 0;
270  av_free(dup);
271 
272  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
273  if (gerr != 0) {
274  return AVERROR(ENOENT);
275  }
276  first_index = 0;
277  last_index = s->globstate.gl_pathc - 1;
278 #endif
279  }
280  }
281  if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
282  if (find_image_range(s1->pb, &first_index, &last_index, s->path,
283  s->start_number, s->start_number_range) < 0) {
285  "Could find no file with path '%s' and index in the range %d-%d\n",
286  s->path, s->start_number, s->start_number + s->start_number_range - 1);
287  return AVERROR(ENOENT);
288  }
289  } else if (s->pattern_type == PT_GLOB) {
290 #if HAVE_GLOB
291  int gerr;
292  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
293  if (gerr != 0) {
294  return AVERROR(ENOENT);
295  }
296  first_index = 0;
297  last_index = s->globstate.gl_pathc - 1;
298  s->use_glob = 1;
299 #else
301  "Pattern type 'glob' was selected but globbing "
302  "is not supported by this libavformat build\n");
303  return AVERROR(ENOSYS);
304 #endif
305  } else if (s->pattern_type != PT_GLOB_SEQUENCE && s->pattern_type != PT_NONE) {
307  "Unknown value '%d' for pattern_type option\n", s->pattern_type);
308  return AVERROR(EINVAL);
309  }
310  s->img_first = first_index;
311  s->img_last = last_index;
312  s->img_number = first_index;
313  /* compute duration */
314  if (!s->ts_from_file) {
315  st->start_time = 0;
316  st->duration = last_index - first_index + 1;
317  }
318  }
319 
320  if (s1->video_codec_id) {
322  st->codecpar->codec_id = s1->video_codec_id;
323  } else if (s1->audio_codec_id) {
325  st->codecpar->codec_id = s1->audio_codec_id;
326  } else if (ffifmt(s1->iformat)->raw_codec_id) {
328  st->codecpar->codec_id = ffifmt(s1->iformat)->raw_codec_id;
329  } else {
330  const char *str = strrchr(s->path, '.');
331  s->split_planes = str && !av_strcasecmp(str + 1, "y");
333  if (s1->pb) {
334  int probe_buffer_size = 2048;
335  uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE);
336  const AVInputFormat *fmt = NULL;
337  void *fmt_iter = NULL;
338  AVProbeData pd = { 0 };
339 
340  if (!probe_buffer)
341  return AVERROR(ENOMEM);
342 
343  probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size);
344  if (probe_buffer_size < 0) {
345  av_free(probe_buffer);
346  return probe_buffer_size;
347  }
348  memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE);
349 
350  pd.buf = probe_buffer;
351  pd.buf_size = probe_buffer_size;
352  pd.filename = s1->url;
353 
354  while ((fmt = av_demuxer_iterate(&fmt_iter))) {
355  const FFInputFormat *fmt2 = ffifmt(fmt);
356  if (fmt2->read_header != ff_img_read_header ||
357  !fmt2->read_probe ||
358  (fmt->flags & AVFMT_NOFILE) ||
359  !fmt2->raw_codec_id)
360  continue;
361  if (fmt2->read_probe(&pd) > 0) {
362  st->codecpar->codec_id = fmt2->raw_codec_id;
363  break;
364  }
365  }
366  if (s1->flags & AVFMT_FLAG_CUSTOM_IO) {
367  avio_seek(s1->pb, 0, SEEK_SET);
368  av_freep(&probe_buffer);
369  } else
370  ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size);
371  }
372  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
374  if (st->codecpar->codec_id == AV_CODEC_ID_LJPEG)
376  if (st->codecpar->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
378  }
379  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
381  st->codecpar->format = pix_fmt;
382 
383  return 0;
384 }
385 
386 /**
387  * Add this frame's source path and basename to packet's sidedata
388  * as a dictionary, so it can be used by filters like 'drawtext'.
389  */
390 static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt) {
391  AVDictionary *d = NULL;
392  char *packed_metadata = NULL;
393  size_t metadata_len;
394  int ret;
395 
396  av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);
397  av_dict_set(&d, "lavf.image2dec.source_basename", av_basename(filename), 0);
398 
399  packed_metadata = av_packet_pack_dictionary(d, &metadata_len);
400  av_dict_free(&d);
401  if (!packed_metadata)
402  return AVERROR(ENOMEM);
404  packed_metadata, metadata_len);
405  if (ret < 0) {
406  av_freep(&packed_metadata);
407  return ret;
408  }
409  return 0;
410 }
411 
413 {
414  VideoDemuxData *s = s1->priv_data;
415  char filename_bytes[1024];
416  char *filename = filename_bytes;
417  int i, res;
418  int size[3] = { 0 }, ret[3] = { 0 };
419  AVIOContext *f[3] = { NULL };
420  AVCodecParameters *par = s1->streams[0]->codecpar;
421 
422  if (!s->is_pipe) {
423  /* loop over input */
424  if (s->loop && s->img_number > s->img_last) {
425  s->img_number = s->img_first;
426  }
427  if (s->img_number > s->img_last)
428  return AVERROR_EOF;
429  if (s->pattern_type == PT_NONE) {
430  av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
431  } else if (s->use_glob) {
432 #if HAVE_GLOB
433  filename = s->globstate.gl_pathv[s->img_number];
434 #endif
435  } else {
436  if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
437  s->path,
438  s->img_number) < 0 && s->img_number > 1)
439  return AVERROR(EIO);
440  }
441  for (i = 0; i < 3; i++) {
442  if (s1->pb &&
443  !strcmp(filename_bytes, s->path) &&
444  !s->loop &&
445  !s->split_planes) {
446  f[i] = s1->pb;
447  } else if (s1->io_open(s1, &f[i], filename, AVIO_FLAG_READ, NULL) < 0) {
448  if (i >= 1)
449  break;
450  av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
451  filename);
452  return AVERROR(EIO);
453  }
454  size[i] = avio_size(f[i]);
455 
456  if (!s->split_planes)
457  break;
458  filename[strlen(filename) - 1] = 'U' + i;
459  }
460 
461  if (par->codec_id == AV_CODEC_ID_NONE) {
462  AVProbeData pd = { 0 };
463  const FFInputFormat *ifmt;
465  int ret;
466  int score = 0;
467 
469  if (ret < 0)
470  return ret;
471  memset(header + ret, 0, sizeof(header) - ret);
472  avio_skip(f[0], -ret);
473  pd.buf = header;
474  pd.buf_size = ret;
475  pd.filename = filename;
476 
477  ifmt = ffifmt(av_probe_input_format3(&pd, 1, &score));
478  if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
479  par->codec_id = ifmt->raw_codec_id;
480  }
481 
482  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
483  infer_size(&par->width, &par->height, size[0]);
484  } else {
485  f[0] = s1->pb;
486  if (avio_feof(f[0]) && s->loop && s->is_pipe)
487  avio_seek(f[0], 0, SEEK_SET);
488  if (avio_feof(f[0]))
489  return AVERROR_EOF;
490  if (s->frame_size > 0) {
491  size[0] = s->frame_size;
492  } else if (!ffstream(s1->streams[0])->parser) {
493  size[0] = avio_size(s1->pb);
494  } else {
495  size[0] = 4096;
496  }
497  }
498 
499  res = av_new_packet(pkt, size[0] + size[1] + size[2]);
500  if (res < 0) {
501  goto fail;
502  }
503  pkt->stream_index = 0;
505  if (s->ts_from_file) {
506  struct stat img_stat;
507  if (stat(filename, &img_stat)) {
508  res = AVERROR(EIO);
509  goto fail;
510  }
511  pkt->pts = (int64_t)img_stat.st_mtime;
512 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
513  if (s->ts_from_file == 2)
514  pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
515 #endif
516  av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
517  } else if (!s->is_pipe) {
518  pkt->pts = s->pts;
519  }
520 
521  if (s->is_pipe)
522  pkt->pos = avio_tell(f[0]);
523 
524  /*
525  * export_path_metadata must be explicitly enabled via
526  * command line options for path metadata to be exported
527  * as packet side_data.
528  */
529  if (!s->is_pipe && s->export_path_metadata == 1) {
530  res = add_filename_as_pkt_side_data(filename, pkt);
531  if (res < 0)
532  goto fail;
533  }
534 
535  pkt->size = 0;
536  for (i = 0; i < 3; i++) {
537  if (f[i]) {
538  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
539  if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
540  if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
541  pkt->pos = 0;
542  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
543  }
544  }
545  if (!s->is_pipe && f[i] != s1->pb)
546  ff_format_io_close(s1, &f[i]);
547  if (ret[i] > 0)
548  pkt->size += ret[i];
549  }
550  }
551 
552  if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
553  if (ret[0] < 0) {
554  res = ret[0];
555  } else if (ret[1] < 0) {
556  res = ret[1];
557  } else if (ret[2] < 0) {
558  res = ret[2];
559  } else {
560  res = AVERROR_EOF;
561  }
562  goto fail;
563  } else {
564  s->img_count++;
565  s->img_number++;
566  s->pts++;
567  return 0;
568  }
569 
570 fail:
571  if (!s->is_pipe) {
572  for (i = 0; i < 3; i++) {
573  if (f[i] != s1->pb)
574  ff_format_io_close(s1, &f[i]);
575  }
576  }
577  return res;
578 }
579 
580 static int img_read_close(struct AVFormatContext* s1)
581 {
582 #if HAVE_GLOB
583  VideoDemuxData *s = s1->priv_data;
584  if (s->use_glob) {
585  globfree(&s->globstate);
586  }
587 #endif
588  return 0;
589 }
590 
591 static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
592 {
593  VideoDemuxData *s1 = s->priv_data;
594  AVStream *st = s->streams[0];
595 
596  if (s1->ts_from_file) {
597  int index = av_index_search_timestamp(st, timestamp, flags);
598  if(index < 0)
599  return -1;
600  s1->img_number = ffstream(st)->index_entries[index].pos;
601  return 0;
602  }
603 
604  if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
605  return -1;
606  s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
607  s1->pts = timestamp;
608  return 0;
609 }
610 
611 #define OFFSET(x) offsetof(VideoDemuxData, x)
612 #define DEC AV_OPT_FLAG_DECODING_PARAM
613 #define COMMON_OPTIONS \
614  { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
615  { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
616  { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
617  { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
618  { NULL },
619 
620 #if CONFIG_IMAGE2_DEMUXER
621 const AVOption ff_img_options[] = {
622  { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, .unit = "pattern_type"},
623  { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
624  { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
625  { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
626  { "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
627  { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
628  { "start_number_range", "set range for looking at the first sequence number", OFFSET(start_number_range), AV_OPT_TYPE_INT, {.i64 = 5}, 1, INT_MAX, DEC },
629  { "ts_from_file", "set frame timestamp from file's one", OFFSET(ts_from_file), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, .unit = "ts_type" },
630  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, .unit = "ts_type" },
631  { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, .unit = "ts_type" },
632  { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, .unit = "ts_type" },
633  { "export_path_metadata", "enable metadata containing input path information", OFFSET(export_path_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
634  COMMON_OPTIONS
635 };
636 
637 static const AVClass img2_class = {
638  .class_name = "image2 demuxer",
639  .item_name = av_default_item_name,
640  .option = ff_img_options,
641  .version = LIBAVUTIL_VERSION_INT,
642 };
644  .p.name = "image2",
645  .p.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
646  .p.flags = AVFMT_NOFILE,
647  .p.priv_class = &img2_class,
648  .priv_data_size = sizeof(VideoDemuxData),
654 };
655 #endif
656 
657 static const AVOption img2pipe_options[] = {
658  { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
660 };
661 static const AVClass imagepipe_class = {
662  .class_name = "imagepipe demuxer",
663  .item_name = av_default_item_name,
664  .option = img2pipe_options,
665  .version = LIBAVUTIL_VERSION_INT,
666 };
667 
668 #if CONFIG_IMAGE2PIPE_DEMUXER
670  .p.name = "image2pipe",
671  .p.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
672  .p.priv_class = &imagepipe_class,
673  .priv_data_size = sizeof(VideoDemuxData),
676 };
677 #endif
678 
679 static int bmp_probe(const AVProbeData *p)
680 {
681  const uint8_t *b = p->buf;
682  int ihsize;
683 
684  if (AV_RB16(b) != 0x424d)
685  return 0;
686 
687  ihsize = AV_RL32(b+14);
688  if (ihsize < 12 || ihsize > 255)
689  return 0;
690 
691  if (!AV_RN32(b + 6)) {
692  return AVPROBE_SCORE_EXTENSION + 1;
693  }
694  return AVPROBE_SCORE_EXTENSION / 4;
695 }
696 
697 static int cri_probe(const AVProbeData *p)
698 {
699  const uint8_t *b = p->buf;
700 
701  if ( AV_RL32(b) == 1
702  && AV_RL32(b + 4) == 4
703  && AV_RN32(b + 8) == AV_RN32("DVCC"))
704  return AVPROBE_SCORE_MAX - 1;
705  return 0;
706 }
707 
708 static int dds_probe(const AVProbeData *p)
709 {
710  const uint8_t *b = p->buf;
711 
712  if ( AV_RB64(b) == 0x444453207c000000
713  && AV_RL32(b + 8)
714  && AV_RL32(b + 12))
715  return AVPROBE_SCORE_MAX - 1;
716  return 0;
717 }
718 
719 static int dpx_probe(const AVProbeData *p)
720 {
721  const uint8_t *b = p->buf;
722  int w, h;
723  int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
724 
725  if (p->buf_size < 0x304+8)
726  return 0;
727  w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
728  h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
729  if (w <= 0 || h <= 0)
730  return 0;
731 
732  if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
733  return AVPROBE_SCORE_EXTENSION + 1;
734  return 0;
735 }
736 
737 static int exr_probe(const AVProbeData *p)
738 {
739  const uint8_t *b = p->buf;
740 
741  if (AV_RL32(b) == 20000630)
742  return AVPROBE_SCORE_EXTENSION + 1;
743  return 0;
744 }
745 
746 static int j2k_probe(const AVProbeData *p)
747 {
748  const uint8_t *b = p->buf;
749 
750  if (AV_RB64(b) == 0x0000000c6a502020 ||
751  AV_RB32(b) == 0xff4fff51)
752  return AVPROBE_SCORE_EXTENSION + 1;
753  return 0;
754 }
755 
756 static int jpeg_probe(const AVProbeData *p)
757 {
758  const uint8_t *b = p->buf;
759  int i, state = SOI, got_header = 0;
760 
761  if (AV_RB16(b) != 0xFFD8 ||
762  AV_RB32(b) == 0xFFD8FFF7)
763  return 0;
764 
765  b += 2;
766  for (i = 0; i < p->buf_size - 3; i++) {
767  int c;
768  if (b[i] != 0xFF)
769  continue;
770  c = b[i + 1];
771  switch (c) {
772  case SOI:
773  return 0;
774  case SOF0:
775  case SOF1:
776  case SOF2:
777  case SOF3:
778  case SOF5:
779  case SOF6:
780  case SOF7:
781  i += AV_RB16(&b[i + 2]) + 1;
782  if (state != SOI)
783  return 0;
784  state = SOF0;
785  break;
786  case SOS:
787  i += AV_RB16(&b[i + 2]) + 1;
788  if (state != SOF0 && state != SOS)
789  return 0;
790  state = SOS;
791  break;
792  case EOI:
793  if (state != SOS)
794  return 0;
795  state = EOI;
796  break;
797  case DQT:
798  case APP0:
799  if (AV_RL32(&b[i + 4]) == MKTAG('J','F','I','F'))
800  got_header = 1;
801  case APP1:
802  if (AV_RL32(&b[i + 4]) == MKTAG('E','x','i','f'))
803  got_header = 1;
804  case APP2:
805  case APP3:
806  case APP4:
807  case APP5:
808  case APP6:
809  case APP7:
810  case APP8:
811  case APP9:
812  case APP10:
813  case APP11:
814  case APP12:
815  case APP13:
816  case APP14:
817  case APP15:
818  case COM:
819  i += AV_RB16(&b[i + 2]) + 1;
820  break;
821  default:
822  if ( (c > TEM && c < SOF0)
823  || c == JPG)
824  return 0;
825  }
826  }
827 
828  if (state == EOI)
829  return AVPROBE_SCORE_EXTENSION + 1;
830  if (state == SOS)
831  return AVPROBE_SCORE_EXTENSION / 2 + got_header;
832  return AVPROBE_SCORE_EXTENSION / 8 + 1;
833 }
834 
835 static int jpegls_probe(const AVProbeData *p)
836 {
837  const uint8_t *b = p->buf;
838 
839  if (AV_RB32(b) == 0xffd8fff7)
840  return AVPROBE_SCORE_EXTENSION + 1;
841  return 0;
842 }
843 
844 static int jpegxl_probe(const AVProbeData *p)
845 {
846  const uint8_t *b = p->buf;
847 
848  /* ISOBMFF-based container */
849  /* 0x4a584c20 == "JXL " */
851  return AVPROBE_SCORE_EXTENSION + 1;
852  /* Raw codestreams all start with 0xff0a */
854  return 0;
855 #if CONFIG_IMAGE_JPEGXL_PIPE_DEMUXER
856  if (ff_jpegxl_parse_codestream_header(p->buf, p->buf_size, NULL, 5) >= 0)
857  return AVPROBE_SCORE_MAX - 2;
858 #endif
859  return 0;
860 }
861 
862 static int pcx_probe(const AVProbeData *p)
863 {
864  const uint8_t *b = p->buf;
865 
866  if ( p->buf_size < 128
867  || b[0] != 10
868  || b[1] > 5
869  || b[2] > 1
870  || av_popcount(b[3]) != 1 || b[3] > 8
871  || AV_RL16(&b[4]) > AV_RL16(&b[8])
872  || AV_RL16(&b[6]) > AV_RL16(&b[10])
873  || b[64])
874  return 0;
875  b += 73;
876  while (++b < p->buf + 128)
877  if (*b)
878  return AVPROBE_SCORE_EXTENSION / 4;
879 
880  return AVPROBE_SCORE_EXTENSION + 1;
881 }
882 
883 static int qdraw_probe(const AVProbeData *p)
884 {
885  const uint8_t *b = p->buf;
886 
887  if ( p->buf_size >= 528
888  && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
889  && AV_RB16(b + 520)
890  && AV_RB16(b + 518))
891  return AVPROBE_SCORE_MAX * 3 / 4;
892  if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
893  && AV_RB16(b + 8)
894  && AV_RB16(b + 6))
895  return AVPROBE_SCORE_EXTENSION / 4;
896  return 0;
897 }
898 
899 static int pictor_probe(const AVProbeData *p)
900 {
901  const uint8_t *b = p->buf;
902 
903  if (AV_RL16(b) == 0x1234)
904  return AVPROBE_SCORE_EXTENSION / 4;
905  return 0;
906 }
907 
908 static int png_probe(const AVProbeData *p)
909 {
910  const uint8_t *b = p->buf;
911 
912  if (AV_RB64(b) == 0x89504e470d0a1a0a)
913  return AVPROBE_SCORE_MAX - 1;
914  return 0;
915 }
916 
917 static int psd_probe(const AVProbeData *p)
918 {
919  const uint8_t *b = p->buf;
920  int ret = 0;
921  uint16_t color_mode;
922 
923  if (AV_RL32(b) == MKTAG('8','B','P','S')) {
924  ret += 1;
925  } else {
926  return 0;
927  }
928 
929  if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
930  ret += 1;
931  } else {
932  return 0;
933  }
934 
935  if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
936  ret += 1;
937 
938  color_mode = AV_RB16(b+24);
939  if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
940  ret += 1;
941 
942  return AVPROBE_SCORE_EXTENSION + ret;
943 }
944 
945 static int sgi_probe(const AVProbeData *p)
946 {
947  const uint8_t *b = p->buf;
948 
949  if (AV_RB16(b) == 474 &&
950  (b[2] & ~1) == 0 &&
951  (b[3] & ~3) == 0 && b[3] &&
952  (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
953  return AVPROBE_SCORE_EXTENSION + 1;
954  return 0;
955 }
956 
957 static int sunrast_probe(const AVProbeData *p)
958 {
959  const uint8_t *b = p->buf;
960 
961  if (AV_RB32(b) == 0x59a66a95)
962  return AVPROBE_SCORE_EXTENSION + 1;
963  return 0;
964 }
965 
966 static int svg_probe(const AVProbeData *p)
967 {
968  const uint8_t *b = p->buf;
969  const uint8_t *end = p->buf + p->buf_size;
970  while (b < end && av_isspace(*b))
971  b++;
972  if (b >= end - 5)
973  return 0;
974  if (!memcmp(b, "<svg", 4))
975  return AVPROBE_SCORE_EXTENSION + 1;
976  if (memcmp(p->buf, "<?xml", 5) && memcmp(b, "<!--", 4))
977  return 0;
978  while (b < end) {
979  int inc = ff_subtitles_next_line(b);
980  if (!inc)
981  break;
982  b += inc;
983  if (b >= end - 4)
984  return 0;
985  if (!memcmp(b, "<svg", 4))
986  return AVPROBE_SCORE_EXTENSION + 1;
987  }
988  return 0;
989 }
990 
991 static int tiff_probe(const AVProbeData *p)
992 {
993  const uint8_t *b = p->buf;
994 
995  if (AV_RB32(b) == 0x49492a00 ||
996  AV_RB32(b) == 0x4D4D002a)
997  return AVPROBE_SCORE_EXTENSION + 1;
998  return 0;
999 }
1000 
1001 static int webp_probe(const AVProbeData *p)
1002 {
1003  const uint8_t *b = p->buf;
1004 
1005  if (AV_RB32(b) == 0x52494646 &&
1006  AV_RB32(b + 8) == 0x57454250)
1007  return AVPROBE_SCORE_MAX - 1;
1008  return 0;
1009 }
1010 
1011 static int pnm_magic_check(const AVProbeData *p, int magic)
1012 {
1013  const uint8_t *b = p->buf;
1014 
1015  return b[0] == 'P' && b[1] == magic + '0';
1016 }
1017 
1018 static inline int pnm_probe(const AVProbeData *p)
1019 {
1020  const uint8_t *b = p->buf;
1021 
1022  while (b[2] == '\r')
1023  b++;
1024  if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
1025  return AVPROBE_SCORE_EXTENSION + 2;
1026  return 0;
1027 }
1028 
1029 static int pbm_probe(const AVProbeData *p)
1030 {
1031  return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
1032 }
1033 
1034 static int pfm_probe(const AVProbeData *p)
1035 {
1036  return pnm_magic_check(p, 'F' - '0') ||
1037  pnm_magic_check(p, 'f' - '0') ? pnm_probe(p) : 0;
1038 }
1039 
1040 static int phm_probe(const AVProbeData *p)
1041 {
1042  return pnm_magic_check(p, 'H' - '0') ||
1043  pnm_magic_check(p, 'h' - '0') ? pnm_probe(p) : 0;
1044 }
1045 
1046 static inline int pgmx_probe(const AVProbeData *p)
1047 {
1048  return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
1049 }
1050 
1051 static int pgm_probe(const AVProbeData *p)
1052 {
1053  int ret = pgmx_probe(p);
1054  return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1055 }
1056 
1057 static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
1058 {
1059  int ret = pgmx_probe(p);
1060  return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1061 }
1062 
1063 static int pgx_probe(const AVProbeData *p)
1064 {
1065  const uint8_t *b = p->buf;
1066  if (!memcmp(b, "PG ML ", 6))
1067  return AVPROBE_SCORE_EXTENSION + 1;
1068  return 0;
1069 }
1070 
1071 static int ppm_probe(const AVProbeData *p)
1072 {
1073  return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
1074 }
1075 
1076 static int pam_probe(const AVProbeData *p)
1077 {
1078  return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
1079 }
1080 
1081 static int hdr_probe(const AVProbeData *p)
1082 {
1083  if (!memcmp(p->buf, "#?RADIANCE\n", 11))
1084  return AVPROBE_SCORE_MAX;
1085  return 0;
1086 }
1087 
1088 static int xbm_probe(const AVProbeData *p)
1089 {
1090  if (!memcmp(p->buf, "/* XBM X10 format */", 20))
1091  return AVPROBE_SCORE_MAX;
1092 
1093  if (!memcmp(p->buf, "#define", 7))
1094  return AVPROBE_SCORE_MAX - 1;
1095  return 0;
1096 }
1097 
1098 static int xpm_probe(const AVProbeData *p)
1099 {
1100  const uint8_t *b = p->buf;
1101 
1102  if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
1103  return AVPROBE_SCORE_MAX - 1;
1104  return 0;
1105 }
1106 
1107 static int xwd_probe(const AVProbeData *p)
1108 {
1109  const uint8_t *b = p->buf;
1110  unsigned width, bpp, bpad, lsize;
1111 
1112  if ( p->buf_size < XWD_HEADER_SIZE
1113  || AV_RB32(b ) < XWD_HEADER_SIZE // header size
1114  || AV_RB32(b + 4) != XWD_VERSION // version
1115  || AV_RB32(b + 8) != XWD_Z_PIXMAP // format
1116  || AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
1117  || AV_RB32(b + 16) == 0 // width
1118  || AV_RB32(b + 20) == 0 // height
1119  || AV_RB32(b + 28) > 1 // byteorder
1120  || AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
1121  || AV_RB32(b + 36) > 1 // bitorder
1122  || AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
1123  || AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
1124  || AV_RB32(b + 68) > 256) // colours
1125  return 0;
1126 
1127  width = AV_RB32(b + 16);
1128  bpad = AV_RB32(b + 40);
1129  bpp = AV_RB32(b + 44);
1130  lsize = AV_RB32(b + 48);
1131  if (lsize < FFALIGN(width * bpp, bpad) >> 3)
1132  return 0;
1133 
1134  return AVPROBE_SCORE_MAX / 2 + 1;
1135 }
1136 
1137 static int gif_probe(const AVProbeData *p)
1138 {
1139  /* check magick */
1140  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
1141  return 0;
1142 
1143  /* width or height contains zero? */
1144  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
1145  return 0;
1146 
1147  return AVPROBE_SCORE_MAX - 1;
1148 }
1149 
1150 static int photocd_probe(const AVProbeData *p)
1151 {
1152  if (!memcmp(p->buf, "PCD_OPA", 7))
1153  return AVPROBE_SCORE_MAX - 1;
1154 
1155  if (p->buf_size < 0x807 || memcmp(p->buf + 0x800, "PCD_IPI", 7))
1156  return 0;
1157 
1158  return AVPROBE_SCORE_MAX - 1;
1159 }
1160 
1161 static int qoi_probe(const AVProbeData *p)
1162 {
1163  if (memcmp(p->buf, "qoif", 4))
1164  return 0;
1165 
1166  if (AV_RB32(p->buf + 4) == 0 || AV_RB32(p->buf + 8) == 0)
1167  return 0;
1168 
1169  if (p->buf[12] != 3 && p->buf[12] != 4)
1170  return 0;
1171 
1172  if (p->buf[13] > 1)
1173  return 0;
1174 
1175  return AVPROBE_SCORE_MAX - 1;
1176 }
1177 
1178 static int gem_probe(const AVProbeData *p)
1179 {
1180  const uint8_t *b = p->buf;
1181  if ( AV_RB16(b ) >= 1 && AV_RB16(b ) <= 3 &&
1182  AV_RB16(b + 2) >= 8 && AV_RB16(b + 2) <= 779 &&
1183  (AV_RB16(b + 4) > 0 && AV_RB16(b + 4) <= 32) && /* planes */
1184  (AV_RB16(b + 6) > 0 && AV_RB16(b + 6) <= 8) && /* pattern_size */
1185  AV_RB16(b + 8) &&
1186  AV_RB16(b + 10) &&
1187  AV_RB16(b + 12) &&
1188  AV_RB16(b + 14)) {
1189  if (AV_RN32(b + 16) == AV_RN32("STTT") ||
1190  AV_RN32(b + 16) == AV_RN32("TIMG") ||
1191  AV_RN32(b + 16) == AV_RN32("XIMG"))
1192  return AVPROBE_SCORE_EXTENSION + 1;
1193  return AVPROBE_SCORE_EXTENSION / 4;
1194  }
1195  return 0;
1196 }
1197 
1198 static int vbn_probe(const AVProbeData *p)
1199 {
1200  const uint8_t *b = p->buf;
1201  if (AV_RL32(b ) == VBN_MAGIC &&
1202  AV_RL32(b + 4) == VBN_MAJOR &&
1203  AV_RL32(b + 8) == VBN_MINOR)
1204  return AVPROBE_SCORE_MAX - 1;
1205  return 0;
1206 }
1207 
1208 #define IMAGEAUTO_DEMUXER_0(imgname, codecid)
1209 #define IMAGEAUTO_DEMUXER_1(imgname, codecid)\
1210 const FFInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
1211  .p.name = AV_STRINGIFY(imgname) "_pipe",\
1212  .p.long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
1213  .p.priv_class = &imagepipe_class,\
1214  .p.flags = AVFMT_GENERIC_INDEX,\
1215  .priv_data_size = sizeof(VideoDemuxData),\
1216  .read_probe = imgname ## _probe,\
1217  .read_header = ff_img_read_header,\
1218  .read_packet = ff_img_read_packet,\
1219  .raw_codec_id = codecid,\
1220 };
1221 
1222 #define IMAGEAUTO_DEMUXER_2(imgname, codecid, enabled) \
1223  IMAGEAUTO_DEMUXER_ ## enabled(imgname, codecid)
1224 #define IMAGEAUTO_DEMUXER_3(imgname, codecid, config) \
1225  IMAGEAUTO_DEMUXER_2(imgname, codecid, config)
1226 #define IMAGEAUTO_DEMUXER_EXT(imgname, codecid, uppercase_name) \
1227  IMAGEAUTO_DEMUXER_3(imgname, AV_CODEC_ID_ ## codecid, \
1228  CONFIG_IMAGE_ ## uppercase_name ## _PIPE_DEMUXER)
1229 #define IMAGEAUTO_DEMUXER(imgname, codecid) \
1230  IMAGEAUTO_DEMUXER_EXT(imgname, codecid, codecid)
1231 
1232 IMAGEAUTO_DEMUXER(bmp, BMP)
1233 IMAGEAUTO_DEMUXER(cri, CRI)
1234 IMAGEAUTO_DEMUXER(dds, DDS)
1235 IMAGEAUTO_DEMUXER(dpx, DPX)
1236 IMAGEAUTO_DEMUXER(exr, EXR)
1237 IMAGEAUTO_DEMUXER(gem, GEM)
1238 IMAGEAUTO_DEMUXER(gif, GIF)
1239 IMAGEAUTO_DEMUXER_EXT(hdr, RADIANCE_HDR, HDR)
1240 IMAGEAUTO_DEMUXER_EXT(j2k, JPEG2000, J2K)
1241 IMAGEAUTO_DEMUXER_EXT(jpeg, MJPEG, JPEG)
1242 IMAGEAUTO_DEMUXER(jpegls, JPEGLS)
1243 IMAGEAUTO_DEMUXER(jpegxl, JPEGXL)
1244 IMAGEAUTO_DEMUXER(pam, PAM)
1245 IMAGEAUTO_DEMUXER(pbm, PBM)
1246 IMAGEAUTO_DEMUXER(pcx, PCX)
1247 IMAGEAUTO_DEMUXER(pfm, PFM)
1248 IMAGEAUTO_DEMUXER(pgm, PGM)
1249 IMAGEAUTO_DEMUXER(pgmyuv, PGMYUV)
1250 IMAGEAUTO_DEMUXER(pgx, PGX)
1251 IMAGEAUTO_DEMUXER(phm, PHM)
1252 IMAGEAUTO_DEMUXER(photocd, PHOTOCD)
1253 IMAGEAUTO_DEMUXER(pictor, PICTOR)
1254 IMAGEAUTO_DEMUXER(png, PNG)
1255 IMAGEAUTO_DEMUXER(ppm, PPM)
1256 IMAGEAUTO_DEMUXER(psd, PSD)
1257 IMAGEAUTO_DEMUXER(qdraw, QDRAW)
1258 IMAGEAUTO_DEMUXER(qoi, QOI)
1259 IMAGEAUTO_DEMUXER(sgi, SGI)
1260 IMAGEAUTO_DEMUXER(sunrast, SUNRAST)
1261 IMAGEAUTO_DEMUXER(svg, SVG)
1262 IMAGEAUTO_DEMUXER(tiff, TIFF)
1263 IMAGEAUTO_DEMUXER(vbn, VBN)
1264 IMAGEAUTO_DEMUXER(webp, WEBP)
1265 IMAGEAUTO_DEMUXER(xbm, XBM)
1266 IMAGEAUTO_DEMUXER(xpm, XPM)
1267 IMAGEAUTO_DEMUXER(xwd, XWD)
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
FFInputFormat::read_probe
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: demux.h:63
mjpeg.h
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
pam_probe
static int pam_probe(const AVProbeData *p)
Definition: img2dec.c:1076
SOS
@ SOS
Definition: mjpeg.h:72
ff_jpegxl_parse_codestream_header
int ff_jpegxl_parse_codestream_header(const uint8_t *buf, int buflen, FFJXLMetadata *meta, int validate)
Definition: jpegxl_parse.c:255
APP1
@ APP1
Definition: mjpeg.h:80
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
cri_probe
static int cri_probe(const AVProbeData *p)
Definition: img2dec.c:697
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
SOF0
@ SOF0
Definition: mjpeg.h:39
pnm_magic_check
static int pnm_magic_check(const AVProbeData *p, int magic)
Definition: img2dec.c:1011
VBN_MINOR
#define VBN_MINOR
Definition: vbn.h:31
OFFSET
#define OFFSET(x)
Definition: img2dec.c:611
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:218
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
webp_probe
static int webp_probe(const AVProbeData *p)
Definition: img2dec.c:1001
ff_img_read_header
int ff_img_read_header(AVFormatContext *s1)
Definition: img2dec.c:188
AVPacket::data
uint8_t * data
Definition: packet.h:524
dds_probe
static int dds_probe(const AVProbeData *p)
Definition: img2dec.c:708
AVOption
AVOption.
Definition: opt.h:357
b
#define b
Definition: input.c:41
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
imagepipe_class
static const AVClass imagepipe_class
Definition: img2dec.c:661
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1414
psd_probe
static int psd_probe(const AVProbeData *p)
Definition: img2dec.c:917
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:125
qoi_probe
static int qoi_probe(const AVProbeData *p)
Definition: img2dec.c:1161
phm_probe
static int phm_probe(const AVProbeData *p)
Definition: img2dec.c:1040
pcx_probe
static int pcx_probe(const AVProbeData *p)
Definition: img2dec.c:862
AVDictionary
Definition: dict.c:34
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
img_read_seek
static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: img2dec.c:591
av_popcount
#define av_popcount
Definition: common.h:153
FFInputFormat::read_header
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: demux.h:70
av_get_frame_filename
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:341
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
os_support.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
XWD_Z_PIXMAP
#define XWD_Z_PIXMAP
Definition: xwd.h:32
av_basename
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:252
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
APP15
@ APP15
Definition: mjpeg.h:94
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:114
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
is_glob
static int is_glob(const char *path)
Definition: img2dec.c:86
FF_JPEGXL_CONTAINER_SIGNATURE_LE
#define FF_JPEGXL_CONTAINER_SIGNATURE_LE
Definition: jpegxl.h:26
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: packet.c:197
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
APP4
@ APP4
Definition: mjpeg.h:83
fail
#define fail()
Definition: checkasm.h:183
svg_probe
static int svg_probe(const AVProbeData *p)
Definition: img2dec.c:966
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:121
SOF3
@ SOF3
Definition: mjpeg.h:42
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
IMAGEAUTO_DEMUXER
#define IMAGEAUTO_DEMUXER(imgname, codecid)
Definition: img2dec.c:1229
pgmx_probe
static int pgmx_probe(const AVProbeData *p)
Definition: img2dec.c:1046
APP13
@ APP13
Definition: mjpeg.h:92
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:465
img_read_close
static int img_read_close(struct AVFormatContext *s1)
Definition: img2dec.c:580
img2pipe_options
static const AVOption img2pipe_options[]
Definition: img2dec.c:657
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:154
PT_NONE
@ PT_NONE
Definition: img2.h:37
loop
static int loop
Definition: ffplay.c:335
PT_GLOB
@ PT_GLOB
Definition: img2.h:35
gif89a_sig
static const uint8_t gif89a_sig[6]
Definition: gif.h:35
pictor_probe
static int pictor_probe(const AVProbeData *p)
Definition: img2dec.c:899
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:180
AVInputFormat
Definition: avformat.h:548
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
COM
@ COM
Definition: mjpeg.h:111
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
SOF5
@ SOF5
Definition: mjpeg.h:44
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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: packet.c:98
APP12
@ APP12
Definition: mjpeg.h:91
img_read_probe
static int img_read_probe(const AVProbeData *p)
Definition: img2dec.c:169
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
APP3
@ APP3
Definition: mjpeg.h:82
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
PT_DEFAULT
@ PT_DEFAULT
Definition: img2.h:38
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
s1
#define s1
Definition: regdef.h:38
AVProbeData::filename
const char * filename
Definition: avformat.h:452
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:41
add_filename_as_pkt_side_data
static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt)
Add this frame's source path and basename to packet's sidedata as a dictionary, so it can be used by ...
Definition: img2dec.c:390
bmp_probe
static int bmp_probe(const AVProbeData *p)
Definition: img2dec.c:679
pgmyuv_probe
static int pgmyuv_probe(const AVProbeData *p)
Definition: img2dec.c:1057
AV_CODEC_ID_ALIAS_PIX
@ AV_CODEC_ID_ALIAS_PIX
Definition: codec_id.h:229
j2k_probe
static int j2k_probe(const AVProbeData *p)
Definition: img2dec.c:746
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
APP11
@ APP11
Definition: mjpeg.h:90
ff_image2_demuxer
const FFInputFormat ff_image2_demuxer
VideoDemuxData
Definition: img2.h:41
xpm_probe
static int xpm_probe(const AVProbeData *p)
Definition: img2dec.c:1098
APP5
@ APP5
Definition: mjpeg.h:84
if
if(ret)
Definition: filter_design.txt:179
xwd.h
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
gem_probe
static int gem_probe(const AVProbeData *p)
Definition: img2dec.c:1178
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_img_options
const AVOption ff_img_options[]
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:59
APP9
@ APP9
Definition: mjpeg.h:88
xwd_probe
static int xwd_probe(const AVProbeData *p)
Definition: img2dec.c:1107
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1206
photocd_probe
static int photocd_probe(const AVProbeData *p)
Definition: img2dec.c:1150
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:362
VBN_MAJOR
#define VBN_MAJOR
Definition: vbn.h:30
xbm_probe
static int xbm_probe(const AVProbeData *p)
Definition: img2dec.c:1088
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
VBN_MAGIC
#define VBN_MAGIC
Definition: vbn.h:29
TEM
@ TEM
Definition: mjpeg.h:113
jpegxl_probe
static int jpegxl_probe(const AVProbeData *p)
Definition: img2dec.c:844
index
int index
Definition: gxfenc.c:90
find_image_range
static int find_image_range(AVIOContext *pb, int *pfirst_index, int *plast_index, const char *path, int start_index, int start_index_range)
Get index range of image files matched by path.
Definition: img2dec.c:116
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:461
DEC
#define DEC
Definition: img2dec.c:612
FFInputFormat::read_packet
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: demux.h:80
PT_SEQUENCE
@ PT_SEQUENCE
Definition: img2.h:36
sunrast_probe
static int sunrast_probe(const AVProbeData *p)
Definition: img2dec.c:957
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
vbn_probe
static int vbn_probe(const AVProbeData *p)
Definition: img2dec.c:1198
AVPacket::size
int size
Definition: packet.h:525
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
XWD_HEADER_SIZE
#define XWD_HEADER_SIZE
Definition: xwd.h:27
gif.h
size
int size
Definition: twinvq_data.h:10344
pfm_probe
static int pfm_probe(const AVProbeData *p)
Definition: img2dec.c:1034
dpx_probe
static int dpx_probe(const AVProbeData *p)
Definition: img2dec.c:719
AV_RB32
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_RB32
Definition: bytestream.h:96
IMAGEAUTO_DEMUXER_EXT
#define IMAGEAUTO_DEMUXER_EXT(imgname, codecid, uppercase_name)
Definition: img2dec.c:1226
avio_check
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url,...
Definition: avio.c:664
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:944
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:606
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
header
static const uint8_t header[24]
Definition: sdr2.c:68
av_packet_pack_dictionary
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: packet.c:312
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
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
DQT
@ DQT
Definition: mjpeg.h:73
APP6
@ APP6
Definition: mjpeg.h:85
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
gif_probe
static int gif_probe(const AVProbeData *p)
Definition: img2dec.c:1137
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
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:517
EOI
@ EOI
Definition: mjpeg.h:71
avio_internal.h
gif87a_sig
static const uint8_t gif87a_sig[6]
Definition: gif.h:34
AVCodecParameters::height
int height
Definition: codec_par.h:135
img2.h
APP8
@ APP8
Definition: mjpeg.h:87
FF_JPEGXL_CODESTREAM_SIGNATURE_LE
#define FF_JPEGXL_CODESTREAM_SIGNATURE_LE
Definition: jpegxl.h:25
pgm_probe
static int pgm_probe(const AVProbeData *p)
Definition: img2dec.c:1051
state
static struct @416 state
FFInputFormat::raw_codec_id
enum AVCodecID raw_codec_id
Raw demuxers store their codec ID here.
Definition: demux.h:46
demux.h
infer_size
static int infer_size(int *width_ptr, int *height_ptr, int size)
Definition: img2dec.c:71
APP7
@ APP7
Definition: mjpeg.h:86
sgi_probe
static int sgi_probe(const AVProbeData *p)
Definition: img2dec.c:945
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
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:71
pgx_probe
static int pgx_probe(const AVProbeData *p)
Definition: img2dec.c:1063
SOF2
@ SOF2
Definition: mjpeg.h:41
pnm_probe
static int pnm_probe(const AVProbeData *p)
Definition: img2dec.c:1018
avformat.h
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: img2dec.c:613
APP14
@ APP14
Definition: mjpeg.h:93
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2897
ff_image2pipe_demuxer
const FFInputFormat ff_image2pipe_demuxer
jpeg_probe
static int jpeg_probe(const AVProbeData *p)
Definition: img2dec.c:756
subtitles.h
png_probe
static int png_probe(const AVProbeData *p)
Definition: img2dec.c:908
jpegls_probe
static int jpegls_probe(const AVProbeData *p)
Definition: img2dec.c:835
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
hdr_probe
static int hdr_probe(const AVProbeData *p)
Definition: img2dec.c:1081
APP2
@ APP2
Definition: mjpeg.h:81
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:133
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
PROBE_BUF_MIN
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:33
ppm_probe
static int ppm_probe(const AVProbeData *p)
Definition: img2dec.c:1071
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
exr_probe
static int exr_probe(const AVProbeData *p)
Definition: img2dec.c:737
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVPacket::stream_index
int stream_index
Definition: packet.h:526
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
ff_img_read_packet
int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: img2dec.c:412
APP0
@ APP0
Definition: mjpeg.h:79
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
pbm_probe
static int pbm_probe(const AVProbeData *p)
Definition: img2dec.c:1029
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:617
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
mem.h
vbn.h
ffio_rewind_with_probe_data
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **buf, int buf_size)
Rewind the AVIOContext using the specified buffer containing the first buf_size bytes of the file.
Definition: aviobuf.c:1148
SOI
@ SOI
Definition: mjpeg.h:70
AVCodecParameters::format
int format
Definition: codec_par.h:92
SOF1
@ SOF1
Definition: mjpeg.h:40
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
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:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
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
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
tiff_probe
static int tiff_probe(const AVProbeData *p)
Definition: img2dec.c:991
FFInputFormat
Definition: demux.h:37
XWD_VERSION
#define XWD_VERSION
Definition: xwd.h:26
d
d
Definition: ffmpeg_filter.c:424
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
jpegxl_parse.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
APP10
@ APP10
Definition: mjpeg.h:89
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFStream::parser
struct AVCodecParserContext * parser
Definition: internal.h:387
PT_GLOB_SEQUENCE
@ PT_GLOB_SEQUENCE
Definition: img2.h:34
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
SOF7
@ SOF7
Definition: mjpeg.h:46
ff_subtitles_next_line
static av_always_inline int ff_subtitles_next_line(const char *ptr)
Get the number of characters to increment to jump to the next line, or to the end of the string.
Definition: subtitles.h:205
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
avstring.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:61
SOF6
@ SOF6
Definition: mjpeg.h:45
qdraw_probe
static int qdraw_probe(const AVProbeData *p)
Definition: img2dec.c:883
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
JPG
@ JPG
Definition: mjpeg.h:47
AV_RB16
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_RB16
Definition: bytestream.h:98
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:244
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346