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

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