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