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