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 
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
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) {
276  av_log(s1, AV_LOG_ERROR,
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
292  av_log(s1, AV_LOG_ERROR,
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) {
298  av_log(s1, AV_LOG_ERROR,
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) {
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 &&
371  pix_fmt != AV_PIX_FMT_NONE)
372  st->codecpar->format = pix_fmt;
373 
374  return 0;
375 }
376 
377 /**
378  * Add this frame's source path and basename to packet's sidedata
379  * as a dictionary, so it can be used by filters like 'drawtext'.
380  */
381 static int add_filename_as_pkt_side_data(char *filename, AVPacket *pkt) {
382  int metadata_len, ret;
383  AVDictionary *d = NULL;
384  char *packed_metadata = NULL;
385 
386  av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);
387  av_dict_set(&d, "lavf.image2dec.source_basename", av_basename(filename), 0);
388 
389  packed_metadata = av_packet_pack_dictionary(d, &metadata_len);
390  av_dict_free(&d);
391  if (!packed_metadata)
392  return AVERROR(ENOMEM);
394  packed_metadata, metadata_len);
395  if (ret < 0) {
396  av_freep(&packed_metadata);
397  return ret;
398  }
399  return 0;
400 }
401 
403 {
404  VideoDemuxData *s = s1->priv_data;
405  char filename_bytes[1024];
406  char *filename = filename_bytes;
407  int i, res;
408  int size[3] = { 0 }, ret[3] = { 0 };
409  AVIOContext *f[3] = { NULL };
410  AVCodecParameters *par = s1->streams[0]->codecpar;
411 
412  if (!s->is_pipe) {
413  /* loop over input */
414  if (s->loop && s->img_number > s->img_last) {
415  s->img_number = s->img_first;
416  }
417  if (s->img_number > s->img_last)
418  return AVERROR_EOF;
419  if (s->pattern_type == PT_NONE) {
420  av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
421  } else if (s->use_glob) {
422 #if HAVE_GLOB
423  filename = s->globstate.gl_pathv[s->img_number];
424 #endif
425  } else {
426  if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
427  s->path,
428  s->img_number) < 0 && s->img_number > 1)
429  return AVERROR(EIO);
430  }
431  for (i = 0; i < 3; i++) {
432  if (s1->pb &&
433  !strcmp(filename_bytes, s->path) &&
434  !s->loop &&
435  !s->split_planes) {
436  f[i] = s1->pb;
437  } else if (s1->io_open(s1, &f[i], filename, AVIO_FLAG_READ, NULL) < 0) {
438  if (i >= 1)
439  break;
440  av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
441  filename);
442  return AVERROR(EIO);
443  }
444  size[i] = avio_size(f[i]);
445 
446  if (!s->split_planes)
447  break;
448  filename[strlen(filename) - 1] = 'U' + i;
449  }
450 
451  if (par->codec_id == AV_CODEC_ID_NONE) {
452  AVProbeData pd = { 0 };
453  const AVInputFormat *ifmt;
455  int ret;
456  int score = 0;
457 
458  ret = avio_read(f[0], header, PROBE_BUF_MIN);
459  if (ret < 0)
460  return ret;
461  memset(header + ret, 0, sizeof(header) - ret);
462  avio_skip(f[0], -ret);
463  pd.buf = header;
464  pd.buf_size = ret;
465  pd.filename = filename;
466 
467  ifmt = av_probe_input_format3(&pd, 1, &score);
468  if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
469  par->codec_id = ifmt->raw_codec_id;
470  }
471 
472  if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
473  infer_size(&par->width, &par->height, size[0]);
474  } else {
475  f[0] = s1->pb;
476  if (avio_feof(f[0]) && s->loop && s->is_pipe)
477  avio_seek(f[0], 0, SEEK_SET);
478  if (avio_feof(f[0]))
479  return AVERROR_EOF;
480  if (s->frame_size > 0) {
481  size[0] = s->frame_size;
482  } else if (!s1->streams[0]->parser) {
483  size[0] = avio_size(s1->pb);
484  } else {
485  size[0] = 4096;
486  }
487  }
488 
489  res = av_new_packet(pkt, size[0] + size[1] + size[2]);
490  if (res < 0) {
491  goto fail;
492  }
493  pkt->stream_index = 0;
494  pkt->flags |= AV_PKT_FLAG_KEY;
495  if (s->ts_from_file) {
496  struct stat img_stat;
497  if (stat(filename, &img_stat)) {
498  res = AVERROR(EIO);
499  goto fail;
500  }
501  pkt->pts = (int64_t)img_stat.st_mtime;
502 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
503  if (s->ts_from_file == 2)
504  pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
505 #endif
506  av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
507  } else if (!s->is_pipe) {
508  pkt->pts = s->pts;
509  }
510 
511  if (s->is_pipe)
512  pkt->pos = avio_tell(f[0]);
513 
514  /*
515  * export_path_metadata must be explicitly enabled via
516  * command line options for path metadata to be exported
517  * as packet side_data.
518  */
519  if (!s->is_pipe && s->export_path_metadata == 1) {
520  res = add_filename_as_pkt_side_data(filename, pkt);
521  if (res < 0)
522  goto fail;
523  }
524 
525  pkt->size = 0;
526  for (i = 0; i < 3; i++) {
527  if (f[i]) {
528  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
529  if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
530  if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
531  pkt->pos = 0;
532  ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
533  }
534  }
535  if (!s->is_pipe && f[i] != s1->pb)
536  ff_format_io_close(s1, &f[i]);
537  if (ret[i] > 0)
538  pkt->size += ret[i];
539  }
540  }
541 
542  if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
543  if (ret[0] < 0) {
544  res = ret[0];
545  } else if (ret[1] < 0) {
546  res = ret[1];
547  } else if (ret[2] < 0) {
548  res = ret[2];
549  } else {
550  res = AVERROR_EOF;
551  }
552  goto fail;
553  } else {
554  s->img_count++;
555  s->img_number++;
556  s->pts++;
557  return 0;
558  }
559 
560 fail:
561  if (!s->is_pipe) {
562  for (i = 0; i < 3; i++) {
563  if (f[i] != s1->pb)
564  ff_format_io_close(s1, &f[i]);
565  }
566  }
567  return res;
568 }
569 
570 static int img_read_close(struct AVFormatContext* s1)
571 {
572 #if HAVE_GLOB
573  VideoDemuxData *s = s1->priv_data;
574  if (s->use_glob) {
575  globfree(&s->globstate);
576  }
577 #endif
578  return 0;
579 }
580 
581 static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
582 {
584  AVStream *st = s->streams[0];
585 
586  if (s1->ts_from_file) {
587  int index = av_index_search_timestamp(st, timestamp, flags);
588  if(index < 0)
589  return -1;
590  s1->img_number = st->index_entries[index].pos;
591  return 0;
592  }
593 
594  if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
595  return -1;
596  s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
597  s1->pts = timestamp;
598  return 0;
599 }
600 
601 #define OFFSET(x) offsetof(VideoDemuxData, x)
602 #define DEC AV_OPT_FLAG_DECODING_PARAM
603 #define COMMON_OPTIONS \
604  { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC }, \
605  { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
606  { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, \
607  { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
608  { NULL },
609 
610 #if CONFIG_IMAGE2_DEMUXER
611 const AVOption ff_img_options[] = {
612  { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_DEFAULT}, 0, INT_MAX, DEC, "pattern_type"},
613  { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
614  { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" },
615  { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
616  { "none", "disable pattern matching", 0, AV_OPT_TYPE_CONST, {.i64=PT_NONE }, INT_MIN, INT_MAX, DEC, "pattern_type" },
617  { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, DEC },
618  { "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 },
619  { "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" },
620  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, "ts_type" },
621  { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, "ts_type" },
622  { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, "ts_type" },
623  { "export_path_metadata", "enable metadata containing input path information", OFFSET(export_path_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC }, \
625 };
626 
627 static const AVClass img2_class = {
628  .class_name = "image2 demuxer",
629  .item_name = av_default_item_name,
630  .option = ff_img_options,
631  .version = LIBAVUTIL_VERSION_INT,
632 };
634  .name = "image2",
635  .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
636  .priv_data_size = sizeof(VideoDemuxData),
642  .flags = AVFMT_NOFILE,
643  .priv_class = &img2_class,
644 };
645 #endif
646 
648  { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
650 };
651 
652 #if CONFIG_IMAGE2PIPE_DEMUXER
653 static const AVClass img2pipe_class = {
654  .class_name = "image2pipe demuxer",
655  .item_name = av_default_item_name,
656  .option = ff_img2pipe_options,
657  .version = LIBAVUTIL_VERSION_INT,
658 };
660  .name = "image2pipe",
661  .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
662  .priv_data_size = sizeof(VideoDemuxData),
665  .priv_class = &img2pipe_class,
666 };
667 #endif
668 
669 static int bmp_probe(const AVProbeData *p)
670 {
671  const uint8_t *b = p->buf;
672  int ihsize;
673 
674  if (AV_RB16(b) != 0x424d)
675  return 0;
676 
677  ihsize = AV_RL32(b+14);
678  if (ihsize < 12 || ihsize > 255)
679  return 0;
680 
681  if (!AV_RN32(b + 6)) {
682  return AVPROBE_SCORE_EXTENSION + 1;
683  }
684  return AVPROBE_SCORE_EXTENSION / 4;
685 }
686 
687 static int dds_probe(const AVProbeData *p)
688 {
689  const uint8_t *b = p->buf;
690 
691  if ( AV_RB64(b) == 0x444453207c000000
692  && AV_RL32(b + 8)
693  && AV_RL32(b + 12))
694  return AVPROBE_SCORE_MAX - 1;
695  return 0;
696 }
697 
698 static int dpx_probe(const AVProbeData *p)
699 {
700  const uint8_t *b = p->buf;
701  int w, h;
702  int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
703 
704  if (p->buf_size < 0x304+8)
705  return 0;
706  w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
707  h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
708  if (w <= 0 || h <= 0)
709  return 0;
710 
711  if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
712  return AVPROBE_SCORE_EXTENSION + 1;
713  return 0;
714 }
715 
716 static int exr_probe(const AVProbeData *p)
717 {
718  const uint8_t *b = p->buf;
719 
720  if (AV_RL32(b) == 20000630)
721  return AVPROBE_SCORE_EXTENSION + 1;
722  return 0;
723 }
724 
725 static int j2k_probe(const AVProbeData *p)
726 {
727  const uint8_t *b = p->buf;
728 
729  if (AV_RB64(b) == 0x0000000c6a502020 ||
730  AV_RB32(b) == 0xff4fff51)
731  return AVPROBE_SCORE_EXTENSION + 1;
732  return 0;
733 }
734 
735 static int jpeg_probe(const AVProbeData *p)
736 {
737  const uint8_t *b = p->buf;
738  int i, state = SOI;
739 
740  if (AV_RB16(b) != 0xFFD8 ||
741  AV_RB32(b) == 0xFFD8FFF7)
742  return 0;
743 
744  b += 2;
745  for (i = 0; i < p->buf_size - 3; i++) {
746  int c;
747  if (b[i] != 0xFF)
748  continue;
749  c = b[i + 1];
750  switch (c) {
751  case SOI:
752  return 0;
753  case SOF0:
754  case SOF1:
755  case SOF2:
756  case SOF3:
757  case SOF5:
758  case SOF6:
759  case SOF7:
760  i += AV_RB16(&b[i + 2]) + 1;
761  if (state != SOI)
762  return 0;
763  state = SOF0;
764  break;
765  case SOS:
766  i += AV_RB16(&b[i + 2]) + 1;
767  if (state != SOF0 && state != SOS)
768  return 0;
769  state = SOS;
770  break;
771  case EOI:
772  if (state != SOS)
773  return 0;
774  state = EOI;
775  break;
776  case DQT:
777  case APP0:
778  case APP1:
779  case APP2:
780  case APP3:
781  case APP4:
782  case APP5:
783  case APP6:
784  case APP7:
785  case APP8:
786  case APP9:
787  case APP10:
788  case APP11:
789  case APP12:
790  case APP13:
791  case APP14:
792  case APP15:
793  case COM:
794  i += AV_RB16(&b[i + 2]) + 1;
795  break;
796  default:
797  if ( (c > TEM && c < SOF0)
798  || c == JPG)
799  return 0;
800  }
801  }
802 
803  if (state == EOI)
804  return AVPROBE_SCORE_EXTENSION + 1;
805  if (state == SOS)
806  return AVPROBE_SCORE_EXTENSION / 2;
807  return AVPROBE_SCORE_EXTENSION / 8;
808 }
809 
810 static int jpegls_probe(const AVProbeData *p)
811 {
812  const uint8_t *b = p->buf;
813 
814  if (AV_RB32(b) == 0xffd8fff7)
815  return AVPROBE_SCORE_EXTENSION + 1;
816  return 0;
817 }
818 
819 static int pcx_probe(const AVProbeData *p)
820 {
821  const uint8_t *b = p->buf;
822 
823  if ( p->buf_size < 128
824  || b[0] != 10
825  || b[1] > 5
826  || b[2] > 1
827  || av_popcount(b[3]) != 1 || b[3] > 8
828  || AV_RL16(&b[4]) > AV_RL16(&b[8])
829  || AV_RL16(&b[6]) > AV_RL16(&b[10])
830  || b[64])
831  return 0;
832  b += 73;
833  while (++b < p->buf + 128)
834  if (*b)
835  return AVPROBE_SCORE_EXTENSION / 4;
836 
837  return AVPROBE_SCORE_EXTENSION + 1;
838 }
839 
840 static int qdraw_probe(const AVProbeData *p)
841 {
842  const uint8_t *b = p->buf;
843 
844  if ( p->buf_size >= 528
845  && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
846  && AV_RB16(b + 520)
847  && AV_RB16(b + 518))
848  return AVPROBE_SCORE_MAX * 3 / 4;
849  if ( (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
850  && AV_RB16(b + 8)
851  && AV_RB16(b + 6))
852  return AVPROBE_SCORE_EXTENSION / 4;
853  return 0;
854 }
855 
856 static int pictor_probe(const AVProbeData *p)
857 {
858  const uint8_t *b = p->buf;
859 
860  if (AV_RL16(b) == 0x1234)
861  return AVPROBE_SCORE_EXTENSION / 4;
862  return 0;
863 }
864 
865 static int png_probe(const AVProbeData *p)
866 {
867  const uint8_t *b = p->buf;
868 
869  if (AV_RB64(b) == 0x89504e470d0a1a0a)
870  return AVPROBE_SCORE_MAX - 1;
871  return 0;
872 }
873 
874 static int psd_probe(const AVProbeData *p)
875 {
876  const uint8_t *b = p->buf;
877  int ret = 0;
878  uint16_t color_mode;
879 
880  if (AV_RL32(b) == MKTAG('8','B','P','S')) {
881  ret += 1;
882  } else {
883  return 0;
884  }
885 
886  if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
887  ret += 1;
888  } else {
889  return 0;
890  }
891 
892  if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
893  ret += 1;
894 
895  color_mode = AV_RB16(b+24);
896  if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
897  ret += 1;
898 
899  return AVPROBE_SCORE_EXTENSION + ret;
900 }
901 
902 static int sgi_probe(const AVProbeData *p)
903 {
904  const uint8_t *b = p->buf;
905 
906  if (AV_RB16(b) == 474 &&
907  (b[2] & ~1) == 0 &&
908  (b[3] & ~3) == 0 && b[3] &&
909  (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
910  return AVPROBE_SCORE_EXTENSION + 1;
911  return 0;
912 }
913 
914 static int sunrast_probe(const AVProbeData *p)
915 {
916  const uint8_t *b = p->buf;
917 
918  if (AV_RB32(b) == 0x59a66a95)
919  return AVPROBE_SCORE_EXTENSION + 1;
920  return 0;
921 }
922 
923 static int svg_probe(const AVProbeData *p)
924 {
925  const uint8_t *b = p->buf;
926  const uint8_t *end = p->buf + p->buf_size;
927 
928  if (memcmp(p->buf, "<?xml", 5))
929  return 0;
930  while (b < end) {
931  int inc = ff_subtitles_next_line(b);
932  if (!inc)
933  break;
934  b += inc;
935  if (b >= end - 4)
936  return 0;
937  if (!memcmp(b, "<svg", 4))
938  return AVPROBE_SCORE_EXTENSION + 1;
939  }
940  return 0;
941 }
942 
943 static int tiff_probe(const AVProbeData *p)
944 {
945  const uint8_t *b = p->buf;
946 
947  if (AV_RB32(b) == 0x49492a00 ||
948  AV_RB32(b) == 0x4D4D002a)
949  return AVPROBE_SCORE_EXTENSION + 1;
950  return 0;
951 }
952 
953 static int webp_probe(const AVProbeData *p)
954 {
955  const uint8_t *b = p->buf;
956 
957  if (AV_RB32(b) == 0x52494646 &&
958  AV_RB32(b + 8) == 0x57454250)
959  return AVPROBE_SCORE_MAX - 1;
960  return 0;
961 }
962 
963 static int pnm_magic_check(const AVProbeData *p, int magic)
964 {
965  const uint8_t *b = p->buf;
966 
967  return b[0] == 'P' && b[1] == magic + '0';
968 }
969 
970 static inline int pnm_probe(const AVProbeData *p)
971 {
972  const uint8_t *b = p->buf;
973 
974  while (b[2] == '\r')
975  b++;
976  if (b[2] == '\n' && (b[3] == '#' || (b[3] >= '0' && b[3] <= '9')))
977  return AVPROBE_SCORE_EXTENSION + 2;
978  return 0;
979 }
980 
981 static int pbm_probe(const AVProbeData *p)
982 {
983  return pnm_magic_check(p, 1) || pnm_magic_check(p, 4) ? pnm_probe(p) : 0;
984 }
985 
986 static inline int pgmx_probe(const AVProbeData *p)
987 {
988  return pnm_magic_check(p, 2) || pnm_magic_check(p, 5) ? pnm_probe(p) : 0;
989 }
990 
991 static int pgm_probe(const AVProbeData *p)
992 {
993  int ret = pgmx_probe(p);
994  return ret && !av_match_ext(p->filename, "pgmyuv") ? ret : 0;
995 }
996 
997 static int pgmyuv_probe(const AVProbeData *p) // custom FFmpeg format recognized by file extension
998 {
999  int ret = pgmx_probe(p);
1000  return ret && av_match_ext(p->filename, "pgmyuv") ? ret : 0;
1001 }
1002 
1003 static int pgx_probe(const AVProbeData *p)
1004 {
1005  const uint8_t *b = p->buf;
1006  if (!memcmp(b, "PG ML ", 6))
1007  return AVPROBE_SCORE_EXTENSION + 1;
1008  return 0;
1009 }
1010 
1011 static int ppm_probe(const AVProbeData *p)
1012 {
1013  return pnm_magic_check(p, 3) || pnm_magic_check(p, 6) ? pnm_probe(p) : 0;
1014 }
1015 
1016 static int pam_probe(const AVProbeData *p)
1017 {
1018  return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
1019 }
1020 
1021 static int xpm_probe(const AVProbeData *p)
1022 {
1023  const uint8_t *b = p->buf;
1024 
1025  if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
1026  return AVPROBE_SCORE_MAX - 1;
1027  return 0;
1028 }
1029 
1030 static int xwd_probe(const AVProbeData *p)
1031 {
1032  const uint8_t *b = p->buf;
1033  unsigned width, bpp, bpad, lsize;
1034 
1035  if ( p->buf_size < XWD_HEADER_SIZE
1036  || AV_RB32(b ) < XWD_HEADER_SIZE // header size
1037  || AV_RB32(b + 4) != XWD_VERSION // version
1038  || AV_RB32(b + 8) != XWD_Z_PIXMAP // format
1039  || AV_RB32(b + 12) > 32 || !AV_RB32(b + 12) // depth
1040  || AV_RB32(b + 16) == 0 // width
1041  || AV_RB32(b + 20) == 0 // height
1042  || AV_RB32(b + 28) > 1 // byteorder
1043  || AV_RB32(b + 32) & ~56 || av_popcount(AV_RB32(b + 32)) != 1 // bitmap unit
1044  || AV_RB32(b + 36) > 1 // bitorder
1045  || AV_RB32(b + 40) & ~56 || av_popcount(AV_RB32(b + 40)) != 1 // padding
1046  || AV_RB32(b + 44) > 32 || !AV_RB32(b + 44) // bpp
1047  || AV_RB32(b + 68) > 256) // colours
1048  return 0;
1049 
1050  width = AV_RB32(b + 16);
1051  bpad = AV_RB32(b + 40);
1052  bpp = AV_RB32(b + 44);
1053  lsize = AV_RB32(b + 48);
1054  if (lsize < FFALIGN(width * bpp, bpad) >> 3)
1055  return 0;
1056 
1057  return AVPROBE_SCORE_MAX / 2 + 1;
1058 }
1059 
1060 static int gif_probe(const AVProbeData *p)
1061 {
1062  /* check magick */
1063  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
1064  return 0;
1065 
1066  /* width or height contains zero? */
1067  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
1068  return 0;
1069 
1070  return AVPROBE_SCORE_MAX - 1;
1071 }
1072 
1073 static int photocd_probe(const AVProbeData *p)
1074 {
1075  if (!memcmp(p->buf, "PCD_OPA", 7))
1076  return AVPROBE_SCORE_MAX - 1;
1077 
1078  if (p->buf_size < 0x807 || memcmp(p->buf + 0x800, "PCD_IPI", 7))
1079  return 0;
1080 
1081  return AVPROBE_SCORE_MAX - 1;
1082 }
1083 
1084 #define IMAGEAUTO_DEMUXER(imgname, codecid)\
1085 static const AVClass imgname ## _class = {\
1086  .class_name = AV_STRINGIFY(imgname) " demuxer",\
1087  .item_name = av_default_item_name,\
1088  .option = ff_img2pipe_options,\
1089  .version = LIBAVUTIL_VERSION_INT,\
1090 };\
1091 AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
1092  .name = AV_STRINGIFY(imgname) "_pipe",\
1093  .long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
1094  .priv_data_size = sizeof(VideoDemuxData),\
1095  .read_probe = imgname ## _probe,\
1096  .read_header = ff_img_read_header,\
1097  .read_packet = ff_img_read_packet,\
1098  .priv_class = & imgname ## _class,\
1099  .flags = AVFMT_GENERIC_INDEX, \
1100  .raw_codec_id = codecid,\
1101 };
1102 
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:708
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:1933
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 img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: img2dec.c:581
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
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:1983
#define OFFSET(x)
Definition: img2dec.c:601
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:923
#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:383
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:1084
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:4869
int64_t pos
Definition: avformat.h:805
static int psd_probe(const AVProbeData *p)
Definition: img2dec.c:874
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:570
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:364
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
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1105
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:341
const AVOption ff_img_options[]
static AVPacket pkt
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1400
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
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:687
char * pixel_format
Set by a private option.
Definition: img2.h:51
static int pgmyuv_probe(const AVProbeData *p)
Definition: img2dec.c:997
#define IMAGEAUTO_DEMUXER(imgname, codecid)
Definition: img2dec.c:1084
Format I/O context.
Definition: avformat.h:1351
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:482
static int pam_probe(const AVProbeData *p)
Definition: img2dec.c:1016
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:669
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:381
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:1295
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:664
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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:1094
static int pictor_probe(const AVProbeData *p)
Definition: img2dec.c:856
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5616
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:4450
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:1419
Definition: mjpeg.h:86
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
uint8_t * data
Definition: packet.h:363
static int pcx_probe(const AVProbeData *p)
Definition: img2dec.c:819
#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
#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:1537
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
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:88
#define AVINDEX_KEYFRAME
Definition: avformat.h:812
#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:2100
Definition: mjpeg.h:89
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:153
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1363
char * url
input or output URL.
Definition: avformat.h:1447
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:698
static int xpm_probe(const AVProbeData *p)
Definition: img2dec.c:1021
static int pgmx_probe(const AVProbeData *p)
Definition: img2dec.c:986
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:123
Definition: mjpeg.h:39
static int j2k_probe(const AVProbeData *p)
Definition: img2dec.c:725
Definition: mjpeg.h:70
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
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
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:1073
static struct @322 state
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1543
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:38
Definition: mjpeg.h:91
Definition: mjpeg.h:41
int width
Definition: img2.h:52
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:1490
Definition: mjpeg.h:83
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:547
int start_number
Definition: img2.h:60
static int sunrast_probe(const AVProbeData *p)
Definition: img2dec.c:914
#define FF_ARRAY_ELEMS(a)
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:4718
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:876
#define DEC
Definition: img2dec.c:602
int frame_size
Definition: img2.h:62
static int sgi_probe(const AVProbeData *p)
Definition: img2dec.c:902
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:1030
Definition: mjpeg.h:88
static int jpeg_probe(const AVProbeData *p)
Definition: img2dec.c:735
int frame_size
Definition: mxfenc.c:2166
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
A list of zero terminated key/value strings.
Definition: packet.h:172
AVInputFormat ff_image2pipe_demuxer
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
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:725
int split_planes
use independent file for each Y, U, V plane
Definition: img2.h:49
GIF format definitions.
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, int *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:495
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:322
static int pgm_probe(const AVProbeData *p)
Definition: img2dec.c:991
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
int index
Definition: gxfenc.c:89
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:298
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:1003
#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:970
int img_last
Definition: img2.h:44
int raw_codec_id
Raw demuxers store their codec ID here.
Definition: avformat.h:696
Definition: mjpeg.h:47
#define flags(name, subs,...)
Definition: cbs_av1.c:560
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:716
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:925
Definition: mjpeg.h:94
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
full parsing and repack
Definition: avformat.h:795
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:840
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:915
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:105
#define COMMON_OPTIONS
Definition: img2dec.c:603
static int gif_probe(const AVProbeData *p)
Definition: img2dec.c:1060
static int tiff_probe(const AVProbeData *p)
Definition: img2dec.c:943
#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:715
AVRational framerate
Set by a private option.
Definition: img2.h:53
static int ppm_probe(const AVProbeData *p)
Definition: img2dec.c:1011
struct AVCodecParserContext * parser
Definition: avformat.h:1095
void * priv_data
Format private data.
Definition: avformat.h:1379
const AVOption ff_img2pipe_options[]
Definition: img2dec.c:647
static int pbm_probe(const AVProbeData *p)
Definition: img2dec.c:981
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:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
Definition: mjpeg.h:82
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
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:963
int stream_index
Definition: packet.h:365
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:406
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:340
static int png_probe(const AVProbeData *p)
Definition: img2dec.c:865
static int jpegls_probe(const AVProbeData *p)
Definition: img2dec.c:810
static int webp_probe(const AVProbeData *p)
Definition: img2dec.c:953
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: img2dec.c:402