SGI image decoder ported to the new image API.
[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 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 #include "avformat.h"
23
24 typedef struct {
25     int img_first;
26     int img_last;
27     int img_number;
28     int img_count;
29     int is_pipe;
30     char path[1024];
31 } VideoData;
32
33 typedef struct {
34     enum CodecID id;
35     const char *str;
36 } IdStrMap;
37
38 static const IdStrMap img_tags[] = {
39     { CODEC_ID_MJPEG     , "jpeg"},
40     { CODEC_ID_MJPEG     , "jpg"},
41     { CODEC_ID_LJPEG     , "ljpg"},
42     { CODEC_ID_PNG       , "png"},
43     { CODEC_ID_PPM       , "ppm"},
44     { CODEC_ID_PGM       , "pgm"},
45     { CODEC_ID_PGMYUV    , "pgmyuv"},
46     { CODEC_ID_PBM       , "pbm"},
47     { CODEC_ID_PAM       , "pam"},
48     { CODEC_ID_MPEG1VIDEO, "mpg1-img"},
49     { CODEC_ID_MPEG2VIDEO, "mpg2-img"},
50     { CODEC_ID_MPEG4     , "mpg4-img"},
51     { CODEC_ID_FFV1      , "ffv1-img"},
52     { CODEC_ID_RAWVIDEO  , "y"},
53     { CODEC_ID_BMP       , "bmp"},
54     { CODEC_ID_GIF       , "gif"},
55     { CODEC_ID_TARGA     , "tga"},
56     { CODEC_ID_TIFF      , "tiff"},
57     { CODEC_ID_SGI       , "sgi"},
58     {0, NULL}
59 };
60
61 static int sizes[][2] = {
62     { 640, 480 },
63     { 720, 480 },
64     { 720, 576 },
65     { 352, 288 },
66     { 352, 240 },
67     { 160, 128 },
68     { 512, 384 },
69     { 640, 352 },
70     { 640, 240 },
71 };
72
73 static int infer_size(int *width_ptr, int *height_ptr, int size)
74 {
75     int i;
76
77     for(i=0;i<sizeof(sizes)/sizeof(sizes[0]);i++) {
78         if ((sizes[i][0] * sizes[i][1]) == size) {
79             *width_ptr = sizes[i][0];
80             *height_ptr = sizes[i][1];
81             return 0;
82         }
83     }
84     return -1;
85 }
86 static enum CodecID av_str2id(const IdStrMap *tags, const char *str)
87 {
88     str= strrchr(str, '.');
89     if(!str) return CODEC_ID_NONE;
90     str++;
91
92     while (tags->id) {
93         int i;
94         for(i=0; toupper(tags->str[i]) == toupper(str[i]); i++){
95             if(tags->str[i]==0 && str[i]==0)
96                 return tags->id;
97         }
98
99         tags++;
100     }
101     return CODEC_ID_NONE;
102 }
103
104 /* return -1 if no image found */
105 static int find_image_range(int *pfirst_index, int *plast_index,
106                             const char *path)
107 {
108     char buf[1024];
109     int range, last_index, range1, first_index;
110
111     /* find the first image */
112     for(first_index = 0; first_index < 5; first_index++) {
113         if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){
114             *pfirst_index =
115             *plast_index = 1;
116             return 0;
117         }
118         if (url_exist(buf))
119             break;
120     }
121     if (first_index == 5)
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 (!url_exist(buf))
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  fail:
152     return -1;
153 }
154
155
156 static int image_probe(AVProbeData *p)
157 {
158     if (p->filename && av_str2id(img_tags, p->filename)) {
159         if (av_filename_number_test(p->filename))
160             return AVPROBE_SCORE_MAX;
161         else
162             return AVPROBE_SCORE_MAX/2;
163     }
164     return 0;
165 }
166
167 enum CodecID av_guess_image2_codec(const char *filename){
168     return av_str2id(img_tags, filename);
169 }
170
171 static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
172 {
173     VideoData *s = s1->priv_data;
174     int first_index, last_index;
175     AVStream *st;
176
177     s1->ctx_flags |= AVFMTCTX_NOHEADER;
178
179     st = av_new_stream(s1, 0);
180     if (!st) {
181         return AVERROR(ENOMEM);
182     }
183
184     pstrcpy(s->path, sizeof(s->path), s1->filename);
185     s->img_number = 0;
186     s->img_count = 0;
187
188     /* find format */
189     if (s1->iformat->flags & AVFMT_NOFILE)
190         s->is_pipe = 0;
191     else{
192         s->is_pipe = 1;
193         st->need_parsing= 1;
194     }
195
196     if (!ap->time_base.num) {
197         av_set_pts_info(st, 60, 1, 25);
198     } else {
199         av_set_pts_info(st, 60, ap->time_base.num, ap->time_base.den);
200     }
201
202     if(ap->width && ap->height){
203         st->codec->width = ap->width;
204         st->codec->height= ap->height;
205     }
206
207     if (!s->is_pipe) {
208         if (find_image_range(&first_index, &last_index, s->path) < 0)
209             return AVERROR_IO;
210         s->img_first = first_index;
211         s->img_last = last_index;
212         s->img_number = first_index;
213         /* compute duration */
214         st->start_time = 0;
215         st->duration = last_index - first_index + 1;
216     }
217
218     if(ap->video_codec_id){
219         st->codec->codec_type = CODEC_TYPE_VIDEO;
220         st->codec->codec_id = ap->video_codec_id;
221     }else if(ap->audio_codec_id){
222         st->codec->codec_type = CODEC_TYPE_AUDIO;
223         st->codec->codec_id = ap->audio_codec_id;
224     }else{
225         st->codec->codec_type = CODEC_TYPE_VIDEO;
226         st->codec->codec_id = av_str2id(img_tags, s->path);
227     }
228     if(st->codec->codec_type == CODEC_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
229         st->codec->pix_fmt = ap->pix_fmt;
230
231     return 0;
232 }
233
234 static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
235 {
236     VideoData *s = s1->priv_data;
237     char filename[1024];
238     int i;
239     int size[3]={0}, ret[3]={0};
240     ByteIOContext f1[3], *f[3]= {&f1[0], &f1[1], &f1[2]};
241     AVCodecContext *codec= s1->streams[0]->codec;
242
243     if (!s->is_pipe) {
244         /* loop over input */
245         if (s1->loop_input && s->img_number > s->img_last) {
246             s->img_number = s->img_first;
247         }
248         if (av_get_frame_filename(filename, sizeof(filename),
249                                   s->path, s->img_number)<0 && s->img_number > 1)
250             return AVERROR_IO;
251         for(i=0; i<3; i++){
252             if (url_fopen(f[i], filename, URL_RDONLY) < 0)
253                 return AVERROR_IO;
254             size[i]= url_fsize(f[i]);
255
256             if(codec->codec_id != CODEC_ID_RAWVIDEO)
257                 break;
258             filename[ strlen(filename) - 1 ]= 'U' + i;
259         }
260
261         if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)
262             infer_size(&codec->width, &codec->height, size[0]);
263     } else {
264         f[0] = &s1->pb;
265         if (url_feof(f[0]))
266             return AVERROR_IO;
267         size[0]= 4096;
268     }
269
270     av_new_packet(pkt, size[0] + size[1] + size[2]);
271     pkt->stream_index = 0;
272     pkt->flags |= PKT_FLAG_KEY;
273
274     pkt->size= 0;
275     for(i=0; i<3; i++){
276         if(size[i]){
277             ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);
278             if (!s->is_pipe)
279                 url_fclose(f[i]);
280             if(ret[i]>0)
281                 pkt->size += ret[i];
282         }
283     }
284
285     if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {
286         av_free_packet(pkt);
287         return AVERROR_IO; /* signal EOF */
288     } else {
289         s->img_count++;
290         s->img_number++;
291         return 0;
292     }
293 }
294
295 static int img_read_close(AVFormatContext *s1)
296 {
297     return 0;
298 }
299
300 #ifdef CONFIG_MUXERS
301 /******************************************************/
302 /* image output */
303
304 static int img_write_header(AVFormatContext *s)
305 {
306     VideoData *img = s->priv_data;
307
308     img->img_number = 1;
309     pstrcpy(img->path, sizeof(img->path), s->filename);
310
311     /* find format */
312     if (s->oformat->flags & AVFMT_NOFILE)
313         img->is_pipe = 0;
314     else
315         img->is_pipe = 1;
316
317     return 0;
318 }
319
320 static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
321 {
322     VideoData *img = s->priv_data;
323     ByteIOContext pb1[3], *pb[3]= {&pb1[0], &pb1[1], &pb1[2]};
324     char filename[1024];
325     AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec;
326     int i;
327
328     if (!img->is_pipe) {
329         if (av_get_frame_filename(filename, sizeof(filename),
330                                   img->path, img->img_number) < 0 && img->img_number>1)
331             return AVERROR_IO;
332         for(i=0; i<3; i++){
333             if (url_fopen(pb[i], filename, URL_WRONLY) < 0)
334                 return AVERROR_IO;
335
336             if(codec->codec_id != CODEC_ID_RAWVIDEO)
337                 break;
338             filename[ strlen(filename) - 1 ]= 'U' + i;
339         }
340     } else {
341         pb[0] = &s->pb;
342     }
343
344     if(codec->codec_id == CODEC_ID_RAWVIDEO){
345         int ysize = codec->width * codec->height;
346         put_buffer(pb[0], pkt->data        , ysize);
347         put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
348         put_buffer(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
349         put_flush_packet(pb[1]);
350         put_flush_packet(pb[2]);
351         url_fclose(pb[1]);
352         url_fclose(pb[2]);
353     }else{
354         put_buffer(pb[0], pkt->data, pkt->size);
355     }
356     put_flush_packet(pb[0]);
357     if (!img->is_pipe) {
358         url_fclose(pb[0]);
359     }
360
361     img->img_number++;
362     return 0;
363 }
364
365 static int img_write_trailer(AVFormatContext *s)
366 {
367     return 0;
368 }
369
370 #endif /* CONFIG_MUXERS */
371
372 /* input */
373 #ifdef CONFIG_IMAGE2_DEMUXER
374 AVInputFormat image2_demuxer = {
375     "image2",
376     "image2 sequence",
377     sizeof(VideoData),
378     image_probe,
379     img_read_header,
380     img_read_packet,
381     img_read_close,
382     NULL,
383     NULL,
384     AVFMT_NOFILE,
385 };
386 #endif
387 #ifdef CONFIG_IMAGE2PIPE_DEMUXER
388 AVInputFormat image2pipe_demuxer = {
389     "image2pipe",
390     "piped image2 sequence",
391     sizeof(VideoData),
392     NULL, /* no probe */
393     img_read_header,
394     img_read_packet,
395     img_read_close,
396     NULL,
397 };
398 #endif
399
400 /* output */
401 #ifdef CONFIG_IMAGE2_MUXER
402 AVOutputFormat image2_muxer = {
403     "image2",
404     "image2 sequence",
405     "",
406     "",
407     sizeof(VideoData),
408     CODEC_ID_NONE,
409     CODEC_ID_MJPEG,
410     img_write_header,
411     img_write_packet,
412     img_write_trailer,
413     AVFMT_NOFILE,
414 };
415 #endif
416 #ifdef CONFIG_IMAGE2PIPE_MUXER
417 AVOutputFormat image2pipe_muxer = {
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 #endif