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 #define _DEFAULT_SOURCE
24 #define _BSD_SOURCE
25 #include <sys/stat.h>
26 #include "libavutil/avstring.h"
27 #include "libavutil/log.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/parseutils.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavcodec/gif.h"
33 #include "avformat.h"
34 #include "avio_internal.h"
35 #include "internal.h"
36 #include "img2.h"
37 #include "libavcodec/mjpeg.h"
38 #include "libavcodec/xwd.h"
39 #include "subtitles.h"
40 
41 #if HAVE_GLOB
42 /* Locally define as 0 (bitwise-OR no-op) any missing glob options that
43  are non-posix glibc/bsd extensions. */
44 #ifndef GLOB_NOMAGIC
45 #define GLOB_NOMAGIC 0
46 #endif
47 #ifndef GLOB_BRACE
48 #define GLOB_BRACE 0
49 #endif
50 
51 #endif /* HAVE_GLOB */
52 
53 static const int sizes[][2] = {
54  { 640, 480 },
55  { 720, 480 },
56  { 720, 576 },
57  { 352, 288 },
58  { 352, 240 },
59  { 160, 128 },
60  { 512, 384 },
61  { 640, 352 },
62  { 640, 240 },
63 };
64 
65 static int infer_size(int *width_ptr, int *height_ptr, int size)
66 {
67  int i;
68 
69  for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
70  if ((sizes[i][0] * sizes[i][1]) == size) {
71  *width_ptr = sizes[i][0];
72  *height_ptr = sizes[i][1];
73  return 0;
74  }
75  }
76 
77  return -1;
78 }
79 
80 static int is_glob(const char *path)
81 {
82 #if HAVE_GLOB
83  size_t span = 0;
84  const char *p = path;
85 
86  while (p = strchr(p, '%')) {
87  if (*(++p) == '%') {
88  ++p;
89  continue;
90  }
91  if (span = strspn(p, "*?[]{}"))
92  break;
93  }
94  /* Did we hit a glob char or get to the end? */
95  return span != 0;
96 #else
97  return 0;
98 #endif
99 }
100 
101 /**
102  * Get index range of image files matched by path.
103  *
104  * @param pfirst_index pointer to index updated with the first number in the range
105  * @param plast_index pointer to index updated with the last number in the range
106  * @param path path which has to be matched by the image files in the range
107  * @param start_index minimum accepted value for the first index in the range
108  * @return -1 if no image file could be found
109  */
110 static int find_image_range(AVIOContext *pb, int *pfirst_index, int *plast_index,
111  const char *path, int start_index, int start_index_range)
112 {
113  char buf[1024];
114  int range, last_index, range1, first_index;
115 
116  /* find the first image */
117  for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
118  if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
119  *pfirst_index =
120  *plast_index = 1;
121  if (pb || avio_check(buf, AVIO_FLAG_READ) > 0)
122  return 0;
123  return -1;
124  }
125  if (avio_check(buf, AVIO_FLAG_READ) > 0)
126  break;
127  }
128  if (first_index == start_index + start_index_range)
129  goto fail;
130 
131  /* find the last image */
132  last_index = first_index;
133  for (;;) {
134  range = 0;
135  for (;;) {
136  if (!range)
137  range1 = 1;
138  else
139  range1 = 2 * range;
140  if (av_get_frame_filename(buf, sizeof(buf), path,
141  last_index + range1) < 0)
142  goto fail;
143  if (avio_check(buf, AVIO_FLAG_READ) <= 0)
144  break;
145  range = range1;
146  /* just in case... */
147  if (range >= (1 << 30))
148  goto fail;
149  }
150  /* we are sure than image last_index + range exists */
151  if (!range)
152  break;
153  last_index += range;
154  }
155  *pfirst_index = first_index;
156  *plast_index = last_index;
157  return 0;
158 
159 fail:
160  return -1;
161 }
162 
163 static int img_read_probe(const AVProbeData *p)
164 {
165  if (p->filename && ff_guess_image2_codec(p->filename)) {
167  return AVPROBE_SCORE_MAX;
168  else if (is_glob(p->filename))
169  return AVPROBE_SCORE_MAX;
170  else if (p->filename[strcspn(p->filename, "*?{")]) // probably PT_GLOB
171  return AVPROBE_SCORE_EXTENSION + 2; // score chosen to be a tad above the image pipes
172  else if (p->buf_size == 0)
173  return 0;
174  else if (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif"))
175  return 5;
176  else
178  }
179  return 0;
180 }
181 
183 {
184  VideoDemuxData *s = s1->priv_data;
185  int first_index = 1, last_index = 1;
186  AVStream *st;
188 
189  s1->ctx_flags |= AVFMTCTX_NOHEADER;
190 
191  st = avformat_new_stream(s1, NULL);
192  if (!st) {
193  return AVERROR(ENOMEM);
194  }
195 
196  if (s->pixel_format &&
197  (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) {
198  av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n",
199  s->pixel_format);
200  return AVERROR(EINVAL);
201  }
202 
203  av_strlcpy(s->path, s1->url, sizeof(s->path));
204  s->img_number = 0;
205  s->img_count = 0;
206 
207  /* find format */
208  if (s1->iformat->flags & AVFMT_NOFILE)
209  s->is_pipe = 0;
210  else {
211  s->is_pipe = 1;
213  }
214 
215  if (s->ts_from_file == 2) {
216 #if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
217  av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n");
218  return AVERROR(ENOSYS);
219 #endif
220  avpriv_set_pts_info(st, 64, 1, 1000000000);
221  } else if (s->ts_from_file)
222  avpriv_set_pts_info(st, 64, 1, 1);
223  else
224  avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
225 
226  if (s->width && s->height) {
227  st->codecpar->width = s->width;
228  st->codecpar->height = s->height;
229  }
230 
231  if (!s->is_pipe) {
232  if (s->pattern_type == PT_DEFAULT) {
233  if (s1->pb) {
234  s->pattern_type = PT_NONE;
235  } else
236  s->pattern_type = PT_GLOB_SEQUENCE;
237  }
238 
239  if (s->pattern_type == PT_GLOB_SEQUENCE) {
240  s->use_glob = is_glob(s->path);
241  if (s->use_glob) {
242 #if HAVE_GLOB
243  char *p = s->path, *q, *dup;
244  int gerr;
245 #endif
246 
247  av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
248  "use pattern_type 'glob' instead\n");
249 #if HAVE_GLOB
250  dup = q = av_strdup(p);
251  while (*q) {
252  /* Do we have room for the next char and a \ insertion? */
253  if ((p - s->path) >= (sizeof(s->path) - 2))
254  break;
255  if (*q == '%' && strspn(q + 1, "%*?[]{}"))
256  ++q;
257  else if (strspn(q, "\\*?[]{}"))
258  *p++ = '\\';
259  *p++ = *q++;
260  }
261  *p = 0;
262  av_free(dup);
263 
264  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
265  if (gerr != 0) {
266  return AVERROR(ENOENT);
267  }
268  first_index = 0;
269  last_index = s->globstate.gl_pathc - 1;
270 #endif
271  }
272  }
273  if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
274  if (find_image_range(s1->pb, &first_index, &last_index, s->path,
275  s->start_number, s->start_number_range) < 0) {
277  "Could find no file with path '%s' and index in the range %d-%d\n",
278  s->path, s->start_number, s->start_number + s->start_number_range - 1);
279  return AVERROR(ENOENT);
280  }
281  } else if (s->pattern_type == PT_GLOB) {
282 #if HAVE_GLOB
283  int gerr;
284  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
285  if (gerr != 0) {
286  return AVERROR(ENOENT);
287  }
288  first_index = 0;
289  last_index = s->globstate.gl_pathc - 1;
290  s->use_glob = 1;
291 #else
293  "Pattern type 'glob' was selected but globbing "
294  "is not supported by this libavformat build\n");
295  return AVERROR(ENOSYS);
296 #endif
297  } else if (s->pattern_type != PT_GLOB_SEQUENCE && s->pattern_type != PT_NONE) {
299  "Unknown value '%d' for pattern_type option\n", s->pattern_type);
300  return AVERROR(EINVAL);
301  }
302  s->img_first = first_index;
303  s->img_last = last_index;
304  s->img_number = first_index;
305  /* compute duration */
306  if (!s->ts_from_file) {
307  st->start_time = 0;
308  st->duration = last_index - first_index + 1;
309  }
310  }
311 
312  if (s1->video_codec_id) {
314  st->codecpar->codec_id = s1->video_codec_id;
315  } else if (s1->audio_codec_id) {
317  st->codecpar->codec_id = s1->audio_codec_id;
318  } else if (s1->iformat->raw_codec_id) {
320  st->codecpar->codec_id = s1->iformat->raw_codec_id;
321  } else {
322  const char *str = strrchr(s->path, '.');
323  s->split_planes = str && !av_strcasecmp(str + 1, "y");
325  if (s1->pb) {
326  int probe_buffer_size = 2048;
327  uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE);
328  const AVInputFormat *fmt = NULL;
329  void *fmt_iter = NULL;
330  AVProbeData pd = { 0 };
331 
332  if (!probe_buffer)
333  return AVERROR(ENOMEM);
334 
335  probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size);
336  if (probe_buffer_size < 0) {
337  av_free(probe_buffer);
338  return probe_buffer_size;
339  }
340  memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE);
341 
342  pd.buf = probe_buffer;
343  pd.buf_size = probe_buffer_size;
344  pd.filename = s1->url;
345 
346  while ((fmt = av_demuxer_iterate(&fmt_iter))) {
347  if (fmt->read_header != ff_img_read_header ||
348  !fmt->read_probe ||
349  (fmt->flags & AVFMT_NOFILE) ||
350  !fmt->raw_codec_id)
351  continue;
352  if (fmt->read_probe(&pd) > 0) {
353  st->codecpar->codec_id = fmt->raw_codec_id;
354  break;
355  }
356  }
357  if (s1->flags & AVFMT_FLAG_CUSTOM_IO) {
358  avio_seek(s1->pb, 0, SEEK_SET);
359  av_freep(&probe_buffer);
360  } else
361  ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size);
362  }
363  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
365  if (st->codecpar->codec_id == AV_CODEC_ID_LJPEG)
367  if (st->codecpar->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
369  }
370  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
372  st->codecpar->format = pix_fmt;
373 
374  return 0;
375 }
376 
378 {
379  VideoDemuxData *s = s1->priv_data;
380  char filename_bytes[1024];
381  char *filename = filename_bytes;
382  int i, res;
383  int size[3] = { 0 }, ret[3] = { 0 };
384  AVIOContext *f[3] = { NULL };
385  AVCodecParameters *par = s1->streams[0]->codecpar;
386 
387  if (!s->is_pipe) {
388  /* loop over input */
389  if (s->loop && s->img_number > s->img_last) {
390  s->img_number = s->img_first;
391  }
392  if (s->img_number > s->img_last)
393  return AVERROR_EOF;
394  if (s->pattern_type == PT_NONE) {
395  av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
396  } else if (s->use_glob) {
397 #if HAVE_GLOB
398  filename = s->globstate.gl_pathv[s->img_number];
399 #endif
400  } else {
401  if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
402  s->path,
403  s->img_number) < 0 && s->img_number > 1)
404  return AVERROR(EIO);
405  }
406  for (i = 0; i < 3; i++) {
407  if (s1->pb &&
408  !strcmp(filename_bytes, s->path) &&
409  !s->loop &&
410  !s->split_planes) {
411  f[i] = s1->pb;
412  } else if (s1->io_open(s1, &f[i], filename, AVIO_FLAG_READ, NULL) < 0) {
413  if (i >= 1)
414  break;
415  av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
416  filename);
417  return AVERROR(EIO);
418  }
419  size[i] = avio_size(f[i]);
420 
421  if (!s->split_planes)
422  break;
423  filename[strlen(filename) - 1] = 'U' + i;
424  }
425 
426  if (par->codec_id == AV_CODEC_ID_NONE) {
427  AVProbeData pd = { 0 };
428  const AVInputFormat *ifmt;
430  int ret;
431  int score = 0;
432 
434  if (ret < 0)
435  return ret;
436  memset(header + ret, 0, sizeof(header) - ret);
437  avio_skip(f[0], -ret);
438  pd.buf = header;
439  pd.buf_size = ret;
440  pd.filename = filename;
441 
442  ifmt = av_probe_input_format3(&pd, 1, &score);
443  if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
444  par->codec_id = ifmt->raw_codec_id;
445  }
446 
447  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
448  infer_size(&par->width, &par->height, size[0]);
449  } else {
450  f[0] = s1->pb;
451  if (avio_feof(f[0]) && s->loop && s->is_pipe)
452  avio_seek(f[0], 0, SEEK_SET);
453  if (avio_feof(f[0]))
454  return AVERROR_EOF;
455  if (s->frame_size > 0) {
456  size[0] = s->frame_size;
457  } else if (!s1->streams[0]->parser) {
458  size[0] = avio_size(s1->pb);
459  } else {
460  size[0] = 4096;
461  }
462  }
463 
464  res = av_new_packet(pkt, size[0] + size[1] + size[2]);
465  if (res < 0) {
466  goto fail;
467  }
468  pkt->stream_index = 0;
470  if (s->ts_from_file) {
471  struct stat img_stat;
472  if (stat(filename, &img_stat)) {
473  res = AVERROR(EIO);
474  goto fail;
475  }
476  pkt->pts = (int64_t)img_stat.st_mtime;
477 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
478  if (s->ts_from_file == 2)
479  pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
480 #endif
481  av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
482  } else if (!s->is_pipe) {
483  pkt->pts = s->pts;
484  }
485 
486  if (s->is_pipe)
487  pkt->pos = avio_tell(f[0]);
488 
489  pkt->size = 0;
490  for (i = 0; i < 3; i++) {
491  if (f[i]) {
492  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
493  if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
494  if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
495  pkt->pos = 0;
496  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
497  }
498  }
499  if (!s->is_pipe && f[i] != s1->pb)
500  ff_format_io_close(s1, &f[i]);
501  if (ret[i] > 0)
502  pkt->size += ret[i];
503  }
504  }
505 
506  if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
508  if (ret[0] < 0) {
509  res = ret[0];
510  } else if (ret[1] < 0) {
511  res = ret[1];
512  } else if (ret[2] < 0) {
513  res = ret[2];
514  } else {
515  res = AVERROR_EOF;
516  }
517  goto fail;
518  } else {
519  s->img_count++;
520  s->img_number++;
521  s->pts++;
522  return 0;
523  }
524 
525 fail:
526  if (!s->is_pipe) {
527  for (i = 0; i < 3; i++) {
528  if (f[i] != s1->pb)
529  ff_format_io_close(s1, &f[i]);
530  }
531  }
532  return res;
533 }
534 
535 static int img_read_close(struct AVFormatContext* s1)
536 {
537 #if HAVE_GLOB
538  VideoDemuxData *s = s1->priv_data;
539  if (s->use_glob) {
540  globfree(&s->globstate);
541  }
542 #endif
543  return 0;
544 }
545 
546 static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
547 {
548  VideoDemuxData *s1 = s->priv_data;
549  AVStream *st = s->streams[0];
550 
551  if (s1->ts_from_file) {
552  int index = av_index_search_timestamp(st, timestamp, flags);
553  if(index < 0)
554  return -1;
555  s1->img_number = st->index_entries[index].pos;
556  return 0;
557  }
558 
559  if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
560  return -1;
561  s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
562  s1->pts = timestamp;
563  return 0;
564 }
565 
566 #define OFFSET(x) offsetof(VideoDemuxData, x)
567 #define DEC AV_OPT_FLAG_DECODING_PARAM
568 #define COMMON_OPTIONS \
569  { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
570  { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
571  { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
572  { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
573  { NULL },
574 
575 #if CONFIG_IMAGE2_DEMUXER
576 const AVOption ff_img_options[] = {
577  { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, "pattern_type"},
578  { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
579  { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" },
580  { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
581  { "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
582  { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
583  { "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 },
584  { "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" },
585  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, "ts_type" },
586  { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, "ts_type" },
587  { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, "ts_type" },
589 };
590 
591 static const AVClass img2_class = {
592  .class_name = "image2 demuxer",
593  .item_name = av_default_item_name,
594  .option = ff_img_options,
595  .version = LIBAVUTIL_VERSION_INT,
596 };
598  .name = "image2",
599  .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
600  .priv_data_size = sizeof(VideoDemuxData),
606  .flags = AVFMT_NOFILE,
607  .priv_class = &img2_class,
608 };
609 #endif
610 
612  { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
614 };
615 
616 #if CONFIG_IMAGE2PIPE_DEMUXER
617 static const AVClass img2pipe_class = {
618  .class_name = "image2pipe demuxer",
619  .item_name = av_default_item_name,
620  .option = ff_img2pipe_options,
621  .version = LIBAVUTIL_VERSION_INT,
622 };
624  .name = "image2pipe",
625  .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
626  .priv_data_size = sizeof(VideoDemuxData),
629  .priv_class = &img2pipe_class,
630 };
631 #endif
632 
633 static int bmp_probe(const AVProbeData *p)
634 {
635  const uint8_t *b = p->buf;
636  int ihsize;
637 
638  if (AV_RB16(b) != 0x424d)
639  return 0;
640 
641  ihsize = AV_RL32(b+14);
642  if (ihsize < 12 || ihsize > 255)
643  return 0;
644 
645  if (!AV_RN32(b + 6)) {
646  return AVPROBE_SCORE_EXTENSION + 1;
647  }
648  return AVPROBE_SCORE_EXTENSION / 4;
649 }
650 
651 static int dds_probe(const AVProbeData *p)
652 {
653  const uint8_t *b = p->buf;
654 
655  if ( AV_RB64(b) == 0x444453207c000000
656  && AV_RL32(b + 8)
657  && AV_RL32(b + 12))
658  return AVPROBE_SCORE_MAX - 1;
659  return 0;
660 }
661 
662 static int dpx_probe(const AVProbeData *p)
663 {
664  const uint8_t *b = p->buf;
665  int w, h;
666  int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
667 
668  if (p->buf_size < 0x304+8)
669  return 0;
670  w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
671  h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
672  if (w <= 0 || h <= 0)
673  return 0;
674 
675  if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
676  return AVPROBE_SCORE_EXTENSION + 1;
677  return 0;
678 }
679 
680 static int exr_probe(const AVProbeData *p)
681 {
682  const uint8_t *b = p->buf;
683 
684  if (AV_RL32(b) == 20000630)
685  return AVPROBE_SCORE_EXTENSION + 1;
686  return 0;
687 }
688 
689 static int j2k_probe(const AVProbeData *p)
690 {
691  const uint8_t *b = p->buf;
692 
693  if (AV_RB64(b) == 0x0000000c6a502020 ||
694  AV_RB32(b) == 0xff4fff51)
695  return AVPROBE_SCORE_EXTENSION + 1;
696  return 0;
697 }
698 
699 static int jpeg_probe(const AVProbeData *p)
700 {
701  const uint8_t *b = p->buf;
702  int i, state = SOI;
703 
704  if (AV_RB16(b) != 0xFFD8 ||
705  AV_RB32(b) == 0xFFD8FFF7)
706  return 0;
707 
708  b += 2;
709  for (i = 0; i < p->buf_size - 3; i++) {
710  int c;
711  if (b[i] != 0xFF)
712  continue;
713  c = b[i + 1];
714  switch (c) {
715  case SOI:
716  return 0;
717  case SOF0:
718  case SOF1:
719  case SOF2:
720  case SOF3:
721  case SOF5:
722  case SOF6:
723  case SOF7:
724  i += AV_RB16(&b[i + 2]) + 1;
725  if (state != SOI)
726  return 0;
727  state = SOF0;
728  break;
729  case SOS:
730  i += AV_RB16(&b[i + 2]) + 1;
731  if (state != SOF0 && state != SOS)
732  return 0;
733  state = SOS;
734  break;
735  case EOI:
736  if (state != SOS)
737  return 0;
738  state = EOI;
739  break;
740  case DQT:
741  case APP0:
742  case APP1:
743  case APP2:
744  case APP3:
745  case APP4:
746  case APP5:
747  case APP6:
748  case APP7:
749  case APP8:
750  case APP9:
751  case APP10:
752  case APP11:
753  case APP12:
754  case APP13:
755  case APP14:
756  case APP15:
757  case COM:
758  i += AV_RB16(&b[i + 2]) + 1;
759  break;
760  default:
761  if ( (c > TEM && c < SOF0)
762  || c == JPG)
763  return 0;
764  }
765  }
766 
767  if (state == EOI)
768  return AVPROBE_SCORE_EXTENSION + 1;
769  if (state == SOS)
770  return AVPROBE_SCORE_EXTENSION / 2;
771  return AVPROBE_SCORE_EXTENSION / 8;
772 }
773 
774 static int jpegls_probe(const AVProbeData *p)
775 {
776  const uint8_t *b = p->buf;
777 
778  if (AV_RB32(b) == 0xffd8fff7)
779  return AVPROBE_SCORE_EXTENSION + 1;
780  return 0;
781 }
782 
783 static int pcx_probe(const AVProbeData *p)
784 {
785  const uint8_t *b = p->buf;
786 
787  if ( p->buf_size < 128
788  || b[0] != 10
789  || b[1] > 5
790  || b[2] > 1
791  || av_popcount(b[3]) != 1 || b[3] > 8
792  || AV_RL16(&b[4]) > AV_RL16(&b[8])
793  || AV_RL16(&b[6]) > AV_RL16(&b[10])
794  || b[64])
795  return 0;
796  b += 73;
797  while (++b < p->buf + 128)
798  if (*b)
799  return AVPROBE_SCORE_EXTENSION / 4;
800 
801  return AVPROBE_SCORE_EXTENSION + 1;
802 }
803 
804 static int qdraw_probe(const AVProbeData *p)
805 {
806  const uint8_t *b = p->buf;
807 
808  if ( p->buf_size >= 528
809  && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
810  && AV_RB16(b + 520)
811  && AV_RB16(b + 518))
812  return AVPROBE_SCORE_MAX * 3 / 4;
813  if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
814  && AV_RB16(b + 8)
815  && AV_RB16(b + 6))
816  return AVPROBE_SCORE_EXTENSION / 4;
817  return 0;
818 }
819 
820 static int pictor_probe(const AVProbeData *p)
821 {
822  const uint8_t *b = p->buf;
823 
824  if (AV_RL16(b) == 0x1234)
825  return AVPROBE_SCORE_EXTENSION / 4;
826  return 0;
827 }
828 
829 static int png_probe(const AVProbeData *p)
830 {
831  const uint8_t *b = p->buf;
832 
833  if (AV_RB64(b) == 0x89504e470d0a1a0a)
834  return AVPROBE_SCORE_MAX - 1;
835  return 0;
836 }
837 
838 static int psd_probe(const AVProbeData *p)
839 {
840  const uint8_t *b = p->buf;
841  int ret = 0;
842  uint16_t color_mode;
843 
844  if (AV_RL32(b) == MKTAG('8','B','P','S')) {
845  ret += 1;
846  } else {
847  return 0;
848  }
849 
850  if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
851  ret += 1;
852  } else {
853  return 0;
854  }
855 
856  if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
857  ret += 1;
858 
859  color_mode = AV_RB16(b+24);
860  if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
861  ret += 1;
862 
863  return AVPROBE_SCORE_EXTENSION + ret;
864 }
865 
866 static int sgi_probe(const AVProbeData *p)
867 {
868  const uint8_t *b = p->buf;
869 
870  if (AV_RB16(b) == 474 &&
871  (b[2] & ~1) == 0 &&
872  (b[3] & ~3) == 0 && b[3] &&
873  (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
874  return AVPROBE_SCORE_EXTENSION + 1;
875  return 0;
876 }
877 
878 static int sunrast_probe(const AVProbeData *p)
879 {
880  const uint8_t *b = p->buf;
881 
882  if (AV_RB32(b) == 0x59a66a95)
883  return AVPROBE_SCORE_EXTENSION + 1;
884  return 0;
885 }
886 
887 static int svg_probe(const AVProbeData *p)
888 {
889  const uint8_t *b = p->buf;
890  const uint8_t *end = p->buf + p->buf_size;
891 
892  if (memcmp(p->buf, "<?xml", 5))
893  return 0;
894  while (b < end) {
895  int inc = ff_subtitles_next_line(b);
896  if (!inc)
897  break;
898  b += inc;
899  if (b >= end - 4)
900  return 0;
901  if (!memcmp(b, "<svg", 4))
902  return AVPROBE_SCORE_EXTENSION + 1;
903  }
904  return 0;
905 }
906 
907 static int tiff_probe(const AVProbeData *p)
908 {
909  const uint8_t *b = p->buf;
910 
911  if (AV_RB32(b) == 0x49492a00 ||
912  AV_RB32(b) == 0x4D4D002a)
913  return AVPROBE_SCORE_EXTENSION + 1;
914  return 0;
915 }
916 
917 static int webp_probe(const AVProbeData *p)
918 {
919  const uint8_t *b = p->buf;
920 
921  if (AV_RB32(b) == 0x52494646 &&
922  AV_RB32(b + 8) == 0x57454250)
923  return AVPROBE_SCORE_MAX - 1;
924  return 0;
925 }
926 
927 static int pnm_magic_check(const AVProbeData *p, int magic)
928 {
929  const uint8_t *b = p->buf;
930 
931  return b[0] == 'P' && b[1] == magic + '0';
932 }
933 
934 static inline int pnm_probe(const AVProbeData *p)
935 {
936  const uint8_t *b = p->buf;
937 
938  while (b[2] == '\r')
939  b++;
940  if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
941  return AVPROBE_SCORE_EXTENSION + 2;
942  return 0;
943 }
944 
945 static int pbm_probe(const AVProbeData *p)
946 {
947  return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
948 }
949 
950 static inline int pgmx_probe(const AVProbeData *p)
951 {
952  return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
953 }
954 
955 static int pgm_probe(const AVProbeData *p)
956 {
957  int ret = pgmx_probe(p);
958  return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
959 }
960 
961 static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
962 {
963  int ret = pgmx_probe(p);
964  return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
965 }
966 
967 static int ppm_probe(const AVProbeData *p)
968 {
969  return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
970 }
971 
972 static int pam_probe(const AVProbeData *p)
973 {
974  return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
975 }
976 
977 static int xpm_probe(const AVProbeData *p)
978 {
979  const uint8_t *b = p->buf;
980 
981  if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
982  return AVPROBE_SCORE_MAX - 1;
983  return 0;
984 }
985 
986 static int xwd_probe(const AVProbeData *p)
987 {
988  const uint8_t *b = p->buf;
989  unsigned width, bpp, bpad, lsize;
990 
991  if ( p->buf_size < XWD_HEADER_SIZE
992  || AV_RB32(b ) < XWD_HEADER_SIZE // header size
993  || AV_RB32(b + 4) != XWD_VERSION // version
994  || AV_RB32(b + 8) != XWD_Z_PIXMAP // format
995  || AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
996  || AV_RB32(b + 16) == 0 // width
997  || AV_RB32(b + 20) == 0 // height
998  || AV_RB32(b + 28) > 1 // byteorder
999  || AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
1000  || AV_RB32(b + 36) > 1 // bitorder
1001  || AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
1002  || AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
1003  || AV_RB32(b + 68) > 256) // colours
1004  return 0;
1005 
1006  width = AV_RB32(b + 16);
1007  bpad = AV_RB32(b + 40);
1008  bpp = AV_RB32(b + 44);
1009  lsize = AV_RB32(b + 48);
1010  if (lsize < FFALIGN(width * bpp, bpad) >> 3)
1011  return 0;
1012 
1013  return AVPROBE_SCORE_MAX / 2 + 1;
1014 }
1015 
1016 static int gif_probe(const AVProbeData *p)
1017 {
1018  /* check magick */
1019  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
1020  return 0;
1021 
1022  /* width or height contains zero? */
1023  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
1024  return 0;
1025 
1026  return AVPROBE_SCORE_MAX - 1;
1027 }
1028 
1029 #define IMAGEAUTO_DEMUXER(imgname, codecid)\
1030 static const AVClass imgname ## _class = {\
1031  .class_name = AV_STRINGIFY(imgname) " demuxer",\
1032  .item_name = av_default_item_name,\
1033  .option = ff_img2pipe_options,\
1034  .version = LIBAVUTIL_VERSION_INT,\
1035 };\
1036 AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
1037  .name = AV_STRINGIFY(imgname) "_pipe",\
1038  .long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
1039  .priv_data_size = sizeof(VideoDemuxData),\
1040  .read_probe = imgname ## _probe,\
1041  .read_header = ff_img_read_header,\
1042  .read_packet = ff_img_read_packet,\
1043  .priv_class = & imgname ## _class,\
1044  .flags = AVFMT_GENERIC_INDEX, \
1045  .raw_codec_id = codecid,\
1046 };
1047 
AVStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1099
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_CODEC_ID_DPX
@ AV_CODEC_ID_DPX
Definition: avcodec.h:346
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: utils.c:4480
AV_CODEC_ID_PBM
@ AV_CODEC_ID_PBM
Definition: avcodec.h:281
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
pam_probe
static int pam_probe(const AVProbeData *p)
Definition: img2dec.c:972
AVInputFormat::raw_codec_id
int raw_codec_id
Raw demuxers store their codec ID here.
Definition: avformat.h:691
SOS
@ SOS
Definition: mjpeg.h:72
APP1
@ APP1
Definition: mjpeg.h:80
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:366
SOF0
@ SOF0
Definition: mjpeg.h:39
pnm_magic_check
static int pnm_magic_check(const AVProbeData *p, int magic)
Definition: img2dec.c:927
OFFSET
#define OFFSET(x)
Definition: img2dec.c:566
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: avcodec.h:231
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
webp_probe
static int webp_probe(const AVProbeData *p)
Definition: img2dec.c:917
ff_img_read_header
int ff_img_read_header(AVFormatContext *s1)
Definition: img2dec.c:182
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
AV_CODEC_ID_PPM
@ AV_CODEC_ID_PPM
Definition: avcodec.h:280
dds_probe
static int dds_probe(const AVProbeData *p)
Definition: img2dec.c:651
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
AV_CODEC_ID_PGM
@ AV_CODEC_ID_PGM
Definition: avcodec.h:282
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1481
psd_probe
static int psd_probe(const AVProbeData *p)
Definition: img2dec.c:838
ff_guess_image2_codec
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:103
pcx_probe
static int pcx_probe(const AVProbeData *p)
Definition: img2dec.c:783
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
img_read_seek
static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: img2dec.c:546
av_get_frame_filename
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4751
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
XWD_Z_PIXMAP
#define XWD_Z_PIXMAP
Definition: xwd.h:32
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:808
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:330
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
is_glob
static int is_glob(const char *path)
Definition: img2dec.c:80
fmt
const char * fmt
Definition: avisynth_c.h:861
APP4
@ APP4
Definition: mjpeg.h:83
fail
#define fail()
Definition: checkasm.h:120
svg_probe
static int svg_probe(const AVProbeData *p)
Definition: img2dec.c:887
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
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: utils.c:2056
SOF3
@ SOF3
Definition: mjpeg.h:42
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
IMAGEAUTO_DEMUXER
#define IMAGEAUTO_DEMUXER(imgname, codecid)
Definition: img2dec.c:1029
pgmx_probe
static int pgmx_probe(const AVProbeData *p)
Definition: img2dec.c:950
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:460
img_read_close
static int img_read_close(struct AVFormatContext *s1)
Definition: img2dec.c:535
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:919
PT_NONE
@ PT_NONE
Definition: img2.h:37
loop
static int loop
Definition: ffplay.c:340
PT_GLOB
@ PT_GLOB
Definition: img2.h:35
gif89a_sig
static const uint8_t gif89a_sig[6]
Definition: gif.h:35
pictor_probe
static int pictor_probe(const AVProbeData *p)
Definition: img2dec.c:820
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
state
static struct @313 state
buf
void * buf
Definition: avisynth_c.h:766
AVInputFormat
Definition: avformat.h:640
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:257
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:86
AV_CODEC_ID_BMP
@ AV_CODEC_ID_BMP
Definition: avcodec.h:296
ff_image2pipe_demuxer
AVInputFormat ff_image2pipe_demuxer
APP12
@ APP12
Definition: mjpeg.h:91
img_read_probe
static int img_read_probe(const AVProbeData *p)
Definition: img2dec.c:163
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
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:448
PT_DEFAULT
@ PT_DEFAULT
Definition: img2.h:38
frame_size
int frame_size
Definition: mxfenc.c:2215
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: avcodec.h:4023
s1
#define s1
Definition: regdef.h:38
AVProbeData::filename
const char * filename
Definition: avformat.h:447
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:38
bmp_probe
static int bmp_probe(const AVProbeData *p)
Definition: img2dec.c:633
pgmyuv_probe
static int pgmyuv_probe(const AVProbeData *p)
Definition: img2dec.c:961
AV_CODEC_ID_ALIAS_PIX
@ AV_CODEC_ID_ALIAS_PIX
Definition: avcodec.h:395
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1088
j2k_probe
static int j2k_probe(const AVProbeData *p)
Definition: img2dec.c:689
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:90
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
APP11
@ APP11
Definition: mjpeg.h:90
VideoDemuxData
Definition: img2.h:41
xpm_probe
static int xpm_probe(const AVProbeData *p)
Definition: img2dec.c:977
f
#define f(width, name)
Definition: cbs_vp9.c:255
APP5
@ APP5
Definition: mjpeg.h:84
AV_CODEC_ID_PNG
@ AV_CODEC_ID_PNG
Definition: avcodec.h:279
if
if(ret)
Definition: filter_design.txt:179
xwd.h
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
internal.h
AV_CODEC_ID_EXR
@ AV_CODEC_ID_EXR
Definition: avcodec.h:398
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_img_options
const AVOption ff_img_options[]
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:53
AV_CODEC_ID_XWD
@ AV_CODEC_ID_XWD
Definition: avcodec.h:376
APP9
@ APP9
Definition: mjpeg.h:88
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:986
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1291
AV_CODEC_ID_PICTOR
@ AV_CODEC_ID_PICTOR
Definition: avcodec.h:359
AV_CODEC_ID_PGMYUV
@ AV_CODEC_ID_PGMYUV
Definition: avcodec.h:283
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
parseutils.h
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
TEM
@ TEM
Definition: mjpeg.h:113
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:110
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:456
DEC
#define DEC
Definition: img2dec.c:567
PT_SEQUENCE
@ PT_SEQUENCE
Definition: img2.h:36
AV_CODEC_ID_PAM
@ AV_CODEC_ID_PAM
Definition: avcodec.h:284
sunrast_probe
static int sunrast_probe(const AVProbeData *p)
Definition: img2dec.c:878
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: avcodec.h:1478
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:188
XWD_HEADER_SIZE
#define XWD_HEADER_SIZE
Definition: xwd.h:27
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4910
gif.h
size
int size
Definition: twinvq_data.h:11134
dpx_probe
static int dpx_probe(const AVProbeData *p)
Definition: img2dec.c:662
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:92
AV_CODEC_ID_PCX
@ AV_CODEC_ID_PCX
Definition: avcodec.h:327
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:483
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:522
header
static const uint8_t header[24]
Definition: sdr2.c:67
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
AV_CODEC_ID_QDRAW
@ AV_CODEC_ID_QDRAW
Definition: avcodec.h:276
AV_CODEC_ID_XPM
@ AV_CODEC_ID_XPM
Definition: avcodec.h:442
AV_CODEC_ID_SVG
@ AV_CODEC_ID_SVG
Definition: avcodec.h:447
DQT
@ DQT
Definition: mjpeg.h:73
APP6
@ APP6
Definition: mjpeg.h:85
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: avcodec.h:315
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: avcodec.h:225
gif_probe
static int gif_probe(const AVProbeData *p)
Definition: img2dec.c:1016
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
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: avcodec.h:4024
img2.h
ff_image2_demuxer
AVInputFormat ff_image2_demuxer
APP8
@ APP8
Definition: mjpeg.h:87
pgm_probe
static int pgm_probe(const AVProbeData *p)
Definition: img2dec.c:955
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_img2pipe_options
const AVOption ff_img2pipe_options[]
Definition: img2dec.c:611
AV_CODEC_ID_WEBP
@ AV_CODEC_ID_WEBP
Definition: avcodec.h:390
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: avcodec.h:306
AVInputFormat::read_packet
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in 'pkt'.
Definition: avformat.h:721
infer_size
static int infer_size(int *width_ptr, int *height_ptr, int size)
Definition: img2dec.c:65
APP7
@ APP7
Definition: mjpeg.h:86
sgi_probe
static int sgi_probe(const AVProbeData *p)
Definition: img2dec.c:866
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:870
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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:72
SOF2
@ SOF2
Definition: mjpeg.h:41
pnm_probe
static int pnm_probe(const AVProbeData *p)
Definition: img2dec.c:934
avformat.h
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: img2dec.c:568
APP14
@ APP14
Definition: mjpeg.h:93
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2450
jpeg_probe
static int jpeg_probe(const AVProbeData *p)
Definition: img2dec.c:699
subtitles.h
png_probe
static int png_probe(const AVProbeData *p)
Definition: img2dec.c:829
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
jpegls_probe
static int jpegls_probe(const AVProbeData *p)
Definition: img2dec.c:774
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
APP2
@ APP2
Definition: mjpeg.h:81
AV_CODEC_ID_JPEGLS
@ AV_CODEC_ID_JPEGLS
Definition: avcodec.h:229
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
PROBE_BUF_MIN
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:33
AV_CODEC_ID_PSD
@ AV_CODEC_ID_PSD
Definition: avcodec.h:436
ppm_probe
static int ppm_probe(const AVProbeData *p)
Definition: img2dec.c:967
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:647
exr_probe
static int exr_probe(const AVProbeData *p)
Definition: img2dec.c:680
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:801
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1479
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
ff_img_read_packet
int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: img2dec.c:377
APP0
@ APP0
Definition: mjpeg.h:79
pbm_probe
static int pbm_probe(const AVProbeData *p)
Definition: img2dec.c:945
ff_format_io_close
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5665
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_CODEC_ID_DDS
@ AV_CODEC_ID_DDS
Definition: avcodec.h:408
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:1110
SOI
@ SOI
Definition: mjpeg.h:70
AVCodecParameters::format
int format
Definition: avcodec.h:3981
SOF1
@ SOF1
Definition: mjpeg.h:40
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
tiff_probe
static int tiff_probe(const AVProbeData *p)
Definition: img2dec.c:907
XWD_VERSION
#define XWD_VERSION
Definition: xwd.h:26
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:791
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
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:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
PT_GLOB_SEQUENCE
@ PT_GLOB_SEQUENCE
Definition: img2.h:34
AV_CODEC_ID_SGI
@ AV_CODEC_ID_SGI
Definition: avcodec.h:319
AV_CODEC_ID_SUNRAST
@ AV_CODEC_ID_SUNRAST
Definition: avcodec.h:328
h
h
Definition: vp9dsp_template.c:2038
SOF7
@ SOF7
Definition: mjpeg.h:46
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition: avcodec.h:314
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:187
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:909
avstring.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: avcodec.h:227
SOF6
@ SOF6
Definition: mjpeg.h:45
qdraw_probe
static int qdraw_probe(const AVProbeData *p)
Definition: img2dec.c:804
av_probe_input_format3
ff_const59 AVInputFormat * av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret)
Guess the file format.
Definition: format.c:128
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:91
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:94
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2167
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358