integer overflows, heap corruption
[ffmpeg.git] / libavformat / img2.c
1 /*
2  * Image format
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4  * Copyright (c) 2004 Michael Niedermayer
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 #include "avformat.h"
21
22 /* XXX: this is a hack */
23 extern int loop_input;
24
25 typedef struct {
26     int img_first;
27     int img_last;
28     int img_number;
29     int img_count;
30     int is_pipe;
31     char path[1024];
32 } VideoData;
33
34 typedef struct {
35     enum CodecID id;
36     const char *str;
37 } IdStrMap;
38
39 static const IdStrMap img_tags[] = {
40     { CODEC_ID_MJPEG     , "jpeg"},
41     { CODEC_ID_MJPEG     , "jpg"},
42     { CODEC_ID_LJPEG     , "ljpg"},
43     { CODEC_ID_PNG       , "png"},
44     { CODEC_ID_PPM       , "ppm"},
45     { CODEC_ID_PGM       , "pgm"},
46     { CODEC_ID_PGMYUV    , "pgmyuv"},
47     { CODEC_ID_PBM       , "pbm"},
48     { CODEC_ID_PAM       , "pam"},
49     { CODEC_ID_MPEG1VIDEO, "mpg1-img"},
50     { CODEC_ID_MPEG2VIDEO, "mpg2-img"},
51     { CODEC_ID_MPEG4     , "mpg4-img"},
52     { CODEC_ID_FFV1      , "ffv1-img"},
53     { CODEC_ID_RAWVIDEO  , "y"},
54     {0, NULL}
55 };
56
57 static int sizes[][2] = {
58     { 640, 480 },
59     { 720, 480 },
60     { 720, 576 },
61     { 352, 288 },
62     { 352, 240 },
63     { 160, 128 },
64     { 512, 384 },
65     { 640, 352 },
66     { 640, 240 },
67 };
68
69 static int infer_size(int *width_ptr, int *height_ptr, int size)
70 {
71     int i;
72
73     for(i=0;i<sizeof(sizes)/sizeof(sizes[0]);i++) {
74         if ((sizes[i][0] * sizes[i][1]) == size) {
75             *width_ptr = sizes[i][0];
76             *height_ptr = sizes[i][1];
77             return 0;
78         }
79     }
80     return -1;
81 }
82 static enum CodecID av_str2id(const IdStrMap *tags, const char *str)
83 {
84     str= strrchr(str, '.');
85     if(!str) return CODEC_ID_NONE;
86     str++;
87
88     while (tags->id) {
89         int i;
90         for(i=0; toupper(tags->str[i]) == toupper(str[i]); i++){
91             if(tags->str[i]==0 && str[i]==0)
92                 return tags->id;
93         }
94
95         tags++;
96     }
97     return CODEC_ID_NONE;
98 }
99
100 static const char *av_id2str(const IdStrMap *tags, enum CodecID id)
101 {
102     while (tags->id) {
103         if(tags->id == id)
104             return tags->str;
105         tags++;
106     }
107     return NULL;
108 }
109
110 /* return -1 if no image found */
111 static int find_image_range(int *pfirst_index, int *plast_index, 
112                             const char *path)
113 {
114     char buf[1024];
115     int range, last_index, range1, first_index;
116
117     /* find the first image */
118     for(first_index = 0; first_index < 5; first_index++) {
119         if (get_frame_filename(buf, sizeof(buf), path, first_index) < 0){
120             *pfirst_index = 
121             *plast_index = 1;
122             return 0;
123         }
124         if (url_exist(buf))
125             break;
126     }
127     if (first_index == 5)
128         goto fail;
129     
130     /* find the last image */
131     last_index = first_index;
132     for(;;) {
133         range = 0;
134         for(;;) {
135             if (!range)
136                 range1 = 1;
137             else
138                 range1 = 2 * range;
139             if (get_frame_filename(buf, sizeof(buf), path, 
140                                    last_index + range1) < 0)
141                 goto fail;
142             if (!url_exist(buf))
143                 break;
144             range = range1;
145             /* just in case... */
146             if (range >= (1 << 30))
147                 goto fail;
148         }
149         /* we are sure than image last_index + range exists */
150         if (!range)
151             break;
152         last_index += range;
153     }
154     *pfirst_index = first_index;
155     *plast_index = last_index;
156     return 0;
157  fail:
158     return -1;
159 }
160
161
162 static int image_probe(AVProbeData *p)
163 {
164     if (filename_number_test(p->filename) >= 0 && av_str2id(img_tags, p->filename))
165         return AVPROBE_SCORE_MAX;
166     else
167         return 0;
168 }
169
170 enum CodecID av_guess_image2_codec(const char *filename){
171     return av_str2id(img_tags, filename);
172 }
173
174 static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
175 {
176     VideoData *s = s1->priv_data;
177     int first_index, last_index;
178     AVStream *st;
179
180     s1->ctx_flags |= AVFMTCTX_NOHEADER;
181
182     st = av_new_stream(s1, 0);
183     if (!st) {
184         return -ENOMEM;
185     }
186
187     pstrcpy(s->path, sizeof(s->path), s1->filename);
188     s->img_number = 0;
189     s->img_count = 0;
190     
191     /* find format */
192     if (s1->iformat->flags & AVFMT_NOFILE)
193         s->is_pipe = 0;
194     else{
195         s->is_pipe = 1;
196         st->need_parsing= 1;
197     }
198         
199     if (!ap || !ap->frame_rate) {
200         st->codec.frame_rate      = 25;
201         st->codec.frame_rate_base = 1;
202     } else {
203         st->codec.frame_rate      = ap->frame_rate;
204         st->codec.frame_rate_base = ap->frame_rate_base;
205     }
206     
207     if(ap && ap->width && ap->height){
208         st->codec.width = ap->width;
209         st->codec.height= ap->height;
210     }
211     
212     if (!s->is_pipe) {
213         if (find_image_range(&first_index, &last_index, s->path) < 0)
214             return AVERROR_IO;
215         s->img_first = first_index;
216         s->img_last = last_index;
217         s->img_number = first_index;
218         /* compute duration */
219         st->start_time = 0;
220         st->duration = ((int64_t)AV_TIME_BASE * 
221                         (last_index - first_index + 1) * 
222                         st->codec.frame_rate_base) / st->codec.frame_rate;
223     }
224     
225     if(ap->video_codec_id){
226         st->codec.codec_type = CODEC_TYPE_VIDEO;
227         st->codec.codec_id = ap->video_codec_id;
228     }else if(ap->audio_codec_id){
229         st->codec.codec_type = CODEC_TYPE_AUDIO;
230         st->codec.codec_id = ap->audio_codec_id;
231     }else{
232         st->codec.codec_type = CODEC_TYPE_VIDEO;
233         st->codec.codec_id = av_str2id(img_tags, s->path);
234     }
235
236     return 0;
237 }
238
239 static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
240 {
241     VideoData *s = s1->priv_data;
242     char filename[1024];
243     int i;
244     int size[3]={0}, ret[3]={0};
245     ByteIOContext f1[3], *f[3]= {&f1[0], &f1[1], &f1[2]};
246     AVCodecContext *codec= &s1->streams[0]->codec;
247
248     if (!s->is_pipe) {
249         /* loop over input */
250         if (loop_input && s->img_number > s->img_last) {
251             s->img_number = s->img_first;
252         }
253         if (get_frame_filename(filename, sizeof(filename),
254                                s->path, s->img_number)<0 && s->img_number > 1)
255             return AVERROR_IO;
256         for(i=0; i<3; i++){
257             if (url_fopen(f[i], filename, URL_RDONLY) < 0)
258                 return AVERROR_IO;
259             size[i]= url_filesize(url_fileno(f[i]));
260             
261             if(codec->codec_id != CODEC_ID_RAWVIDEO)
262                 break;
263             filename[ strlen(filename) - 1 ]= 'U' + i;
264         }
265         
266         if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)
267             infer_size(&codec->width, &codec->height, size[0]);
268     } else {
269         f[0] = &s1->pb;
270         if (url_feof(f[0]))
271             return AVERROR_IO;
272         size[0]= 4096;
273     }
274
275     av_new_packet(pkt, size[0] + size[1] + size[2]);
276     pkt->stream_index = 0;
277     pkt->flags |= PKT_FLAG_KEY;
278
279     pkt->size= 0;
280     for(i=0; i<3; i++){
281         if(size[i]){
282             ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);
283             if (!s->is_pipe)
284                 url_fclose(f[i]);
285             if(ret[i]>0)
286                 pkt->size += ret[i];
287         }
288     }
289
290     if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {
291         av_free_packet(pkt);
292         return AVERROR_IO; /* signal EOF */
293     } else {
294         s->img_count++;
295         s->img_number++;
296         return 0;
297     }
298 }
299
300 static int img_read_close(AVFormatContext *s1)
301 {
302     return 0;
303 }
304
305 /******************************************************/
306 /* image output */
307
308 static int img_write_header(AVFormatContext *s)
309 {
310     VideoData *img = s->priv_data;
311
312     img->img_number = 1;
313     pstrcpy(img->path, sizeof(img->path), s->filename);
314
315     /* find format */
316     if (s->oformat->flags & AVFMT_NOFILE)
317         img->is_pipe = 0;
318     else
319         img->is_pipe = 1;
320         
321     return 0;
322 }
323
324 static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
325 {
326     VideoData *img = s->priv_data;
327     ByteIOContext pb1[3], *pb[3]= {&pb1[0], &pb1[1], &pb1[2]};
328     char filename[1024];
329     AVCodecContext *codec= &s->streams[ pkt->stream_index ]->codec;
330     int i;
331
332     if (!img->is_pipe) {
333         if (get_frame_filename(filename, sizeof(filename), 
334                                img->path, img->img_number) < 0 && img->img_number>1)
335             return AVERROR_IO;
336         for(i=0; i<3; i++){
337             if (url_fopen(pb[i], filename, URL_WRONLY) < 0)
338                 return AVERROR_IO;
339         
340             if(codec->codec_id != CODEC_ID_RAWVIDEO)
341                 break;
342             filename[ strlen(filename) - 1 ]= 'U' + i;
343         }
344     } else {
345         pb[0] = &s->pb;
346     }
347     
348     if(codec->codec_id == CODEC_ID_RAWVIDEO){
349         int size = (codec->width * codec->height)>>2;
350         put_buffer(pb[0], pkt->data         , 4*size);
351         put_buffer(pb[1], pkt->data + 4*size,   size);
352         put_buffer(pb[2], pkt->data + 5*size,   size);
353         put_flush_packet(pb[1]);
354         put_flush_packet(pb[2]);
355         url_fclose(pb[1]);
356         url_fclose(pb[2]);
357     }else{
358         put_buffer(pb[0], pkt->data, pkt->size);
359     }
360     put_flush_packet(pb[0]);
361     if (!img->is_pipe) {
362         url_fclose(pb[0]);
363     }
364
365     img->img_number++;
366     return 0;
367 }
368
369 static int img_write_trailer(AVFormatContext *s)
370 {
371     return 0;
372 }
373
374 /* input */
375
376 static AVInputFormat image2_iformat = {
377     "image2",
378     "image2 sequence",
379     sizeof(VideoData),
380     image_probe,
381     img_read_header,
382     img_read_packet,
383     img_read_close,
384     NULL,
385     NULL,
386     AVFMT_NOFILE,
387 };
388
389 static AVInputFormat image2pipe_iformat = {
390     "image2pipe",
391     "piped image2 sequence",
392     sizeof(VideoData),
393     NULL, /* no probe */
394     img_read_header,
395     img_read_packet,
396     img_read_close,
397     NULL,
398 };
399
400
401 /* output */
402
403 static AVOutputFormat image2_oformat = {
404     "image2",
405     "image2 sequence",
406     "",
407     "",
408     sizeof(VideoData),
409     CODEC_ID_NONE,
410     CODEC_ID_MJPEG,
411     img_write_header,
412     img_write_packet,
413     img_write_trailer,
414     AVFMT_NOFILE,
415 };
416
417 static AVOutputFormat image2pipe_oformat = {
418     "image2pipe",
419     "piped image2 sequence",
420     "",
421     "",
422     sizeof(VideoData),
423     CODEC_ID_NONE,
424     CODEC_ID_MJPEG,
425     img_write_header,
426     img_write_packet,
427     img_write_trailer,
428 };
429
430 int img2_init(void)
431 {
432     av_register_input_format(&image2_iformat);
433     av_register_output_format(&image2_oformat);
434
435     av_register_input_format(&image2pipe_iformat);
436     av_register_output_format(&image2pipe_oformat);
437     
438     return 0;
439 }