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