Statistics
| Branch: | Revision:

ffmpeg / libavformat / img2.c @ 470bce2b

History | View | Annotate | Download (11.2 KB)

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
#include "libavutil/avstring.h"
24
#include "avformat.h"
25
#include <strings.h>
26

    
27
typedef struct {
28
    int img_first;
29
    int img_last;
30
    int img_number;
31
    int img_count;
32
    int is_pipe;
33
    char path[1024];
34
} VideoData;
35

    
36
typedef struct {
37
    enum CodecID id;
38
    const char *str;
39
} IdStrMap;
40

    
41
static const IdStrMap img_tags[] = {
42
    { CODEC_ID_MJPEG     , "jpeg"},
43
    { CODEC_ID_MJPEG     , "jpg"},
44
    { CODEC_ID_LJPEG     , "ljpg"},
45
    { CODEC_ID_PNG       , "png"},
46
    { CODEC_ID_PNG       , "mng"},
47
    { CODEC_ID_PPM       , "ppm"},
48
    { CODEC_ID_PPM       , "pnm"},
49
    { CODEC_ID_PGM       , "pgm"},
50
    { CODEC_ID_PGMYUV    , "pgmyuv"},
51
    { CODEC_ID_PBM       , "pbm"},
52
    { CODEC_ID_PAM       , "pam"},
53
    { CODEC_ID_MPEG1VIDEO, "mpg1-img"},
54
    { CODEC_ID_MPEG2VIDEO, "mpg2-img"},
55
    { CODEC_ID_MPEG4     , "mpg4-img"},
56
    { CODEC_ID_FFV1      , "ffv1-img"},
57
    { CODEC_ID_RAWVIDEO  , "y"},
58
    { CODEC_ID_BMP       , "bmp"},
59
    { CODEC_ID_GIF       , "gif"},
60
    { CODEC_ID_TARGA     , "tga"},
61
    { CODEC_ID_TIFF      , "tiff"},
62
    { CODEC_ID_TIFF      , "tif"},
63
    { CODEC_ID_SGI       , "sgi"},
64
    { CODEC_ID_PTX       , "ptx"},
65
    { CODEC_ID_PCX       , "pcx"},
66
    { CODEC_ID_SUNRAST   , "sun"},
67
    { CODEC_ID_SUNRAST   , "ras"},
68
    { CODEC_ID_SUNRAST   , "rs"},
69
    { CODEC_ID_SUNRAST   , "im1"},
70
    { CODEC_ID_SUNRAST   , "im8"},
71
    { CODEC_ID_SUNRAST   , "im24"},
72
    { CODEC_ID_SUNRAST   , "sunras"},
73
    { CODEC_ID_JPEG2000  , "jp2"},
74
    { CODEC_ID_NONE      , NULL}
75
};
76

    
77
static const int sizes[][2] = {
78
    { 640, 480 },
79
    { 720, 480 },
80
    { 720, 576 },
81
    { 352, 288 },
82
    { 352, 240 },
83
    { 160, 128 },
84
    { 512, 384 },
85
    { 640, 352 },
86
    { 640, 240 },
87
};
88

    
89
static int infer_size(int *width_ptr, int *height_ptr, int size)
90
{
91
    int i;
92

    
93
    for(i=0;i<FF_ARRAY_ELEMS(sizes);i++) {
94
        if ((sizes[i][0] * sizes[i][1]) == size) {
95
            *width_ptr = sizes[i][0];
96
            *height_ptr = sizes[i][1];
97
            return 0;
98
        }
99
    }
100
    return -1;
101
}
102
static enum CodecID av_str2id(const IdStrMap *tags, const char *str)
103
{
104
    str= strrchr(str, '.');
105
    if(!str) return CODEC_ID_NONE;
106
    str++;
107

    
108
    while (tags->id) {
109
        if (!strcasecmp(str, tags->str))
110
            return tags->id;
111

    
112
        tags++;
113
    }
114
    return CODEC_ID_NONE;
115
}
116

    
117
/* return -1 if no image found */
118
static int find_image_range(int *pfirst_index, int *plast_index,
119
                            const char *path)
120
{
121
    char buf[1024];
122
    int range, last_index, range1, first_index;
123

    
124
    /* find the first image */
125
    for(first_index = 0; first_index < 5; first_index++) {
126
        if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){
127
            *pfirst_index =
128
            *plast_index = 1;
129
            return 0;
130
        }
131
        if (url_exist(buf))
132
            break;
133
    }
134
    if (first_index == 5)
135
        goto fail;
136

    
137
    /* find the last image */
138
    last_index = first_index;
139
    for(;;) {
140
        range = 0;
141
        for(;;) {
142
            if (!range)
143
                range1 = 1;
144
            else
145
                range1 = 2 * range;
146
            if (av_get_frame_filename(buf, sizeof(buf), path,
147
                                      last_index + range1) < 0)
148
                goto fail;
149
            if (!url_exist(buf))
150
                break;
151
            range = range1;
152
            /* just in case... */
153
            if (range >= (1 << 30))
154
                goto fail;
155
        }
156
        /* we are sure than image last_index + range exists */
157
        if (!range)
158
            break;
159
        last_index += range;
160
    }
161
    *pfirst_index = first_index;
162
    *plast_index = last_index;
163
    return 0;
164
 fail:
165
    return -1;
166
}
167

    
168

    
169
static int image_probe(AVProbeData *p)
170
{
171
    if (p->filename && av_str2id(img_tags, p->filename)) {
172
        if (av_filename_number_test(p->filename))
173
            return AVPROBE_SCORE_MAX;
174
        else
175
            return AVPROBE_SCORE_MAX/2;
176
    }
177
    return 0;
178
}
179

    
180
enum CodecID av_guess_image2_codec(const char *filename){
181
    return av_str2id(img_tags, filename);
182
}
183

    
184
static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
185
{
186
    VideoData *s = s1->priv_data;
187
    int first_index, last_index;
188
    AVStream *st;
189

    
190
    s1->ctx_flags |= AVFMTCTX_NOHEADER;
191

    
192
    st = av_new_stream(s1, 0);
193
    if (!st) {
194
        return AVERROR(ENOMEM);
195
    }
196

    
197
    av_strlcpy(s->path, s1->filename, sizeof(s->path));
198
    s->img_number = 0;
199
    s->img_count = 0;
200

    
201
    /* find format */
202
    if (s1->iformat->flags & AVFMT_NOFILE)
203
        s->is_pipe = 0;
204
    else{
205
        s->is_pipe = 1;
206
        st->need_parsing = AVSTREAM_PARSE_FULL;
207
    }
208

    
209
    if (!ap->time_base.num) {
210
        av_set_pts_info(st, 60, 1, 25);
211
    } else {
212
        av_set_pts_info(st, 60, ap->time_base.num, ap->time_base.den);
213
    }
214

    
215
    if(ap->width && ap->height){
216
        st->codec->width = ap->width;
217
        st->codec->height= ap->height;
218
    }
219

    
220
    if (!s->is_pipe) {
221
        if (find_image_range(&first_index, &last_index, s->path) < 0)
222
            return AVERROR(EIO);
223
        s->img_first = first_index;
224
        s->img_last = last_index;
225
        s->img_number = first_index;
226
        /* compute duration */
227
        st->start_time = 0;
228
        st->duration = last_index - first_index + 1;
229
    }
230

    
231
    if(ap->video_codec_id){
232
        st->codec->codec_type = CODEC_TYPE_VIDEO;
233
        st->codec->codec_id = ap->video_codec_id;
234
    }else if(ap->audio_codec_id){
235
        st->codec->codec_type = CODEC_TYPE_AUDIO;
236
        st->codec->codec_id = ap->audio_codec_id;
237
    }else{
238
        st->codec->codec_type = CODEC_TYPE_VIDEO;
239
        st->codec->codec_id = av_str2id(img_tags, s->path);
240
    }
241
    if(st->codec->codec_type == CODEC_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
242
        st->codec->pix_fmt = ap->pix_fmt;
243

    
244
    return 0;
245
}
246

    
247
static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
248
{
249
    VideoData *s = s1->priv_data;
250
    char filename[1024];
251
    int i;
252
    int size[3]={0}, ret[3]={0};
253
    ByteIOContext *f[3];
254
    AVCodecContext *codec= s1->streams[0]->codec;
255

    
256
    if (!s->is_pipe) {
257
        /* loop over input */
258
        if (s1->loop_input && s->img_number > s->img_last) {
259
            s->img_number = s->img_first;
260
        }
261
        if (av_get_frame_filename(filename, sizeof(filename),
262
                                  s->path, s->img_number)<0 && s->img_number > 1)
263
            return AVERROR(EIO);
264
        for(i=0; i<3; i++){
265
            if (url_fopen(&f[i], filename, URL_RDONLY) < 0)
266
                return AVERROR(EIO);
267
            size[i]= url_fsize(f[i]);
268

    
269
            if(codec->codec_id != CODEC_ID_RAWVIDEO)
270
                break;
271
            filename[ strlen(filename) - 1 ]= 'U' + i;
272
        }
273

    
274
        if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)
275
            infer_size(&codec->width, &codec->height, size[0]);
276
    } else {
277
        f[0] = s1->pb;
278
        if (url_feof(f[0]))
279
            return AVERROR(EIO);
280
        size[0]= 4096;
281
    }
282

    
283
    av_new_packet(pkt, size[0] + size[1] + size[2]);
284
    pkt->stream_index = 0;
285
    pkt->flags |= PKT_FLAG_KEY;
286

    
287
    pkt->size= 0;
288
    for(i=0; i<3; i++){
289
        if(size[i]){
290
            ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);
291
            if (!s->is_pipe)
292
                url_fclose(f[i]);
293
            if(ret[i]>0)
294
                pkt->size += ret[i];
295
        }
296
    }
297

    
298
    if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {
299
        av_free_packet(pkt);
300
        return AVERROR(EIO); /* signal EOF */
301
    } else {
302
        s->img_count++;
303
        s->img_number++;
304
        return 0;
305
    }
306
}
307

    
308
#if defined(CONFIG_IMAGE2_MUXER) || defined(CONFIG_IMAGE2PIPE_MUXER)
309
/******************************************************/
310
/* image output */
311

    
312
static int img_write_header(AVFormatContext *s)
313
{
314
    VideoData *img = s->priv_data;
315

    
316
    img->img_number = 1;
317
    av_strlcpy(img->path, s->filename, sizeof(img->path));
318

    
319
    /* find format */
320
    if (s->oformat->flags & AVFMT_NOFILE)
321
        img->is_pipe = 0;
322
    else
323
        img->is_pipe = 1;
324

    
325
    return 0;
326
}
327

    
328
static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
329
{
330
    VideoData *img = s->priv_data;
331
    ByteIOContext *pb[3];
332
    char filename[1024];
333
    AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec;
334
    int i;
335

    
336
    if (!img->is_pipe) {
337
        if (av_get_frame_filename(filename, sizeof(filename),
338
                                  img->path, img->img_number) < 0 && img->img_number>1)
339
            return AVERROR(EIO);
340
        for(i=0; i<3; i++){
341
            if (url_fopen(&pb[i], filename, URL_WRONLY) < 0)
342
                return AVERROR(EIO);
343

    
344
            if(codec->codec_id != CODEC_ID_RAWVIDEO)
345
                break;
346
            filename[ strlen(filename) - 1 ]= 'U' + i;
347
        }
348
    } else {
349
        pb[0] = s->pb;
350
    }
351

    
352
    if(codec->codec_id == CODEC_ID_RAWVIDEO){
353
        int ysize = codec->width * codec->height;
354
        put_buffer(pb[0], pkt->data        , ysize);
355
        put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
356
        put_buffer(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
357
        put_flush_packet(pb[1]);
358
        put_flush_packet(pb[2]);
359
        url_fclose(pb[1]);
360
        url_fclose(pb[2]);
361
    }else{
362
        put_buffer(pb[0], pkt->data, pkt->size);
363
    }
364
    put_flush_packet(pb[0]);
365
    if (!img->is_pipe) {
366
        url_fclose(pb[0]);
367
    }
368

    
369
    img->img_number++;
370
    return 0;
371
}
372

    
373
#endif /* defined(CONFIG_IMAGE2_MUXER) || defined(CONFIG_IMAGE2PIPE_MUXER) */
374

    
375
/* input */
376
#ifdef CONFIG_IMAGE2_DEMUXER
377
AVInputFormat image2_demuxer = {
378
    "image2",
379
    NULL_IF_CONFIG_SMALL("image2 sequence"),
380
    sizeof(VideoData),
381
    image_probe,
382
    img_read_header,
383
    img_read_packet,
384
    NULL,
385
    NULL,
386
    NULL,
387
    AVFMT_NOFILE,
388
};
389
#endif
390
#ifdef CONFIG_IMAGE2PIPE_DEMUXER
391
AVInputFormat image2pipe_demuxer = {
392
    "image2pipe",
393
    NULL_IF_CONFIG_SMALL("piped image2 sequence"),
394
    sizeof(VideoData),
395
    NULL, /* no probe */
396
    img_read_header,
397
    img_read_packet,
398
};
399
#endif
400

    
401
/* output */
402
#ifdef CONFIG_IMAGE2_MUXER
403
AVOutputFormat image2_muxer = {
404
    "image2",
405
    NULL_IF_CONFIG_SMALL("image2 sequence"),
406
    "",
407
    "bmp,jpeg,jpg,ljpg,pam,pbm,pgm,pgmyuv,png,ppm,sgi,tif,tiff",
408
    sizeof(VideoData),
409
    CODEC_ID_NONE,
410
    CODEC_ID_MJPEG,
411
    img_write_header,
412
    img_write_packet,
413
    NULL,
414
    .flags= AVFMT_NOTIMESTAMPS | AVFMT_NOFILE
415
};
416
#endif
417
#ifdef CONFIG_IMAGE2PIPE_MUXER
418
AVOutputFormat image2pipe_muxer = {
419
    "image2pipe",
420
    NULL_IF_CONFIG_SMALL("piped image2 sequence"),
421
    "",
422
    "",
423
    sizeof(VideoData),
424
    CODEC_ID_NONE,
425
    CODEC_ID_MJPEG,
426
    img_write_header,
427
    img_write_packet,
428
    .flags= AVFMT_NOTIMESTAMPS
429
};
430
#endif