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/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/parseutils.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  s->img_count++;
567  s->img_number++;
568  s->pts++;
569  return 0;
570  }
571 
572 fail:
573  if (!s->is_pipe) {
574  for (i = 0; i < 3; i++) {
575  if (f[i] != s1->pb)
576  ff_format_io_close(s1, &f[i]);
577  }
578  }
579  return res;
580 }
581 
582  static int img_read_close(struct AVFormatContext* s1)
583 {
584 #if HAVE_GLOB
585  VideoDemuxData *s = s1->priv_data;
586  if (s->use_glob) {
587  globfree(&s->globstate);
588  }
589 #endif
590  return 0;
591 }
592 
593  static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
594 {
595  VideoDemuxData *s1 = s->priv_data;
596  AVStream *st = s->streams[0];
597 
598  if (s1->ts_from_file) {
599  int index = av_index_search_timestamp(st, timestamp, flags);
600  if(index < 0)
601  return -1;
602  s1->img_number = ffstream(st)->index_entries[index].pos;
603  return 0;
604  }
605 
606  if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
607  return -1;
608  s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
609  s1->pts = timestamp;
610  return 0;
611 }
612 
613  #define OFFSET(x) offsetof(VideoDemuxData, x)
614  #define DEC AV_OPT_FLAG_DECODING_PARAM
615  #define COMMON_OPTIONS \
616  { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
617  { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
618  { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
619  { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
620  { NULL },
621 
622 #if CONFIG_IMAGE2_DEMUXER
623 const AVOption ff_img_options[] = {
624  { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, .unit = "pattern_type"},
625  { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
626  { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
627  { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
628  { "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, .unit = "pattern_type" },
629  { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
630  { "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 },
631  { "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" },
632  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, .unit = "ts_type" },
633  { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, .unit = "ts_type" },
634  { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, .unit = "ts_type" },
635  { "export_path_metadata", "enable metadata containing input path information", OFFSET(export_path_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
636  COMMON_OPTIONS
637 };
638 
639 static const AVClass img2_class = {
640  .class_name = "image2 demuxer",
641  .item_name = av_default_item_name,
642  .option = ff_img_options,
643  .version = LIBAVUTIL_VERSION_INT,
644 };
645 const FFInputFormat ff_image2_demuxer = {
646  .p.name = "image2",
647  .p.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
648  .p.flags = AVFMT_NOFILE,
649  .p.priv_class = &img2_class,
650  .priv_data_size = sizeof(VideoDemuxData),
651  .read_probe = img_read_probe,
652  .read_header = ff_img_read_header,
653  .read_packet = ff_img_read_packet,
654  .read_close = img_read_close,
655  .read_seek = img_read_seek,
656 };
657 #endif
658 
659  static const AVOption img2pipe_options[] = {
660  { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
661  COMMON_OPTIONS
662 };
663  static const AVClass imagepipe_class = {
664  .class_name = "imagepipe demuxer",
665  .item_name = av_default_item_name,
666  .option = img2pipe_options,
667  .version = LIBAVUTIL_VERSION_INT,
668 };
669 
670 #if CONFIG_IMAGE2PIPE_DEMUXER
671 const FFInputFormat ff_image2pipe_demuxer = {
672  .p.name = "image2pipe",
673  .p.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
674  .p.priv_class = &imagepipe_class,
675  .priv_data_size = sizeof(VideoDemuxData),
676  .read_header = ff_img_read_header,
677  .read_packet = ff_img_read_packet,
678 };
679 #endif
680 
681  static int bmp_probe(const AVProbeData *p)
682 {
683  const uint8_t *b = p->buf;
684  int ihsize;
685 
686  if (AV_RB16(b) != 0x424d)
687  return 0;
688 
689  ihsize = AV_RL32(b+14);
690  if (ihsize < 12 || ihsize > 255)
691  return 0;
692 
693  if (!AV_RN32(b + 6)) {
694  return AVPROBE_SCORE_EXTENSION + 1;
695  }
696  return AVPROBE_SCORE_EXTENSION / 4;
697 }
698 
699  static int cri_probe(const AVProbeData *p)
700 {
701  const uint8_t *b = p->buf;
702 
703  if ( AV_RL32(b) == 1
704  && AV_RL32(b + 4) == 4
705  && AV_RN32(b + 8) == AV_RN32("DVCC"))
706  return AVPROBE_SCORE_MAX - 1;
707  return 0;
708 }
709 
710  static int dds_probe(const AVProbeData *p)
711 {
712  const uint8_t *b = p->buf;
713 
714  if ( AV_RB64(b) == 0x444453207c000000
715  && AV_RL32(b + 8)
716  && AV_RL32(b + 12))
717  return AVPROBE_SCORE_MAX - 1;
718  return 0;
719 }
720 
721  static int dpx_probe(const AVProbeData *p)
722 {
723  const uint8_t *b = p->buf;
724  int w, h;
725  int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
726 
727  if (p->buf_size < 0x304+8)
728  return 0;
729  w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
730  h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
731  if (w <= 0 || h <= 0)
732  return 0;
733 
734  if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
735  return AVPROBE_SCORE_EXTENSION + 1;
736  return 0;
737 }
738 
739  static int exr_probe(const AVProbeData *p)
740 {
741  const uint8_t *b = p->buf;
742 
743  if (AV_RL32(b) == 20000630)
744  return AVPROBE_SCORE_EXTENSION + 1;
745  return 0;
746 }
747 
748  static int j2k_probe(const AVProbeData *p)
749 {
750  const uint8_t *b = p->buf;
751 
752  if (AV_RB64(b) == 0x0000000c6a502020 ||
753  AV_RB32(b) == 0xff4fff51)
754  return AVPROBE_SCORE_EXTENSION + 1;
755  return 0;
756 }
757 
758  static int jpeg_probe(const AVProbeData *p)
759 {
760  const uint8_t *b = p->buf;
761  int i, state = SOI, got_header = 0;
762 
763  if (AV_RB16(b) != 0xFFD8 ||
764  AV_RB32(b) == 0xFFD8FFF7)
765  return 0;
766 
767  b += 2;
768  for (i = 0; i < p->buf_size - 3; i++) {
769  int c;
770  if (b[i] != 0xFF)
771  continue;
772  c = b[i + 1];
773  switch (c) {
774  case SOI:
775  return 0;
776  case SOF0:
777  case SOF1:
778  case SOF2:
779  case SOF3:
780  case SOF5:
781  case SOF6:
782  case SOF7:
783  i += AV_RB16(&b[i + 2]) + 1;
784  if (state != SOI)
785  return 0;
786  state = SOF0;
787  break;
788  case SOS:
789  i += AV_RB16(&b[i + 2]) + 1;
790  if (state != SOF0 && state != SOS)
791  return 0;
792  state = SOS;
793  break;
794  case EOI:
795  if (state != SOS)
796  return 0;
797  state = EOI;
798  break;
799  case APP0:
800  if (c == APP0 && AV_RL32(&b[i + 4]) == MKTAG('J','F','I','F'))
801  got_header = 1;
802  /* fallthrough */
803  case APP1:
804  if (c == APP1 && AV_RL32(&b[i + 4]) == MKTAG('E','x','i','f'))
805  got_header = 1;
806  /* fallthrough */
807  case APP2:
808  case APP3:
809  case APP4:
810  case APP5:
811  case APP6:
812  case APP7:
813  case APP8:
814  case APP9:
815  case APP10:
816  case APP11:
817  case APP12:
818  case APP13:
819  case APP14:
820  case APP15:
821  case DQT: /* fallthrough */
822  case COM:
823  i += AV_RB16(&b[i + 2]) + 1;
824  break;
825  default:
826  if ( (c > TEM && c < SOF0)
827  || c == JPG)
828  return 0;
829  }
830  }
831 
832  if (state == EOI)
833  return AVPROBE_SCORE_EXTENSION + 1;
834  if (state == SOS)
835  return AVPROBE_SCORE_EXTENSION / 2 + got_header;
836  return AVPROBE_SCORE_EXTENSION / 8 + 1;
837 }
838 
839  static int jpegls_probe(const AVProbeData *p)
840 {
841  const uint8_t *b = p->buf;
842 
843  if (AV_RB32(b) == 0xffd8fff7)
844  return AVPROBE_SCORE_EXTENSION + 1;
845  return 0;
846 }
847 
848  static int jpegxl_probe(const AVProbeData *p)
849 {
850  const uint8_t *b = p->buf;
851 
852  /* ISOBMFF-based container */
853  /* 0x4a584c20 == "JXL " */
854  if (AV_RL64(b) == FF_JPEGXL_CONTAINER_SIGNATURE_LE)
855  return AVPROBE_SCORE_EXTENSION + 1;
856  /* Raw codestreams all start with 0xff0a */
857  if (AV_RL16(b) != FF_JPEGXL_CODESTREAM_SIGNATURE_LE)
858  return 0;
859 #if CONFIG_IMAGE_JPEGXL_PIPE_DEMUXER
860  if (ff_jpegxl_parse_codestream_header(p->buf, p->buf_size, NULL, 5) >= 0)
861  return AVPROBE_SCORE_MAX - 2;
862 #endif
863  return 0;
864 }
865 
866  static int pcx_probe(const AVProbeData *p)
867 {
868  const uint8_t *b = p->buf;
869 
870  if ( p->buf_size < 128
871  || b[0] != 10
872  || b[1] > 5
873  || b[2] > 1
874  || av_popcount(b[3]) != 1 || b[3] > 8
875  || AV_RL16(&b[4]) > AV_RL16(&b[8])
876  || AV_RL16(&b[6]) > AV_RL16(&b[10])
877  || b[64])
878  return 0;
879  b += 73;
880  while (++b < p->buf + 128)
881  if (*b)
882  return AVPROBE_SCORE_EXTENSION / 4;
883 
884  return AVPROBE_SCORE_EXTENSION + 1;
885 }
886 
887  static int qdraw_probe(const AVProbeData *p)
888 {
889  const uint8_t *b = p->buf;
890 
891  if ( p->buf_size >= 528
892  && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
893  && AV_RB16(b + 520)
894  && AV_RB16(b + 518))
895  return AVPROBE_SCORE_MAX * 3 / 4;
896  if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
897  && AV_RB16(b + 8)
898  && AV_RB16(b + 6))
899  return AVPROBE_SCORE_EXTENSION / 4;
900  return 0;
901 }
902 
903  static int pictor_probe(const AVProbeData *p)
904 {
905  const uint8_t *b = p->buf;
906 
907  if (AV_RL16(b) == 0x1234)
908  return AVPROBE_SCORE_EXTENSION / 4;
909  return 0;
910 }
911 
912  static int png_probe(const AVProbeData *p)
913 {
914  const uint8_t *b = p->buf;
915 
916  if (AV_RB64(b) == 0x89504e470d0a1a0a)
917  return AVPROBE_SCORE_MAX - 1;
918  return 0;
919 }
920 
921  static int psd_probe(const AVProbeData *p)
922 {
923  const uint8_t *b = p->buf;
924  int ret = 0;
925  uint16_t color_mode;
926 
927  if (AV_RL32(b) == MKTAG('8','B','P','S')) {
928  ret += 1;
929  } else {
930  return 0;
931  }
932 
933  if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
934  ret += 1;
935  } else {
936  return 0;
937  }
938 
939  if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
940  ret += 1;
941 
942  color_mode = AV_RB16(b+24);
943  if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
944  ret += 1;
945 
946  return AVPROBE_SCORE_EXTENSION + ret;
947 }
948 
949  static int sgi_probe(const AVProbeData *p)
950 {
951  const uint8_t *b = p->buf;
952 
953  if (AV_RB16(b) == 474 &&
954  (b[2] & ~1) == 0 &&
955  (b[3] & ~3) == 0 && b[3] &&
956  (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
957  return AVPROBE_SCORE_EXTENSION + 1;
958  return 0;
959 }
960 
961  static int sunrast_probe(const AVProbeData *p)
962 {
963  const uint8_t *b = p->buf;
964 
965  if (AV_RB32(b) == 0x59a66a95)
966  return AVPROBE_SCORE_EXTENSION + 1;
967  return 0;
968 }
969 
970  static int svg_probe(const AVProbeData *p)
971 {
972  const uint8_t *b = p->buf;
973  const uint8_t *end = p->buf + p->buf_size;
974  while (b < end && av_isspace(*b))
975  b++;
976  if (b >= end - 5)
977  return 0;
978  if (!memcmp(b, "<svg", 4))
979  return AVPROBE_SCORE_EXTENSION + 1;
980  if (memcmp(p->buf, "<?xml", 5) && memcmp(b, "<!--", 4))
981  return 0;
982  while (b < end) {
983  int inc = ff_subtitles_next_line(b);
984  if (!inc)
985  break;
986  b += inc;
987  if (b >= end - 4)
988  return 0;
989  if (!memcmp(b, "<svg", 4))
990  return AVPROBE_SCORE_EXTENSION + 1;
991  }
992  return 0;
993 }
994 
995  static int tiff_probe(const AVProbeData *p)
996 {
997  const uint8_t *b = p->buf;
998 
999  if (AV_RB32(b) == 0x49492a00 ||
1000  AV_RB32(b) == 0x4D4D002a)
1001  return AVPROBE_SCORE_EXTENSION + 1;
1002  return 0;
1003 }
1004 
1005  static int webp_probe(const AVProbeData *p)
1006 {
1007  const uint8_t *b = p->buf;
1008 
1009  if (AV_RB32(b) == 0x52494646 &&
1010  AV_RB32(b + 8) == 0x57454250)
1011  return AVPROBE_SCORE_MAX - 1;
1012  return 0;
1013 }
1014 
1015  static int pnm_magic_check(const AVProbeData *p, int magic)
1016 {
1017  const uint8_t *b = p->buf;
1018 
1019  return b[0] == 'P' && b[1] == magic + '0';
1020 }
1021 
1022  static inline int pnm_probe(const AVProbeData *p)
1023 {
1024  const uint8_t *b = p->buf;
1025 
1026  while (b[2] == '\r')
1027  b++;
1028  if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
1029  return AVPROBE_SCORE_EXTENSION + 2;
1030  return 0;
1031 }
1032 
1033  static int pbm_probe(const AVProbeData *p)
1034 {
1035  return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
1036 }
1037 
1038  static int pfm_probe(const AVProbeData *p)
1039 {
1040  return pnm_magic_check(p, 'F' - '0') ||
1041  pnm_magic_check(p, 'f' - '0') ? pnm_probe(p) : 0;
1042 }
1043 
1044  static int phm_probe(const AVProbeData *p)
1045 {
1046  return pnm_magic_check(p, 'H' - '0') ||
1047  pnm_magic_check(p, 'h' - '0') ? pnm_probe(p) : 0;
1048 }
1049 
1050  static inline int pgmx_probe(const AVProbeData *p)
1051 {
1052  return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
1053 }
1054 
1055  static int pgm_probe(const AVProbeData *p)
1056 {
1057  int ret = pgmx_probe(p);
1058  return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1059 }
1060 
1061  static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
1062 {
1063  int ret = pgmx_probe(p);
1064  return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1065 }
1066 
1067  static int pgx_probe(const AVProbeData *p)
1068 {
1069  const uint8_t *b = p->buf;
1070  if (!memcmp(b, "PG ML ", 6))
1071  return AVPROBE_SCORE_EXTENSION + 1;
1072  return 0;
1073 }
1074 
1075  static int ppm_probe(const AVProbeData *p)
1076 {
1077  return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
1078 }
1079 
1080  static int pam_probe(const AVProbeData *p)
1081 {
1082  return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
1083 }
1084 
1085  static int hdr_probe(const AVProbeData *p)
1086 {
1087  if (!memcmp(p->buf, "#?RADIANCE\n", 11))
1088  return AVPROBE_SCORE_MAX;
1089  return 0;
1090 }
1091 
1092  static int xbm_probe(const AVProbeData *p)
1093 {
1094  if (!memcmp(p->buf, "/* XBM X10 format */", 20))
1095  return AVPROBE_SCORE_MAX;
1096 
1097  if (!memcmp(p->buf, "#define", 7))
1098  return AVPROBE_SCORE_MAX - 1;
1099  return 0;
1100 }
1101 
1102  static int xpm_probe(const AVProbeData *p)
1103 {
1104  const uint8_t *b = p->buf;
1105 
1106  if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
1107  return AVPROBE_SCORE_MAX - 1;
1108  return 0;
1109 }
1110 
1111  static int xwd_probe(const AVProbeData *p)
1112 {
1113  const uint8_t *b = p->buf;
1114  unsigned width, bpp, bpad, lsize;
1115 
1116  if ( p->buf_size < XWD_HEADER_SIZE
1117  || AV_RB32(b ) < XWD_HEADER_SIZE // header size
1118  || AV_RB32(b + 4) != XWD_VERSION // version
1119  || AV_RB32(b + 8) != XWD_Z_PIXMAP // format
1120  || AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
1121  || AV_RB32(b + 16) == 0 // width
1122  || AV_RB32(b + 20) == 0 // height
1123  || AV_RB32(b + 28) > 1 // byteorder
1124  || AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
1125  || AV_RB32(b + 36) > 1 // bitorder
1126  || AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
1127  || AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
1128  || AV_RB32(b + 68) > 256) // colours
1129  return 0;
1130 
1131  width = AV_RB32(b + 16);
1132  bpad = AV_RB32(b + 40);
1133  bpp = AV_RB32(b + 44);
1134  lsize = AV_RB32(b + 48);
1135  if (lsize < FFALIGN(width * bpp, bpad) >> 3)
1136  return 0;
1137 
1138  return AVPROBE_SCORE_MAX / 2 + 1;
1139 }
1140 
1141  static int gif_probe(const AVProbeData *p)
1142 {
1143  /* check magick */
1144  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
1145  return 0;
1146 
1147  /* width or height contains zero? */
1148  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
1149  return 0;
1150 
1151  return AVPROBE_SCORE_MAX - 1;
1152 }
1153 
1154  static int photocd_probe(const AVProbeData *p)
1155 {
1156  if (!memcmp(p->buf, "PCD_OPA", 7))
1157  return AVPROBE_SCORE_MAX - 1;
1158 
1159  if (p->buf_size < 0x807 || memcmp(p->buf + 0x800, "PCD_IPI", 7))
1160  return 0;
1161 
1162  return AVPROBE_SCORE_MAX - 1;
1163 }
1164 
1165  static int qoi_probe(const AVProbeData *p)
1166 {
1167  if (memcmp(p->buf, "qoif", 4))
1168  return 0;
1169 
1170  if (AV_RB32(p->buf + 4) == 0 || AV_RB32(p->buf + 8) == 0)
1171  return 0;
1172 
1173  if (p->buf[12] != 3 && p->buf[12] != 4)
1174  return 0;
1175 
1176  if (p->buf[13] > 1)
1177  return 0;
1178 
1179  return AVPROBE_SCORE_MAX - 1;
1180 }
1181 
1182  static int gem_probe(const AVProbeData *p)
1183 {
1184  const uint8_t *b = p->buf;
1185  if ( AV_RB16(b ) >= 1 && AV_RB16(b ) <= 3 &&
1186  AV_RB16(b + 2) >= 8 && AV_RB16(b + 2) <= 779 &&
1187  (AV_RB16(b + 4) > 0 && AV_RB16(b + 4) <= 32) && /* planes */
1188  (AV_RB16(b + 6) > 0 && AV_RB16(b + 6) <= 8) && /* pattern_size */
1189  AV_RB16(b + 8) &&
1190  AV_RB16(b + 10) &&
1191  AV_RB16(b + 12) &&
1192  AV_RB16(b + 14)) {
1193  if (AV_RN32(b + 16) == AV_RN32("STTT") ||
1194  AV_RN32(b + 16) == AV_RN32("TIMG") ||
1195  AV_RN32(b + 16) == AV_RN32("XIMG"))
1196  return AVPROBE_SCORE_EXTENSION + 1;
1197  return AVPROBE_SCORE_EXTENSION / 4;
1198  }
1199  return 0;
1200 }
1201 
1202  static int vbn_probe(const AVProbeData *p)
1203 {
1204  const uint8_t *b = p->buf;
1205  if (AV_RL32(b ) == VBN_MAGIC &&
1206  AV_RL32(b + 4) == VBN_MAJOR &&
1207  AV_RL32(b + 8) == VBN_MINOR)
1208  return AVPROBE_SCORE_MAX - 1;
1209  return 0;
1210 }
1211 
1212  #define IMAGEAUTO_DEMUXER_0(imgname, codecid)
1213  #define IMAGEAUTO_DEMUXER_1(imgname, codecid)\
1214 const FFInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
1215  .p.name = AV_STRINGIFY(imgname) "_pipe",\
1216  .p.long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
1217  .p.priv_class = &imagepipe_class,\
1218  .p.flags = AVFMT_GENERIC_INDEX,\
1219  .priv_data_size = sizeof(VideoDemuxData),\
1220  .read_probe = imgname ## _probe,\
1221  .read_header = ff_img_read_header,\
1222  .read_packet = ff_img_read_packet,\
1223  .raw_codec_id = codecid,\
1224 };
1225 
1226  #define IMAGEAUTO_DEMUXER_2(imgname, codecid, enabled) \
1227  IMAGEAUTO_DEMUXER_ ## enabled(imgname, codecid)
1228  #define IMAGEAUTO_DEMUXER_3(imgname, codecid, config) \
1229  IMAGEAUTO_DEMUXER_2(imgname, codecid, config)
1230  #define IMAGEAUTO_DEMUXER_EXT(imgname, codecid, uppercase_name) \
1231  IMAGEAUTO_DEMUXER_3(imgname, AV_CODEC_ID_ ## codecid, \
1232  CONFIG_IMAGE_ ## uppercase_name ## _PIPE_DEMUXER)
1233  #define IMAGEAUTO_DEMUXER(imgname, codecid) \
1234  IMAGEAUTO_DEMUXER_EXT(imgname, codecid, codecid)
1235 
1236 IMAGEAUTO_DEMUXER(bmp, BMP)
1237 IMAGEAUTO_DEMUXER(cri, CRI)
1238 IMAGEAUTO_DEMUXER(dds, DDS)
1239 IMAGEAUTO_DEMUXER(dpx, DPX)
1240 IMAGEAUTO_DEMUXER(exr, EXR)
1241 IMAGEAUTO_DEMUXER(gem, GEM)
1242 IMAGEAUTO_DEMUXER(gif, GIF)
1243 IMAGEAUTO_DEMUXER_EXT(hdr, RADIANCE_HDR, HDR)
1244 IMAGEAUTO_DEMUXER_EXT(j2k, JPEG2000, J2K)
1245 IMAGEAUTO_DEMUXER_EXT(jpeg, MJPEG, JPEG)
1246 IMAGEAUTO_DEMUXER(jpegls, JPEGLS)
1247 IMAGEAUTO_DEMUXER(jpegxl, JPEGXL)
1248 IMAGEAUTO_DEMUXER(pam, PAM)
1249 IMAGEAUTO_DEMUXER(pbm, PBM)
1250 IMAGEAUTO_DEMUXER(pcx, PCX)
1251 IMAGEAUTO_DEMUXER(pfm, PFM)
1252 IMAGEAUTO_DEMUXER(pgm, PGM)
1253 IMAGEAUTO_DEMUXER(pgmyuv, PGMYUV)
1254 IMAGEAUTO_DEMUXER(pgx, PGX)
1255 IMAGEAUTO_DEMUXER(phm, PHM)
1256 IMAGEAUTO_DEMUXER(photocd, PHOTOCD)
1257 IMAGEAUTO_DEMUXER(pictor, PICTOR)
1258 IMAGEAUTO_DEMUXER(png, PNG)
1259 IMAGEAUTO_DEMUXER(ppm, PPM)
1260 IMAGEAUTO_DEMUXER(psd, PSD)
1261 IMAGEAUTO_DEMUXER(qdraw, QDRAW)
1262 IMAGEAUTO_DEMUXER(qoi, QOI)
1263 IMAGEAUTO_DEMUXER(sgi, SGI)
1264 IMAGEAUTO_DEMUXER(sunrast, SUNRAST)
1265 IMAGEAUTO_DEMUXER(svg, SVG)
1266 IMAGEAUTO_DEMUXER(tiff, TIFF)
1267 IMAGEAUTO_DEMUXER(vbn, VBN)
1268 IMAGEAUTO_DEMUXER(webp, WEBP)
1269 IMAGEAUTO_DEMUXER(xbm, XBM)
1270 IMAGEAUTO_DEMUXER(xpm, XPM)
1271 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:1080
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:699
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:1015
VBN_MINOR
#define VBN_MINOR
Definition: vbn.h:31
OFFSET
#define OFFSET(x)
Definition: img2dec.c:613
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
w
uint8_t w
Definition: llviddspenc.c:38
webp_probe
static int webp_probe(const AVProbeData *p)
Definition: img2dec.c:1005
ff_img_read_header
int ff_img_read_header(AVFormatContext *s1)
Definition: img2dec.c:189
AVPacket::data
uint8_t * data
Definition: packet.h:522
dds_probe
static int dds_probe(const AVProbeData *p)
Definition: img2dec.c:710
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
imagepipe_class
static const AVClass imagepipe_class
Definition: img2dec.c:663
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1414
psd_probe
static int psd_probe(const AVProbeData *p)
Definition: img2dec.c:921
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:115
qoi_probe
static int qoi_probe(const AVProbeData *p)
Definition: img2dec.c:1165
phm_probe
static int phm_probe(const AVProbeData *p)
Definition: img2dec.c:1044
pcx_probe
static int pcx_probe(const AVProbeData *p)
Definition: img2dec.c:866
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:593
av_popcount
#define av_popcount
Definition: common.h:152
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:353
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:322
os_support.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
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:126
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:853
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:197
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
APP4
@ APP4
Definition: mjpeg.h:83
fail
#define fail()
Definition: checkasm.h:179
svg_probe
static int svg_probe(const AVProbeData *p)
Definition: img2dec.c:970
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:120
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:1233
pgmx_probe
static int pgmx_probe(const AVProbeData *p)
Definition: img2dec.c:1050
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:582
img2pipe_options
static const AVOption img2pipe_options[]
Definition: img2dec.c:659
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
av_probe_input_format3
const AVInputFormat * av_probe_input_format3(const AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:155
PT_NONE
@ PT_NONE
Definition: img2.h:37
loop
static int loop
Definition: ffplay.c:338
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:903
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:548
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
COM
@ COM
Definition: mjpeg.h:111
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
SOF5
@ SOF5
Definition: mjpeg.h:44
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:98
APP12
@ APP12
Definition: mjpeg.h:91
img_read_probe
static int img_read_probe(const AVProbeData *p)
Definition: img2dec.c:170
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
APP3
@ APP3
Definition: mjpeg.h:82
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
PT_DEFAULT
@ PT_DEFAULT
Definition: img2.h:38
frame_size
int frame_size
Definition: mxfenc.c:2422
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
s1
#define s1
Definition: regdef.h:38
AVProbeData::filename
const char * filename
Definition: avformat.h:452
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:42
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:681
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:1061
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:748
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:1102
APP5
@ APP5
Definition: mjpeg.h:84
if
if(ret)
Definition: filter_design.txt:179
xwd.h
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
gem_probe
static int gem_probe(const AVProbeData *p)
Definition: img2dec.c:1182
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_img_options
const AVOption ff_img_options[]
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:60
APP9
@ APP9
Definition: mjpeg.h:88
xwd_probe
static int xwd_probe(const AVProbeData *p)
Definition: img2dec.c:1111
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1206
photocd_probe
static int photocd_probe(const AVProbeData *p)
Definition: img2dec.c:1154
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:362
parseutils.h
VBN_MAJOR
#define VBN_MAJOR
Definition: vbn.h:30
xbm_probe
static int xbm_probe(const AVProbeData *p)
Definition: img2dec.c:1092
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
state
static struct @385 state
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:848
index
int index
Definition: gxfenc.c:89
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
DEC
#define DEC
Definition: img2dec.c:614
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:961
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
vbn_probe
static int vbn_probe(const AVProbeData *p)
Definition: img2dec.c:1202
AVPacket::size
int size
Definition: packet.h:523
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:106
XWD_HEADER_SIZE
#define XWD_HEADER_SIZE
Definition: xwd.h:27
gif.h
size
int size
Definition: twinvq_data.h:10344
pfm_probe
static int pfm_probe(const AVProbeData *p)
Definition: img2dec.c:1038
dpx_probe
static int dpx_probe(const AVProbeData *p)
Definition: img2dec.c:721
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:1230
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:663
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:944
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:603
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2557
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: avpacket.c:312
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
DQT
@ DQT
Definition: mjpeg.h:73
APP6
@ APP6
Definition: mjpeg.h:85
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:173
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
gif_probe
static int gif_probe(const AVProbeData *p)
Definition: img2dec.c:1141
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:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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:1055
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:949
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
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:1067
SOF2
@ SOF2
Definition: mjpeg.h:41
pnm_probe
static int pnm_probe(const AVProbeData *p)
Definition: img2dec.c:1022
avformat.h
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: img2dec.c:615
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:2894
ff_image2pipe_demuxer
const FFInputFormat ff_image2pipe_demuxer
jpeg_probe
static int jpeg_probe(const AVProbeData *p)
Definition: img2dec.c:758
subtitles.h
png_probe
static int png_probe(const AVProbeData *p)
Definition: img2dec.c:912
jpegls_probe
static int jpegls_probe(const AVProbeData *p)
Definition: img2dec.c:839
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:1085
APP2
@ APP2
Definition: mjpeg.h:81
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:133
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
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:1075
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:611
exr_probe
static int exr_probe(const AVProbeData *p)
Definition: img2dec.c:739
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVPacket::stream_index
int stream_index
Definition: packet.h:524
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:317
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:1033
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:270
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
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:1147
SOI
@ SOI
Definition: mjpeg.h:70
AVCodecParameters::format
int format
Definition: codec_par.h:92
SOF1
@ SOF1
Definition: mjpeg.h:40
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
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:542
tiff_probe
static int tiff_probe(const AVProbeData *p)
Definition: img2dec.c:995
FFInputFormat
Definition: demux.h:37
XWD_VERSION
#define XWD_VERSION
Definition: xwd.h:26
d
d
Definition: ffmpeg_filter.c:409
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:2038
SOF7
@ SOF7
Definition: mjpeg.h:46
ff_subtitles_next_line
static av_always_inline int ff_subtitles_next_line(const char *ptr)
Get the number of characters to increment to jump to the next line, or to the end of the string.
Definition: subtitles.h:205
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
avstring.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:61
SOF6
@ SOF6
Definition: mjpeg.h:45
qdraw_probe
static int qdraw_probe(const AVProbeData *p)
Definition: img2dec.c:887
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:153
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:243
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:345
Generated on Thu Sep 26 2024 23:15:46 for FFmpeg by   doxygen 1.8.17

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