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 
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 {
225  st->avg_frame_rate = st->r_frame_rate = s->framerate;
226  }
227 
228  if (s->width && s->height) {
229  st->codecpar->width = s->width;
230  st->codecpar->height = s->height;
231  }
232 
233  if (!s->is_pipe) {
234  if (s->pattern_type == PT_DEFAULT) {
235  if (s1->pb) {
236  s->pattern_type = PT_NONE;
237  } else
239  }
240 
241  if (s->pattern_type == PT_GLOB_SEQUENCE) {
242  s->use_glob = is_glob(s->path);
243  if (s->use_glob) {
244 #if HAVE_GLOB
245  char *p = s->path, *q, *dup;
246  int gerr;
247 #endif
248 
249  av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
250  "use pattern_type 'glob' instead\n");
251 #if HAVE_GLOB
252  dup = q = av_strdup(p);
253  while (*q) {
254  /* Do we have room for the next char and a \ insertion? */
255  if ((p - s->path) >= (sizeof(s->path) - 2))
256  break;
257  if (*q == '%' && strspn(q + 1, "%*?[]{}"))
258  ++q;
259  else if (strspn(q, "\\*?[]{}"))
260  *p++ = '\\';
261  *p++ = *q++;
262  }
263  *p = 0;
264  av_free(dup);
265 
266  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
267  if (gerr != 0) {
268  return AVERROR(ENOENT);
269  }
270  first_index = 0;
271  last_index = s->globstate.gl_pathc - 1;
272 #endif
273  }
274  }
275  if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
276  if (find_image_range(s1->pb, &first_index, &last_index, s->path,
277  s->start_number, s->start_number_range) < 0) {
278  av_log(s1, AV_LOG_ERROR,
279  "Could find no file with path '%s' and index in the range %d-%d\n",
280  s->path, s->start_number, s->start_number + s->start_number_range - 1);
281  return AVERROR(ENOENT);
282  }
283  } else if (s->pattern_type == PT_GLOB) {
284 #if HAVE_GLOB
285  int gerr;
286  gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
287  if (gerr != 0) {
288  return AVERROR(ENOENT);
289  }
290  first_index = 0;
291  last_index = s->globstate.gl_pathc - 1;
292  s->use_glob = 1;
293 #else
294  av_log(s1, AV_LOG_ERROR,
295  "Pattern type 'glob' was selected but globbing "
296  "is not supported by this libavformat build\n");
297  return AVERROR(ENOSYS);
298 #endif
299  } else if (s->pattern_type != PT_GLOB_SEQUENCE && s->pattern_type != PT_NONE) {
300  av_log(s1, AV_LOG_ERROR,
301  "Unknown value '%d' for pattern_type option\n", s->pattern_type);
302  return AVERROR(EINVAL);
303  }
304  s->img_first = first_index;
305  s->img_last = last_index;
306  s->img_number = first_index;
307  /* compute duration */
308  if (!s->ts_from_file) {
309  st->start_time = 0;
310  st->duration = last_index - first_index + 1;
311  }
312  }
313 
314  if (s1->video_codec_id) {
316  st->codecpar->codec_id = s1->video_codec_id;
317  } else if (s1->audio_codec_id) {
319  st->codecpar->codec_id = s1->audio_codec_id;
320  } else if (s1->iformat->raw_codec_id) {
323  } else {
324  const char *str = strrchr(s->path, '.');
325  s->split_planes = str && !av_strcasecmp(str + 1, "y");
327  if (s1->pb) {
328  int probe_buffer_size = 2048;
329  uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE);
330  const AVInputFormat *fmt = NULL;
331  void *fmt_iter = NULL;
332  AVProbeData pd = { 0 };
333 
334  if (!probe_buffer)
335  return AVERROR(ENOMEM);
336 
337  probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size);
338  if (probe_buffer_size < 0) {
339  av_free(probe_buffer);
340  return probe_buffer_size;
341  }
342  memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE);
343 
344  pd.buf = probe_buffer;
345  pd.buf_size = probe_buffer_size;
346  pd.filename = s1->url;
347 
348  while ((fmt = av_demuxer_iterate(&fmt_iter))) {
349  if (fmt->read_header != ff_img_read_header ||
350  !fmt->read_probe ||
351  (fmt->flags & AVFMT_NOFILE) ||
352  !fmt->raw_codec_id)
353  continue;
354  if (fmt->read_probe(&pd) > 0) {
355  st->codecpar->codec_id = fmt->raw_codec_id;
356  break;
357  }
358  }
359  if (s1->flags & AVFMT_FLAG_CUSTOM_IO) {
360  avio_seek(s1->pb, 0, SEEK_SET);
361  av_freep(&probe_buffer);
362  } else
363  ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size);
364  }
365  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
367  if (st->codecpar->codec_id == AV_CODEC_ID_LJPEG)
369  if (st->codecpar->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
371  }
372  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
373  pix_fmt != AV_PIX_FMT_NONE)
374  st->codecpar->format = pix_fmt;
375 
376  return 0;
377 }
378 
379 /**
380  * Add this frame's source path and basename to packet's sidedata
381  * as a dictionary, so it can be used by filters like 'drawtext'.
382  */
383 static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt) {
384  AVDictionary *d = NULL;
385  char *packed_metadata = NULL;
386  buffer_size_t metadata_len;
387  int ret;
388 
389  av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);
390  av_dict_set(&d, "lavf.image2dec.source_basename", av_basename(filename), 0);
391 
392  packed_metadata = av_packet_pack_dictionary(d, &metadata_len);
393  av_dict_free(&d);
394  if (!packed_metadata)
395  return AVERROR(ENOMEM);
397  packed_metadata, metadata_len);
398  if (ret < 0) {
399  av_freep(&packed_metadata);
400  return ret;
401  }
402  return 0;
403 }
404 
406 {
407  VideoDemuxData *s = s1->priv_data;
408  char filename_bytes[1024];
409  char *filename = filename_bytes;
410  int i, res;
411  int size[3] = { 0 }, ret[3] = { 0 };
412  AVIOContext *f[3] = { NULL };
413  AVCodecParameters *par = s1->streams[0]->codecpar;
414 
415  if (!s->is_pipe) {
416  /* loop over input */
417  if (s->loop && s->img_number > s->img_last) {
418  s->img_number = s->img_first;
419  }
420  if (s->img_number > s->img_last)
421  return AVERROR_EOF;
422  if (s->pattern_type == PT_NONE) {
423  av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
424  } else if (s->use_glob) {
425 #if HAVE_GLOB
426  filename = s->globstate.gl_pathv[s->img_number];
427 #endif
428  } else {
429  if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
430  s->path,
431  s->img_number) < 0 && s->img_number > 1)
432  return AVERROR(EIO);
433  }
434  for (i = 0; i < 3; i++) {
435  if (s1->pb &&
436  !strcmp(filename_bytes, s->path) &&
437  !s->loop &&
438  !s->split_planes) {
439  f[i] = s1->pb;
440  } else if (s1->io_open(s1, &f[i], filename, AVIO_FLAG_READ, NULL) < 0) {
441  if (i >= 1)
442  break;
443  av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
444  filename);
445  return AVERROR(EIO);
446  }
447  size[i] = avio_size(f[i]);
448 
449  if (!s->split_planes)
450  break;
451  filename[strlen(filename) - 1] = 'U' + i;
452  }
453 
454  if (par->codec_id == AV_CODEC_ID_NONE) {
455  AVProbeData pd = { 0 };
456  const AVInputFormat *ifmt;
458  int ret;
459  int score = 0;
460 
461  ret = avio_read(f[0], header, PROBE_BUF_MIN);
462  if (ret < 0)
463  return ret;
464  memset(header + ret, 0, sizeof(header) - ret);
465  avio_skip(f[0], -ret);
466  pd.buf = header;
467  pd.buf_size = ret;
468  pd.filename = filename;
469 
470  ifmt = av_probe_input_format3(&pd, 1, &score);
471  if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
472  par->codec_id = ifmt->raw_codec_id;
473  }
474 
475  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
476  infer_size(&par->width, &par->height, size[0]);
477  } else {
478  f[0] = s1->pb;
479  if (avio_feof(f[0]) && s->loop && s->is_pipe)
480  avio_seek(f[0], 0, SEEK_SET);
481  if (avio_feof(f[0]))
482  return AVERROR_EOF;
483  if (s->frame_size > 0) {
484  size[0] = s->frame_size;
485  } else if (!s1->streams[0]->parser) {
486  size[0] = avio_size(s1->pb);
487  } else {
488  size[0] = 4096;
489  }
490  }
491 
492  res = av_new_packet(pkt, size[0] + size[1] + size[2]);
493  if (res < 0) {
494  goto fail;
495  }
496  pkt->stream_index = 0;
497  pkt->flags |= AV_PKT_FLAG_KEY;
498  if (s->ts_from_file) {
499  struct stat img_stat;
500  if (stat(filename, &img_stat)) {
501  res = AVERROR(EIO);
502  goto fail;
503  }
504  pkt->pts = (int64_t)img_stat.st_mtime;
505 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
506  if (s->ts_from_file == 2)
507  pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
508 #endif
509  av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
510  } else if (!s->is_pipe) {
511  pkt->pts = s->pts;
512  }
513 
514  if (s->is_pipe)
515  pkt->pos = avio_tell(f[0]);
516 
517  /*
518  * export_path_metadata must be explicitly enabled via
519  * command line options for path metadata to be exported
520  * as packet side_data.
521  */
522  if (!s->is_pipe && s->export_path_metadata == 1) {
523  res = add_filename_as_pkt_side_data(filename, pkt);
524  if (res < 0)
525  goto fail;
526  }
527 
528  pkt->size = 0;
529  for (i = 0; i < 3; i++) {
530  if (f[i]) {
531  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
532  if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
533  if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
534  pkt->pos = 0;
535  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
536  }
537  }
538  if (!s->is_pipe && f[i] != s1->pb)
539  ff_format_io_close(s1, &f[i]);
540  if (ret[i] > 0)
541  pkt->size += ret[i];
542  }
543  }
544 
545  if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
546  if (ret[0] < 0) {
547  res = ret[0];
548  } else if (ret[1] < 0) {
549  res = ret[1];
550  } else if (ret[2] < 0) {
551  res = ret[2];
552  } else {
553  res = AVERROR_EOF;
554  }
555  goto fail;
556  } else {
557  s->img_count++;
558  s->img_number++;
559  s->pts++;
560  return 0;
561  }
562 
563 fail:
564  if (!s->is_pipe) {
565  for (i = 0; i < 3; i++) {
566  if (f[i] != s1->pb)
567  ff_format_io_close(s1, &f[i]);
568  }
569  }
570  return res;
571 }
572 
573 static int img_read_close(struct AVFormatContext* s1)
574 {
575 #if HAVE_GLOB
576  VideoDemuxData *s = s1->priv_data;
577  if (s->use_glob) {
578  globfree(&s->globstate);
579  }
580 #endif
581  return 0;
582 }
583 
584 static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
585 {
587  AVStream *st = s->streams[0];
588 
589  if (s1->ts_from_file) {
590  int index = av_index_search_timestamp(st, timestamp, flags);
591  if(index < 0)
592  return -1;
594  return 0;
595  }
596 
597  if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
598  return -1;
599  s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
600  s1->pts = timestamp;
601  return 0;
602 }
603 
604 #define OFFSET(x) offsetof(VideoDemuxData, x)
605 #define DEC AV_OPT_FLAG_DECODING_PARAM
606 #define COMMON_OPTIONS \
607  { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
608  { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
609  { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
610  { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
611  { NULL },
612 
613 #if CONFIG_IMAGE2_DEMUXER
614 const AVOption ff_img_options[] = {
615  { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, "pattern_type"},
616  { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
617  { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" },
618  { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
619  { "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
620  { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
621  { "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 },
622  { "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" },
623  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, "ts_type" },
624  { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, "ts_type" },
625  { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, "ts_type" },
626  { "export_path_metadata", "enable metadata containing input path information", OFFSET(export_path_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
628 };
629 
630 static const AVClass img2_class = {
631  .class_name = "image2 demuxer",
632  .item_name = av_default_item_name,
633  .option = ff_img_options,
634  .version = LIBAVUTIL_VERSION_INT,
635 };
637  .name = "image2",
638  .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
639  .priv_data_size = sizeof(VideoDemuxData),
645  .flags = AVFMT_NOFILE,
646  .priv_class = &img2_class,
647 };
648 #endif
649 
651  { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
653 };
654 
655 #if CONFIG_IMAGE2PIPE_DEMUXER
656 static const AVClass img2pipe_class = {
657  .class_name = "image2pipe demuxer",
658  .item_name = av_default_item_name,
659  .option = ff_img2pipe_options,
660  .version = LIBAVUTIL_VERSION_INT,
661 };
663  .name = "image2pipe",
664  .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
665  .priv_data_size = sizeof(VideoDemuxData),
668  .priv_class = &img2pipe_class,
669 };
670 #endif
671 
672 static int bmp_probe(const AVProbeData *p)
673 {
674  const uint8_t *b = p->buf;
675  int ihsize;
676 
677  if (AV_RB16(b) != 0x424d)
678  return 0;
679 
680  ihsize = AV_RL32(b+14);
681  if (ihsize < 12 || ihsize > 255)
682  return 0;
683 
684  if (!AV_RN32(b + 6)) {
685  return AVPROBE_SCORE_EXTENSION + 1;
686  }
687  return AVPROBE_SCORE_EXTENSION / 4;
688 }
689 
690 static int cri_probe(const AVProbeData *p)
691 {
692  const uint8_t *b = p->buf;
693 
694  if ( AV_RL32(b) == 1
695  && AV_RL32(b + 4) == 4
696  && AV_RN32(b + 8) == AV_RN32("DVCC"))
697  return AVPROBE_SCORE_MAX - 1;
698  return 0;
699 }
700 
701 static int dds_probe(const AVProbeData *p)
702 {
703  const uint8_t *b = p->buf;
704 
705  if ( AV_RB64(b) == 0x444453207c000000
706  && AV_RL32(b + 8)
707  && AV_RL32(b + 12))
708  return AVPROBE_SCORE_MAX - 1;
709  return 0;
710 }
711 
712 static int dpx_probe(const AVProbeData *p)
713 {
714  const uint8_t *b = p->buf;
715  int w, h;
716  int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
717 
718  if (p->buf_size < 0x304+8)
719  return 0;
720  w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
721  h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
722  if (w <= 0 || h <= 0)
723  return 0;
724 
725  if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
726  return AVPROBE_SCORE_EXTENSION + 1;
727  return 0;
728 }
729 
730 static int exr_probe(const AVProbeData *p)
731 {
732  const uint8_t *b = p->buf;
733 
734  if (AV_RL32(b) == 20000630)
735  return AVPROBE_SCORE_EXTENSION + 1;
736  return 0;
737 }
738 
739 static int j2k_probe(const AVProbeData *p)
740 {
741  const uint8_t *b = p->buf;
742 
743  if (AV_RB64(b) == 0x0000000c6a502020 ||
744  AV_RB32(b) == 0xff4fff51)
745  return AVPROBE_SCORE_EXTENSION + 1;
746  return 0;
747 }
748 
749 static int jpeg_probe(const AVProbeData *p)
750 {
751  const uint8_t *b = p->buf;
752  int i, state = SOI;
753 
754  if (AV_RB16(b) != 0xFFD8 ||
755  AV_RB32(b) == 0xFFD8FFF7)
756  return 0;
757 
758  b += 2;
759  for (i = 0; i < p->buf_size - 3; i++) {
760  int c;
761  if (b[i] != 0xFF)
762  continue;
763  c = b[i + 1];
764  switch (c) {
765  case SOI:
766  return 0;
767  case SOF0:
768  case SOF1:
769  case SOF2:
770  case SOF3:
771  case SOF5:
772  case SOF6:
773  case SOF7:
774  i += AV_RB16(&b[i + 2]) + 1;
775  if (state != SOI)
776  return 0;
777  state = SOF0;
778  break;
779  case SOS:
780  i += AV_RB16(&b[i + 2]) + 1;
781  if (state != SOF0 && state != SOS)
782  return 0;
783  state = SOS;
784  break;
785  case EOI:
786  if (state != SOS)
787  return 0;
788  state = EOI;
789  break;
790  case DQT:
791  case APP0:
792  case APP1:
793  case APP2:
794  case APP3:
795  case APP4:
796  case APP5:
797  case APP6:
798  case APP7:
799  case APP8:
800  case APP9:
801  case APP10:
802  case APP11:
803  case APP12:
804  case APP13:
805  case APP14:
806  case APP15:
807  case COM:
808  i += AV_RB16(&b[i + 2]) + 1;
809  break;
810  default:
811  if ( (c > TEM && c < SOF0)
812  || c == JPG)
813  return 0;
814  }
815  }
816 
817  if (state == EOI)
818  return AVPROBE_SCORE_EXTENSION + 1;
819  if (state == SOS)
820  return AVPROBE_SCORE_EXTENSION / 2;
821  return AVPROBE_SCORE_EXTENSION / 8 + 1;
822 }
823 
824 static int jpegls_probe(const AVProbeData *p)
825 {
826  const uint8_t *b = p->buf;
827 
828  if (AV_RB32(b) == 0xffd8fff7)
829  return AVPROBE_SCORE_EXTENSION + 1;
830  return 0;
831 }
832 
833 static int pcx_probe(const AVProbeData *p)
834 {
835  const uint8_t *b = p->buf;
836 
837  if ( p->buf_size < 128
838  || b[0] != 10
839  || b[1] > 5
840  || b[2] > 1
841  || av_popcount(b[3]) != 1 || b[3] > 8
842  || AV_RL16(&b[4]) > AV_RL16(&b[8])
843  || AV_RL16(&b[6]) > AV_RL16(&b[10])
844  || b[64])
845  return 0;
846  b += 73;
847  while (++b < p->buf + 128)
848  if (*b)
849  return AVPROBE_SCORE_EXTENSION / 4;
850 
851  return AVPROBE_SCORE_EXTENSION + 1;
852 }
853 
854 static int qdraw_probe(const AVProbeData *p)
855 {
856  const uint8_t *b = p->buf;
857 
858  if ( p->buf_size >= 528
859  && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
860  && AV_RB16(b + 520)
861  && AV_RB16(b + 518))
862  return AVPROBE_SCORE_MAX * 3 / 4;
863  if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
864  && AV_RB16(b + 8)
865  && AV_RB16(b + 6))
866  return AVPROBE_SCORE_EXTENSION / 4;
867  return 0;
868 }
869 
870 static int pictor_probe(const AVProbeData *p)
871 {
872  const uint8_t *b = p->buf;
873 
874  if (AV_RL16(b) == 0x1234)
875  return AVPROBE_SCORE_EXTENSION / 4;
876  return 0;
877 }
878 
879 static int png_probe(const AVProbeData *p)
880 {
881  const uint8_t *b = p->buf;
882 
883  if (AV_RB64(b) == 0x89504e470d0a1a0a)
884  return AVPROBE_SCORE_MAX - 1;
885  return 0;
886 }
887 
888 static int psd_probe(const AVProbeData *p)
889 {
890  const uint8_t *b = p->buf;
891  int ret = 0;
892  uint16_t color_mode;
893 
894  if (AV_RL32(b) == MKTAG('8','B','P','S')) {
895  ret += 1;
896  } else {
897  return 0;
898  }
899 
900  if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
901  ret += 1;
902  } else {
903  return 0;
904  }
905 
906  if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
907  ret += 1;
908 
909  color_mode = AV_RB16(b+24);
910  if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
911  ret += 1;
912 
913  return AVPROBE_SCORE_EXTENSION + ret;
914 }
915 
916 static int sgi_probe(const AVProbeData *p)
917 {
918  const uint8_t *b = p->buf;
919 
920  if (AV_RB16(b) == 474 &&
921  (b[2] & ~1) == 0 &&
922  (b[3] & ~3) == 0 && b[3] &&
923  (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
924  return AVPROBE_SCORE_EXTENSION + 1;
925  return 0;
926 }
927 
928 static int sunrast_probe(const AVProbeData *p)
929 {
930  const uint8_t *b = p->buf;
931 
932  if (AV_RB32(b) == 0x59a66a95)
933  return AVPROBE_SCORE_EXTENSION + 1;
934  return 0;
935 }
936 
937 static int svg_probe(const AVProbeData *p)
938 {
939  const uint8_t *b = p->buf;
940  const uint8_t *end = p->buf + p->buf_size;
941 
942  if (memcmp(p->buf, "<?xml", 5))
943  return 0;
944  while (b < end) {
945  int inc = ff_subtitles_next_line(b);
946  if (!inc)
947  break;
948  b += inc;
949  if (b >= end - 4)
950  return 0;
951  if (!memcmp(b, "<svg", 4))
952  return AVPROBE_SCORE_EXTENSION + 1;
953  }
954  return 0;
955 }
956 
957 static int tiff_probe(const AVProbeData *p)
958 {
959  const uint8_t *b = p->buf;
960 
961  if (AV_RB32(b) == 0x49492a00 ||
962  AV_RB32(b) == 0x4D4D002a)
963  return AVPROBE_SCORE_EXTENSION + 1;
964  return 0;
965 }
966 
967 static int webp_probe(const AVProbeData *p)
968 {
969  const uint8_t *b = p->buf;
970 
971  if (AV_RB32(b) == 0x52494646 &&
972  AV_RB32(b + 8) == 0x57454250)
973  return AVPROBE_SCORE_MAX - 1;
974  return 0;
975 }
976 
977 static int pnm_magic_check(const AVProbeData *p, int magic)
978 {
979  const uint8_t *b = p->buf;
980 
981  return b[0] == 'P' && b[1] == magic + '0';
982 }
983 
984 static inline int pnm_probe(const AVProbeData *p)
985 {
986  const uint8_t *b = p->buf;
987 
988  while (b[2] == '\r')
989  b++;
990  if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
991  return AVPROBE_SCORE_EXTENSION + 2;
992  return 0;
993 }
994 
995 static int pbm_probe(const AVProbeData *p)
996 {
997  return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) || pnm_magic_check(p, 22) || pnm_magic_check(p, 54) ? pnm_probe(p) : 0;
998 }
999 
1000 static inline int pgmx_probe(const AVProbeData *p)
1001 {
1002  return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
1003 }
1004 
1005 static int pgm_probe(const AVProbeData *p)
1006 {
1007  int ret = pgmx_probe(p);
1008  return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1009 }
1010 
1011 static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
1012 {
1013  int ret = pgmx_probe(p);
1014  return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1015 }
1016 
1017 static int pgx_probe(const AVProbeData *p)
1018 {
1019  const uint8_t *b = p->buf;
1020  if (!memcmp(b, "PG ML ", 6))
1021  return AVPROBE_SCORE_EXTENSION + 1;
1022  return 0;
1023 }
1024 
1025 static int ppm_probe(const AVProbeData *p)
1026 {
1027  return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
1028 }
1029 
1030 static int pam_probe(const AVProbeData *p)
1031 {
1032  return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
1033 }
1034 
1035 static int xbm_probe(const AVProbeData *p)
1036 {
1037  if (!memcmp(p->buf, "/* XBM X10 format */", 20))
1038  return AVPROBE_SCORE_MAX;
1039 
1040  if (!memcmp(p->buf, "#define", 7))
1041  return AVPROBE_SCORE_MAX - 1;
1042  return 0;
1043 }
1044 
1045 static int xpm_probe(const AVProbeData *p)
1046 {
1047  const uint8_t *b = p->buf;
1048 
1049  if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
1050  return AVPROBE_SCORE_MAX - 1;
1051  return 0;
1052 }
1053 
1054 static int xwd_probe(const AVProbeData *p)
1055 {
1056  const uint8_t *b = p->buf;
1057  unsigned width, bpp, bpad, lsize;
1058 
1059  if ( p->buf_size < XWD_HEADER_SIZE
1060  || AV_RB32(b ) < XWD_HEADER_SIZE // header size
1061  || AV_RB32(b + 4) != XWD_VERSION // version
1062  || AV_RB32(b + 8) != XWD_Z_PIXMAP // format
1063  || AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
1064  || AV_RB32(b + 16) == 0 // width
1065  || AV_RB32(b + 20) == 0 // height
1066  || AV_RB32(b + 28) > 1 // byteorder
1067  || AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
1068  || AV_RB32(b + 36) > 1 // bitorder
1069  || AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
1070  || AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
1071  || AV_RB32(b + 68) > 256) // colours
1072  return 0;
1073 
1074  width = AV_RB32(b + 16);
1075  bpad = AV_RB32(b + 40);
1076  bpp = AV_RB32(b + 44);
1077  lsize = AV_RB32(b + 48);
1078  if (lsize < FFALIGN(width * bpp, bpad) >> 3)
1079  return 0;
1080 
1081  return AVPROBE_SCORE_MAX / 2 + 1;
1082 }
1083 
1084 static int gif_probe(const AVProbeData *p)
1085 {
1086  /* check magick */
1087  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
1088  return 0;
1089 
1090  /* width or height contains zero? */
1091  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
1092  return 0;
1093 
1094  return AVPROBE_SCORE_MAX - 1;
1095 }
1096 
1097 static int photocd_probe(const AVProbeData *p)
1098 {
1099  if (!memcmp(p->buf, "PCD_OPA", 7))
1100  return AVPROBE_SCORE_MAX - 1;
1101 
1102  if (p->buf_size < 0x807 || memcmp(p->buf + 0x800, "PCD_IPI", 7))
1103  return 0;
1104 
1105  return AVPROBE_SCORE_MAX - 1;
1106 }
1107 
1108 #define IMAGEAUTO_DEMUXER(imgname, codecid)\
1109 static const AVClass imgname ## _class = {\
1110  .class_name = AV_STRINGIFY(imgname) " demuxer",\
1111  .item_name = av_default_item_name,\
1112  .option = ff_img2pipe_options,\
1113  .version = LIBAVUTIL_VERSION_INT,\
1114 };\
1115 AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
1116  .name = AV_STRINGIFY(imgname) "_pipe",\
1117  .long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
1118  .priv_data_size = sizeof(VideoDemuxData),\
1119  .read_probe = imgname ## _probe,\
1120  .read_header = ff_img_read_header,\
1121  .read_packet = ff_img_read_packet,\
1122  .priv_class = & imgname ## _class,\
1123  .flags = AVFMT_GENERIC_INDEX, \
1124  .raw_codec_id = codecid,\
1125 };
1126 
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:714
Definition: mjpeg.h:93
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1843
int img_number
Definition: img2.h:45
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
static enum AVPixelFormat pix_fmt
int height
Set by a private option.
Definition: img2.h:52
static int cri_probe(const AVProbeData *p)
Definition: img2dec.c:690
static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: img2dec.c:584
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
Definition: mjpeg.h:81
AVOption.
Definition: opt.h:248
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
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:2044
#define OFFSET(x)
Definition: img2dec.c:604
Definition: mjpeg.h:71
Definition: mjpeg.h:111
Definition: mjpeg.h:73
Definition: mjpeg.h:40
static int svg_probe(const AVProbeData *p)
Definition: img2dec.c:937
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Definition: mjpeg.h:42
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * filename
Definition: avformat.h:442
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:389
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:1094
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:4999
int64_t pos
Definition: avformat.h:813
static int psd_probe(const AVProbeData *p)
Definition: img2dec.c:888
AVInputFormat ff_image2_demuxer
char path[1024]
Definition: img2.h:50
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
static int img_read_close(struct AVFormatContext *s1)
Definition: img2dec.c:573
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:370
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
static const uint8_t gif87a_sig[6]
Definition: gif.h:34
int start_number_range
Definition: img2.h:61
Definition: img2.h:37
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
#define FF_ARRAY_ELEMS(a)
const AVOption ff_img_options[]
AVPacket * pkt
Definition: movenc.c:59
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1296
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:91
fg index
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
MJPEG encoder and decoder.
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int img_count
Definition: img2.h:47
static int dds_probe(const AVProbeData *p)
Definition: img2dec.c:701
char * pixel_format
Set by a private option.
Definition: img2.h:51
static int pgmyuv_probe(const AVProbeData *p)
Definition: img2dec.c:1011
#define IMAGEAUTO_DEMUXER(imgname, codecid)
Definition: img2dec.c:1108
Format I/O context.
Definition: avformat.h:1247
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
static int pam_probe(const AVProbeData *p)
Definition: img2dec.c:1030
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
static int bmp_probe(const AVProbeData *p)
Definition: img2dec.c:672
static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt)
Add this frame&#39;s source path and basename to packet&#39;s sidedata as a dictionary, so it can be used by ...
Definition: img2dec.c:383
Definition: mjpeg.h:72
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:260
uint8_t
int width
Video only.
Definition: codec_par.h:126
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1187
AVOptions.
int pattern_type
PatternType.
Definition: img2.h:55
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:668
#define f(width, name)
Definition: cbs_vp9.c:255
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
enum AVStreamParseType need_parsing
Definition: avformat.h:1092
static int pictor_probe(const AVProbeData *p)
Definition: img2dec.c:870
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5746
Definition: mjpeg.h:46
int export_path_metadata
enabled when set to 1.
Definition: img2.h:64
Definition: mjpeg.h:113
int ff_img_read_header(AVFormatContext *s1)
Definition: img2dec.c:182
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4553
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:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1315
Definition: mjpeg.h:86
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1378
uint8_t * data
Definition: packet.h:369
static int pcx_probe(const AVProbeData *p)
Definition: img2dec.c:833
#define XWD_HEADER_SIZE
Definition: xwd.h:27
#define AVERROR_EOF
End of file.
Definition: error.h:55
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
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
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
Definition: mjpeg.h:87
static int xbm_probe(const AVProbeData *p)
Definition: img2dec.c:1035
static struct @321 state
#define XWD_VERSION
Definition: xwd.h:26
#define FFALIGN(x, a)
Definition: macros.h:48
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1435
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
static int is_glob(const char *path)
Definition: img2dec.c:80
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
#define AVINDEX_KEYFRAME
Definition: avformat.h:820
#define XWD_Z_PIXMAP
Definition: xwd.h:32
int64_t pts
Definition: img2.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2161
Definition: mjpeg.h:89
int buffer_size_t
Definition: internal.h:306
static const int sizes[][2]
Definition: img2dec.c:53
int loop
Definition: img2.h:54
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1259
char * url
input or output URL.
Definition: avformat.h:1343
int ts_from_file
Definition: img2.h:63
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static int dpx_probe(const AVProbeData *p)
Definition: img2dec.c:712
static int xpm_probe(const AVProbeData *p)
Definition: img2dec.c:1045
static int pgmx_probe(const AVProbeData *p)
Definition: img2dec.c:1000
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:957
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
#define fail()
Definition: checkasm.h:133
Definition: mjpeg.h:39
static int j2k_probe(const AVProbeData *p)
Definition: img2dec.c:739
Definition: mjpeg.h:70
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:250
Definition: mjpeg.h:79
Definition: mjpeg.h:80
static int img_read_probe(const AVProbeData *p)
Definition: img2dec.c:163
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
#define b
Definition: input.c:41
static int photocd_probe(const AVProbeData *p)
Definition: img2dec.c:1097
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1441
Definition: mjpeg.h:44
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#define width
int is_pipe
Definition: img2.h:48
uint8_t w
Definition: llviddspenc.c:39
Definition: mjpeg.h:91
Definition: mjpeg.h:41
int width
Definition: img2.h:52
#define av_popcount
Definition: common.h:176
Definition: img2.h:35
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
#define s(width, name)
Definition: cbs_vp9.c:257
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don&#39;t avio_close() it.
Definition: avformat.h:1386
Definition: mjpeg.h:83
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:558
int start_number
Definition: img2.h:60
static int sunrast_probe(const AVProbeData *p)
Definition: img2dec.c:928
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4848
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
#define PROBE_BUF_MIN
size of probe buffer, for guessing file type from file contents
Definition: internal.h:33
Stream structure.
Definition: avformat.h:884
#define DEC
Definition: img2dec.c:605
int frame_size
Definition: img2.h:62
static int sgi_probe(const AVProbeData *p)
Definition: img2dec.c:916
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static int xwd_probe(const AVProbeData *p)
Definition: img2dec.c:1054
Definition: mjpeg.h:88
static int jpeg_probe(const AVProbeData *p)
Definition: img2dec.c:749
int frame_size
Definition: mxfenc.c:2206
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1123
A list of zero terminated key/value strings.
Definition: packet.h:172
AVInputFormat ff_image2pipe_demuxer
AVIOContext * pb
I/O context.
Definition: avformat.h:1289
static int loop
Definition: ffplay.c:341
int(* read_packet)(struct AVFormatContext *, AVPacket *pkt)
Read one packet and put it in &#39;pkt&#39;.
Definition: avformat.h:731
int split_planes
use independent file for each Y, U, V plane
Definition: img2.h:49
GIF format definitions.
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:333
static int pgm_probe(const AVProbeData *p)
Definition: img2dec.c:1005
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
Definition: mjpeg.h:84
Describe the class of an AVClass context structure.
Definition: log.h:67
FF_ENABLE_DEPRECATION_WARNINGS 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:309
static int infer_size(int *width_ptr, int *height_ptr, int size)
Definition: img2dec.c:65
Definition: mjpeg.h:45
static int pgx_probe(const AVProbeData *p)
Definition: img2dec.c:1017
#define s1
Definition: regdef.h:38
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define AV_RN32(p)
Definition: intreadwrite.h:364
misc parsing utilities
static int pnm_probe(const AVProbeData *p)
Definition: img2dec.c:984
int img_last
Definition: img2.h:44
int raw_codec_id
Raw demuxers store their codec ID here.
Definition: avformat.h:702
Definition: mjpeg.h:47
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
static int exr_probe(const AVProbeData *p)
Definition: img2dec.c:730
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:933
Definition: mjpeg.h:94
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
full parsing and repack
Definition: avformat.h:803
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
Main libavformat public API header.
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
static int qdraw_probe(const AVProbeData *p)
Definition: img2dec.c:854
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:923
Definition: mjpeg.h:90
static const uint8_t gif89a_sig[6]
Definition: gif.h:35
int den
Denominator.
Definition: rational.h:60
Definition: mjpeg.h:92
enum AVCodecID ff_guess_image2_codec(const char *filename)
Definition: img2.c:106
#define COMMON_OPTIONS
Definition: img2dec.c:606
static int gif_probe(const AVProbeData *p)
Definition: img2dec.c:1084
static int tiff_probe(const AVProbeData *p)
Definition: img2dec.c:957
#define av_free(p)
Definition: mjpeg.h:85
int(* read_header)(struct AVFormatContext *)
Read the format header and initialize the AVFormatContext structure.
Definition: avformat.h:721
AVRational framerate
Set by a private option.
Definition: img2.h:53
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:513
static int ppm_probe(const AVProbeData *p)
Definition: img2dec.c:1025
struct AVCodecParserContext * parser
Definition: avformat.h:1093
void * priv_data
Format private data.
Definition: avformat.h:1275
const AVOption ff_img2pipe_options[]
Definition: img2dec.c:650
static int pbm_probe(const AVProbeData *p)
Definition: img2dec.c:995
int use_glob
Definition: img2.h:56
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
Definition: mjpeg.h:82
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2501
static int pnm_magic_check(const AVProbeData *p, int magic)
Definition: img2dec.c:977
int stream_index
Definition: packet.h:371
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
int img_first
Definition: img2.h:43
#define MKTAG(a, b, c, d)
Definition: common.h:478
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1026
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:346
static int png_probe(const AVProbeData *p)
Definition: img2dec.c:879
static int jpegls_probe(const AVProbeData *p)
Definition: img2dec.c:824
static int webp_probe(const AVProbeData *p)
Definition: img2dec.c:967
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int i
Definition: input.c:407
int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: img2dec.c:405