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 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     strcpy(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     strcpy(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 }