FFmpeg: libavformat/img2dec.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /