Merge commit 'e4dc1000d7bbbcb5b45cf9849fc5315f19578e37'
[ffmpeg.git] / libavformat / img2dec.c
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 _BSD_SOURCE
24 #include <sys/stat.h>
25 #include "libavutil/avstring.h"
26 #include "libavutil/log.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/parseutils.h"
30 #include "avformat.h"
31 #include "internal.h"
32 #include "img2.h"
33
34 #if HAVE_GLOB
35 /* Locally define as 0 (bitwise-OR no-op) any missing glob options that
36    are non-posix glibc/bsd extensions. */
37 #ifndef GLOB_NOMAGIC
38 #define GLOB_NOMAGIC 0
39 #endif
40 #ifndef GLOB_BRACE
41 #define GLOB_BRACE 0
42 #endif
43
44 #endif /* HAVE_GLOB */
45
46 static const int sizes[][2] = {
47     { 640, 480 },
48     { 720, 480 },
49     { 720, 576 },
50     { 352, 288 },
51     { 352, 240 },
52     { 160, 128 },
53     { 512, 384 },
54     { 640, 352 },
55     { 640, 240 },
56 };
57
58 static int infer_size(int *width_ptr, int *height_ptr, int size)
59 {
60     int i;
61
62     for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
63         if ((sizes[i][0] * sizes[i][1]) == size) {
64             *width_ptr  = sizes[i][0];
65             *height_ptr = sizes[i][1];
66             return 0;
67         }
68     }
69
70     return -1;
71 }
72
73 static int is_glob(const char *path)
74 {
75 #if HAVE_GLOB
76     size_t span = 0;
77     const char *p = path;
78
79     while (p = strchr(p, '%')) {
80         if (*(++p) == '%') {
81             ++p;
82             continue;
83         }
84         if (span = strspn(p, "*?[]{}"))
85             break;
86     }
87     /* Did we hit a glob char or get to the end? */
88     return span != 0;
89 #else
90     return 0;
91 #endif
92 }
93
94 /**
95  * Get index range of image files matched by path.
96  *
97  * @param pfirst_index pointer to index updated with the first number in the range
98  * @param plast_index  pointer to index updated with the last number in the range
99  * @param path         path which has to be matched by the image files in the range
100  * @param start_index  minimum accepted value for the first index in the range
101  * @return -1 if no image file could be found
102  */
103 static int find_image_range(int *pfirst_index, int *plast_index,
104                             const char *path, int start_index, int start_index_range)
105 {
106     char buf[1024];
107     int range, last_index, range1, first_index;
108
109     /* find the first image */
110     for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
111         if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
112             *pfirst_index =
113             *plast_index  = 1;
114             if (avio_check(buf, AVIO_FLAG_READ) > 0)
115                 return 0;
116             return -1;
117         }
118         if (avio_check(buf, AVIO_FLAG_READ) > 0)
119             break;
120     }
121     if (first_index == start_index + start_index_range)
122         goto fail;
123
124     /* find the last image */
125     last_index = first_index;
126     for (;;) {
127         range = 0;
128         for (;;) {
129             if (!range)
130                 range1 = 1;
131             else
132                 range1 = 2 * range;
133             if (av_get_frame_filename(buf, sizeof(buf), path,
134                                       last_index + range1) < 0)
135                 goto fail;
136             if (avio_check(buf, AVIO_FLAG_READ) <= 0)
137                 break;
138             range = range1;
139             /* just in case... */
140             if (range >= (1 << 30))
141                 goto fail;
142         }
143         /* we are sure than image last_index + range exists */
144         if (!range)
145             break;
146         last_index += range;
147     }
148     *pfirst_index = first_index;
149     *plast_index  = last_index;
150     return 0;
151
152 fail:
153     return -1;
154 }
155
156 static int img_read_probe(AVProbeData *p)
157 {
158     if (p->filename && ff_guess_image2_codec(p->filename)) {
159         if (av_filename_number_test(p->filename))
160             return AVPROBE_SCORE_MAX;
161         else if (is_glob(p->filename))
162             return AVPROBE_SCORE_MAX;
163         else if (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif"))
164             return 5;
165         else
166             return AVPROBE_SCORE_EXTENSION;
167     }
168     return 0;
169 }
170
171 int ff_img_read_header(AVFormatContext *s1)
172 {
173     VideoDemuxData *s = s1->priv_data;
174     int first_index, last_index;
175     AVStream *st;
176     enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
177
178     s1->ctx_flags |= AVFMTCTX_NOHEADER;
179
180     st = avformat_new_stream(s1, NULL);
181     if (!st) {
182         return AVERROR(ENOMEM);
183     }
184
185     if (s->pixel_format &&
186         (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) {
187         av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n",
188                s->pixel_format);
189         return AVERROR(EINVAL);
190     }
191
192     av_strlcpy(s->path, s1->filename, sizeof(s->path));
193     s->img_number = 0;
194     s->img_count  = 0;
195
196     /* find format */
197     if (s1->iformat->flags & AVFMT_NOFILE)
198         s->is_pipe = 0;
199     else {
200         s->is_pipe       = 1;
201         st->need_parsing = AVSTREAM_PARSE_FULL;
202     }
203
204     if (s->ts_from_file == 2) {
205 #if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
206         av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n");
207         return AVERROR(ENOSYS);
208 #endif
209         avpriv_set_pts_info(st, 64, 1, 1000000000);
210     } else if (s->ts_from_file)
211         avpriv_set_pts_info(st, 64, 1, 1);
212     else
213         avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
214
215     if (s->width && s->height) {
216         st->codec->width  = s->width;
217         st->codec->height = s->height;
218     }
219
220     if (!s->is_pipe) {
221         if (s->pattern_type == PT_GLOB_SEQUENCE) {
222         s->use_glob = is_glob(s->path);
223         if (s->use_glob) {
224             char *p = s->path, *q, *dup;
225             int gerr;
226
227             av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
228                    "use pattern_type 'glob' instead\n");
229 #if HAVE_GLOB
230             dup = q = av_strdup(p);
231             while (*q) {
232                 /* Do we have room for the next char and a \ insertion? */
233                 if ((p - s->path) >= (sizeof(s->path) - 2))
234                   break;
235                 if (*q == '%' && strspn(q + 1, "%*?[]{}"))
236                     ++q;
237                 else if (strspn(q, "\\*?[]{}"))
238                     *p++ = '\\';
239                 *p++ = *q++;
240             }
241             *p = 0;
242             av_free(dup);
243
244             gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
245             if (gerr != 0) {
246                 return AVERROR(ENOENT);
247             }
248             first_index = 0;
249             last_index = s->globstate.gl_pathc - 1;
250 #endif
251         }
252         }
253         if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
254             if (find_image_range(&first_index, &last_index, s->path,
255                                  s->start_number, s->start_number_range) < 0) {
256                 av_log(s1, AV_LOG_ERROR,
257                        "Could find no file with path '%s' and index in the range %d-%d\n",
258                        s->path, s->start_number, s->start_number + s->start_number_range - 1);
259                 return AVERROR(ENOENT);
260             }
261         } else if (s->pattern_type == PT_GLOB) {
262 #if HAVE_GLOB
263             int gerr;
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             s->use_glob = 1;
271 #else
272             av_log(s1, AV_LOG_ERROR,
273                    "Pattern type 'glob' was selected but globbing "
274                    "is not supported by this libavformat build\n");
275             return AVERROR(ENOSYS);
276 #endif
277         } else if (s->pattern_type != PT_GLOB_SEQUENCE) {
278             av_log(s1, AV_LOG_ERROR,
279                    "Unknown value '%d' for pattern_type option\n", s->pattern_type);
280             return AVERROR(EINVAL);
281         }
282         s->img_first  = first_index;
283         s->img_last   = last_index;
284         s->img_number = first_index;
285         /* compute duration */
286         if (!s->ts_from_file) {
287             st->start_time = 0;
288             st->duration   = last_index - first_index + 1;
289         }
290     }
291
292     if (s1->video_codec_id) {
293         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
294         st->codec->codec_id   = s1->video_codec_id;
295     } else if (s1->audio_codec_id) {
296         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
297         st->codec->codec_id   = s1->audio_codec_id;
298     } else if (s1->iformat->raw_codec_id) {
299         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
300         st->codec->codec_id   = s1->iformat->raw_codec_id;
301     } else {
302         const char *str = strrchr(s->path, '.');
303         s->split_planes       = str && !av_strcasecmp(str + 1, "y");
304         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
305         st->codec->codec_id   = ff_guess_image2_codec(s->path);
306         if (st->codec->codec_id == AV_CODEC_ID_LJPEG)
307             st->codec->codec_id = AV_CODEC_ID_MJPEG;
308         if (st->codec->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
309             st->codec->codec_id = AV_CODEC_ID_NONE;
310     }
311     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
312         pix_fmt != AV_PIX_FMT_NONE)
313         st->codec->pix_fmt = pix_fmt;
314
315     return 0;
316 }
317
318 int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
319 {
320     VideoDemuxData *s = s1->priv_data;
321     char filename_bytes[1024];
322     char *filename = filename_bytes;
323     int i;
324     int size[3]           = { 0 }, ret[3] = { 0 };
325     AVIOContext *f[3]     = { NULL };
326     AVCodecContext *codec = s1->streams[0]->codec;
327
328     if (!s->is_pipe) {
329         /* loop over input */
330         if (s->loop && s->img_number > s->img_last) {
331             s->img_number = s->img_first;
332         }
333         if (s->img_number > s->img_last)
334             return AVERROR_EOF;
335         if (s->use_glob) {
336 #if HAVE_GLOB
337             filename = s->globstate.gl_pathv[s->img_number];
338 #endif
339         } else {
340         if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
341                                   s->path,
342                                   s->img_number) < 0 && s->img_number > 1)
343             return AVERROR(EIO);
344         }
345         for (i = 0; i < 3; i++) {
346             if (avio_open2(&f[i], filename, AVIO_FLAG_READ,
347                            &s1->interrupt_callback, NULL) < 0) {
348                 if (i >= 1)
349                     break;
350                 av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
351                        filename);
352                 return AVERROR(EIO);
353             }
354             size[i] = avio_size(f[i]);
355
356             if (!s->split_planes)
357                 break;
358             filename[strlen(filename) - 1] = 'U' + i;
359         }
360
361         if (codec->codec_id == AV_CODEC_ID_NONE) {
362             AVProbeData pd;
363             AVInputFormat *ifmt;
364             uint8_t header[PROBE_BUF_MIN + AVPROBE_PADDING_SIZE];
365             int ret;
366             int score = 0;
367
368             ret = avio_read(f[0], header, PROBE_BUF_MIN);
369             if (ret < 0)
370                 return ret;
371             memset(header + ret, 0, sizeof(header) - ret);
372             avio_skip(f[0], -ret);
373             pd.buf = header;
374             pd.buf_size = ret;
375             pd.filename = filename;
376
377             ifmt = av_probe_input_format3(&pd, 1, &score);
378             if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
379                 codec->codec_id = ifmt->raw_codec_id;
380         }
381
382         if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width)
383             infer_size(&codec->width, &codec->height, size[0]);
384     } else {
385         f[0] = s1->pb;
386         if (url_feof(f[0]))
387             return AVERROR(EIO);
388         if (s->frame_size > 0) {
389             size[0] = s->frame_size;
390         } else {
391             size[0] = 4096;
392         }
393     }
394
395     if (av_new_packet(pkt, size[0] + size[1] + size[2]) < 0)
396         return AVERROR(ENOMEM);
397     pkt->stream_index = 0;
398     pkt->flags       |= AV_PKT_FLAG_KEY;
399     if (s->ts_from_file) {
400         struct stat img_stat;
401         if (stat(filename, &img_stat))
402             return AVERROR(EIO);
403         pkt->pts = (int64_t)img_stat.st_mtime;
404 #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
405         if (s->ts_from_file == 2)
406             pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
407 #endif
408         av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
409     } else if (!s->is_pipe) {
410         pkt->pts      = s->pts;
411     }
412
413     pkt->size = 0;
414     for (i = 0; i < 3; i++) {
415         if (f[i]) {
416             ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
417             if (!s->is_pipe)
418                 avio_close(f[i]);
419             if (ret[i] > 0)
420                 pkt->size += ret[i];
421         }
422     }
423
424     if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
425         av_free_packet(pkt);
426         return AVERROR(EIO); /* signal EOF */
427     } else {
428         s->img_count++;
429         s->img_number++;
430         s->pts++;
431         return 0;
432     }
433 }
434
435 static int img_read_close(struct AVFormatContext* s1)
436 {
437     VideoDemuxData *s = s1->priv_data;
438 #if HAVE_GLOB
439     if (s->use_glob) {
440         globfree(&s->globstate);
441     }
442 #endif
443     return 0;
444 }
445
446 static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
447 {
448     VideoDemuxData *s1 = s->priv_data;
449     AVStream *st = s->streams[0];
450
451     if (s1->ts_from_file) {
452         int index = av_index_search_timestamp(st, timestamp, flags);
453         if(index < 0)
454             return -1;
455         s1->img_number = st->index_entries[index].pos;
456         return 0;
457     }
458
459     if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
460         return -1;
461     s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
462     s1->pts = timestamp;
463     return 0;
464 }
465
466 #define OFFSET(x) offsetof(VideoDemuxData, x)
467 #define DEC AV_OPT_FLAG_DECODING_PARAM
468 static const AVOption options[] = {
469     { "framerate",    "set the video framerate",             OFFSET(framerate),    AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0,   DEC },
470     { "loop",         "force loop over input file sequence", OFFSET(loop),         AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, 1,       DEC },
471
472     { "pattern_type", "set pattern type",                    OFFSET(pattern_type), AV_OPT_TYPE_INT,    {.i64=PT_GLOB_SEQUENCE}, 0,       INT_MAX, DEC, "pattern_type"},
473     { "glob_sequence","select glob/sequence pattern type",   0, AV_OPT_TYPE_CONST,  {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
474     { "glob",         "select glob pattern type",            0, AV_OPT_TYPE_CONST,  {.i64=PT_GLOB         }, INT_MIN, INT_MAX, DEC, "pattern_type" },
475     { "sequence",     "select sequence pattern type",        0, AV_OPT_TYPE_CONST,  {.i64=PT_SEQUENCE     }, INT_MIN, INT_MAX, DEC, "pattern_type" },
476
477     { "pixel_format", "set video pixel format",              OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0,       DEC },
478     { "start_number", "set first number in the sequence",    OFFSET(start_number), AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, INT_MAX, DEC },
479     { "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 },
480     { "video_size",   "set video size",                      OFFSET(width),        AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0,   DEC },
481     { "frame_size",   "force frame size in bytes",           OFFSET(frame_size),   AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, INT_MAX, DEC },
482     { "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" },
483     { "none", "none",                   0, AV_OPT_TYPE_CONST,    {.i64 = 0   }, 0, 2,       DEC, "ts_type" },
484     { "sec",  "second precision",       0, AV_OPT_TYPE_CONST,    {.i64 = 1   }, 0, 2,       DEC, "ts_type" },
485     { "ns",   "nano second precision",  0, AV_OPT_TYPE_CONST,    {.i64 = 2   }, 0, 2,       DEC, "ts_type" },
486     { NULL },
487 };
488
489 #if CONFIG_IMAGE2_DEMUXER
490 static const AVClass img2_class = {
491     .class_name = "image2 demuxer",
492     .item_name  = av_default_item_name,
493     .option     = options,
494     .version    = LIBAVUTIL_VERSION_INT,
495 };
496 AVInputFormat ff_image2_demuxer = {
497     .name           = "image2",
498     .long_name      = NULL_IF_CONFIG_SMALL("image2 sequence"),
499     .priv_data_size = sizeof(VideoDemuxData),
500     .read_probe     = img_read_probe,
501     .read_header    = ff_img_read_header,
502     .read_packet    = ff_img_read_packet,
503     .read_close     = img_read_close,
504     .read_seek      = img_read_seek,
505     .flags          = AVFMT_NOFILE,
506     .priv_class     = &img2_class,
507 };
508 #endif
509 #if CONFIG_IMAGE2PIPE_DEMUXER
510 static const AVClass img2pipe_class = {
511     .class_name = "image2pipe demuxer",
512     .item_name  = av_default_item_name,
513     .option     = options,
514     .version    = LIBAVUTIL_VERSION_INT,
515 };
516 AVInputFormat ff_image2pipe_demuxer = {
517     .name           = "image2pipe",
518     .long_name      = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
519     .priv_data_size = sizeof(VideoDemuxData),
520     .read_header    = ff_img_read_header,
521     .read_packet    = ff_img_read_packet,
522     .priv_class     = &img2pipe_class,
523 };
524 #endif