src/png2swf.c

   1 /* png2swf.c
   2
   3    PNG to SWF converter tool
   4
   5    Part of the swftools package.
   6
   7    Copyright (c) 2002 Matthias Kramm <kramm@quiss.org>
   8
   9    This file is distributed under the GPL, see file COPYING for details
  10
  11 */
  12
  13 #include <stdio.h>
  14 #include <math.h>
  15 #include <fcntl.h>
  16 #include <zlib.h>
  17 #include "../lib/rfxswf.h"
  18 #include "../lib/args.h"
  19
  20 #define MAX_INPUT_FILES 1024
  21 #define VERBOSE(x) (global.verbose>=x)
  22
  23 struct {
  24     int framerate;
  25     int max_image_width;
  26     int max_image_height;
  27     int force_width;
  28     int force_height;
  29     int nfiles;
  30     int verbose;
  31     char *outfile;
  32 } global;
  33
  34 struct {
  35     char *filename;
  36 } image[MAX_INPUT_FILES];
  37
  38 TAG *MovieStart(SWF * swf, int framerate, int dx, int dy)
  39 {
  40     TAG *t;
  41     RGBA rgb;
  42
  43     memset(swf, 0x00, sizeof(SWF));
  44
  45     swf->fileVersion = 5;
  46     swf->frameRate = (25600 / framerate);
  47     swf->movieSize.xmax = dx * 20;
  48     swf->movieSize.ymax = dy * 20;
  49
  50     t = swf->firstTag = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
  51
  52     rgb.r = rgb.g = rgb.b = rgb.a = 0x00;
  53     rgb.g = 0xff;
  54     swf_SetRGB(t, &rgb);
  55
  56     return t;
  57 }
  58
  59 int MovieFinish(SWF * swf, TAG * t, char *sname)
  60 {
  61     int handle, so = fileno(stdout);
  62     t = swf_InsertTag(t, ST_END);
  63
  64     if ((!isatty(so)) && (!sname))
  65         handle = so;
  66     else {
  67         if (!sname)
  68             sname = "output.swf";
  69         handle = open(sname, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
  70     }
  71     if FAILED
  72         (swf_WriteSWF(handle, swf)) if (VERBOSE(1))
  73             fprintf(stderr, "Unable to write output file: %s\n", sname);
  74     if (handle != so)
  75         close(handle);
  76
  77     swf_FreeTags(swf);
  78     return 0;
  79 }
  80
  81 int png_read_chunk(char (*head)[4], int*destlen, U8**destdata, FILE*fi)
  82 {
  83     unsigned int len;
  84     if(destlen) *destlen=0;
  85     if(destdata) *destdata=0;
  86     if(!fread(&len, 4, 1, fi))
  87         return 0;
  88     if(!fread(head, 4, 1, fi))
  89         return 0;
  90     len = REVERSESWAP32(len);
  91     if(destlen) *destlen = len;
  92     if(destdata) {
  93         if(len)
  94             *destdata = malloc(len);
  95         else
  96             *destdata = 0;
  97         if(!fread(*destdata, len, 1, fi)) {
  98             *destdata = 0;
  99             if(destlen) *destlen=0;
 100             return 0;
 101         }
 102         fseek(fi, 4, SEEK_CUR);
 103
 104     } else {
 105         fseek(fi, len+4, SEEK_CUR);
 106     }
 107     return 1;
 108 }
 109
 110 unsigned int png_get_dword(FILE*fi)
 111 {
 112     unsigned int a;
 113     fread(&a,4,1,fi);
 114     return REVERSESWAP32(a);
 115 }
 116
 117 struct png_header
 118 {
 119     int width;
 120     int height;
 121     int bpp;
 122     int mode;
 123 };
 124
 125 int png_read_header(FILE*fi, struct png_header*header)
 126 {
 127     char id[4];
 128     int len;
 129     int ok=0;
 130     U8 head[8] = {137,80,78,71,13,10,26,10};
 131     U8 head2[8];
 132     U8*data;
 133     fread(head2,8,1,fi);
 134     if(strncmp(head,head2,4))
 135         return 0;
 136
 137     while(png_read_chunk(&id, &len, &data, fi))
 138     {
 139         if(VERBOSE(2))
 140             printf("%c%c%c%c %d\n", id[0],id[1],id[2],id[3],len);
 141         if(!strncasecmp(id, "IHDR", 4)) {
 142             char a,b,c,f,i;
 143             if(len < 8) exit(1);
 144             header->width = REVERSESWAP32(*(U32*)&data[0]);
 145             header->height = REVERSESWAP32(*(U32*)&data[4]);
 146             a = data[8];      // should be 8
 147             b = data[9];      // should be 3(indexed) or 2(rgb)
 148
 149             c = data[10];     // compression mode (0)
 150             f = data[11];     // filter mode (0)
 151             i = data[12];     // interlace mode (0)
 152
 153             if(b!=2 && b!=3 && b!=6) {
 154                 fprintf(stderr, "Image mode %d not supported!\n", b);
 155                 exit(1);
 156             }
 157             if(a!=8 && (b==2 || b==6)) {
 158                 fprintf(stderr, "Bpp %d in mode %d not supported!\n", a);
 159                 exit(1);
 160             }
 161             if(c!=0) {
 162                 fprintf(stderr, "Compression mode %d not supported!\n", c);
 163                 exit(1);
 164             }
 165             if(f!=0) {
 166                 fprintf(stderr, "Filter mode %d not supported!\n", f);
 167                 exit(1);
 168             }
 169             if(i!=0) {
 170                 fprintf(stderr, "Interlace mode %d not supported!\n", i);
 171                 exit(1);
 172             }
 173             if(VERBOSE(2))
 174                 printf("%dx%d %d %d %d %d %d\n",header->width, header->height, a,b,c,f,i);
 175             header->bpp = a;
 176             header->mode = b;
 177             ok = 1;
 178         }
 179
 180         free(data);
 181     }
 182     return ok;
 183 }
 184
 185 typedef unsigned char byte;
 186 #define ABS(a) ((a)>0?(a):(-(a)))
 187 byte inline PaethPredictor (byte a,byte b,byte c)
 188 {
 189         // a = left, b = above, c = upper left
 190         int p = a + b - c;        // initial estimate
 191         int pa = ABS(p - a);      // distances to a, b, c
 192         int pb = ABS(p - b);
 193         int pc = ABS(p - c);
 194         // return nearest of a,b,c,
 195         // breaking ties in order a,b,c.
 196         if (pa <= pb && pa <= pc)
 197                 return a;
 198         else if (pb <= pc)
 199                 return b;
 200         else return c;
 201 }
 202
 203 void applyfilter3(int mode, U8*src, U8*old, U8*dest, int width)
 204 {
 205     int x;
 206     unsigned char lastr=0;
 207     unsigned char lastg=0;
 208     unsigned char lastb=0;
 209     unsigned char upperlastr=0;
 210     unsigned char upperlastg=0;
 211     unsigned char upperlastb=0;
 212
 213     if(mode==0) {
 214         for(x=0;x<width;x++) {
 215             dest[0] = 255;
 216             dest[1] = src[0];
 217             dest[2] = src[1];
 218             dest[3] = src[2];
 219             dest+=4;
 220             src+=3;
 221         }
 222     }
 223     else if(mode==1) {
 224         for(x=0;x<width;x++) {
 225             dest[0] = 255;
 226             dest[1] = src[0]+lastr;
 227             dest[2] = src[1]+lastg;
 228             dest[3] = src[2]+lastb;
 229             lastr = dest[1];
 230             lastg = dest[2];
 231             lastb = dest[3];
 232             dest+=4;
 233             src+=3;
 234         }
 235     }
 236     else if(mode==2) {
 237         for(x=0;x<width;x++) {
 238             dest[0] = 255;
 239             dest[1] = src[0]+old[1];
 240             dest[2] = src[1]+old[2];
 241             dest[3] = src[2]+old[3];
 242             dest+=4;
 243             old+=4;
 244             src+=3;
 245         }
 246     }
 247     else if(mode==3) {
 248         for(x=0;x<width;x++) {
 249             dest[0] = 255;
 250             dest[1] = src[0]+(old[1]+lastr)/2;
 251             dest[2] = src[1]+(old[2]+lastg)/2;
 252             dest[3] = src[2]+(old[3]+lastb)/2;
 253             lastr = dest[1];
 254             lastg = dest[2];
 255             lastb = dest[3];
 256             dest+=4;
 257             old+=4;
 258             src+=3;
 259         }
 260     }
 261     else if(mode==4) {
 262         for(x=0;x<width;x++) {
 263             dest[0] = 255;
 264             dest[1] = src[0]+PaethPredictor(lastr,old[1],upperlastr);
 265             dest[2] = src[1]+PaethPredictor(lastg,old[2],upperlastg);
 266             dest[3] = src[2]+PaethPredictor(lastb,old[3],upperlastb);
 267             lastr = dest[1];
 268             lastg = dest[2];
 269             lastb = dest[3];
 270             upperlastr = old[1];
 271             upperlastg = old[2];
 272             upperlastb = old[3];
 273             dest+=4;
 274             old+=4;
 275             src+=3;
 276         }
 277     }
 278
 279 }
 280
 281 void applyfilter4(int mode, U8*src, U8*old, U8*dest, int width)
 282 {
 283     int x;
 284     unsigned char lastr=0;
 285     unsigned char lastg=0;
 286     unsigned char lastb=0;
 287     unsigned char lasta=0;
 288     unsigned char upperlastr=0;
 289     unsigned char upperlastg=0;
 290     unsigned char upperlastb=0;
 291     unsigned char upperlasta=0;
 292
 293     if(mode==0) {
 294         for(x=0;x<width;x++) {
 295             dest[0] = src[3];
 296             dest[1] = src[0];
 297             dest[2] = src[1];
 298             dest[3] = src[2];
 299             dest+=4;
 300             src+=4;
 301         }
 302     }
 303     else if(mode==1) {
 304         for(x=0;x<width;x++) {
 305             dest[0] = src[3]+lasta;
 306             dest[1] = src[0]+lastr;
 307             dest[2] = src[1]+lastg;
 308             dest[3] = src[2]+lastb;
 309             lasta = dest[0];
 310             lastr = dest[1];
 311             lastg = dest[2];
 312             lastb = dest[3];
 313             dest+=4;
 314             src+=4;
 315         }
 316     }
 317     else if(mode==2) {
 318         for(x=0;x<width;x++) {
 319             dest[0] = src[3]+old[0];
 320             dest[1] = src[0]+old[1];
 321             dest[2] = src[1]+old[2];
 322             dest[3] = src[2]+old[3];
 323             dest+=4;
 324             old+=4;
 325             src+=4;
 326         }
 327     }
 328     else if(mode==3) {
 329         for(x=0;x<width;x++) {
 330             dest[0] = src[3]+(old[0]+lasta)/2;
 331             dest[1] = src[0]+(old[1]+lastr)/2;
 332             dest[2] = src[1]+(old[2]+lastg)/2;
 333             dest[3] = src[2]+(old[3]+lastb)/2;
 334             lastr = dest[1];
 335             lastg = dest[2];
 336             lastb = dest[3];
 337             dest+=4;
 338             old+=4;
 339             src+=4;
 340         }
 341     }
 342     else if(mode==4) {
 343         for(x=0;x<width;x++) {
 344             dest[0] = src[3]+PaethPredictor(lasta,old[0],upperlasta);
 345             dest[1] = src[0]+PaethPredictor(lastr,old[1],upperlastr);
 346             dest[2] = src[1]+PaethPredictor(lastg,old[2],upperlastg);
 347             dest[3] = src[2]+PaethPredictor(lastb,old[3],upperlastb);
 348             lasta = dest[0];
 349             lastr = dest[1];
 350             lastg = dest[2];
 351             lastb = dest[3];
 352             upperlastr = old[0];
 353             upperlastr = old[1];
 354             upperlastg = old[2];
 355             upperlastb = old[3];
 356             dest+=4;
 357             old+=4;
 358             src+=4;
 359         }
 360     }
 361
 362 }
 363
 364 void applyfilter1(int mode, U8*src, U8*old, U8*dest, int width)
 365 {
 366     int x;
 367     unsigned char last=0;
 368     unsigned char upperlast=0;
 369
 370     if(mode==0) {
 371         for(x=0;x<width;x++) {
 372             *dest = *src;
 373             dest++;
 374             src++;
 375         }
 376     }
 377     else if(mode==1) {
 378         for(x=0;x<width;x++) {
 379             *dest = *src+last;
 380             last = *dest;
 381             dest++;
 382             src++;
 383         }
 384     }
 385     else if(mode==2) {
 386         for(x=0;x<width;x++) {
 387             *dest = *src+*old;
 388             dest++;
 389             old++;
 390             src++;
 391         }
 392     }
 393     else if(mode==3) {
 394         for(x=0;x<width;x++) {
 395             *dest = *src+(*old+last)/2;
 396             dest++;
 397             old++;
 398             src++;
 399         }
 400     }
 401     else if(mode==4) {
 402         for(x=0;x<width;x++) {
 403             *dest = *src+PaethPredictor(last,*old,upperlast);
 404             last = *dest;
 405             upperlast = *old;
 406             dest++;
 407             old++;
 408             src++;
 409         }
 410     }
 411
 412 }
 413
 414 TAG *MovieAddFrame(SWF * swf, TAG * t, char *sname, int id)
 415 {
 416     SHAPE *s;
 417     SRECT r;
 418     MATRIX m;
 419     int fs;
 420
 421     char tagid[4];
 422     int len;
 423     U8*data;
 424     U8*imagedata;
 425     U8*zimagedata=0;
 426     unsigned long int imagedatalen;
 427     unsigned long int zimagedatalen=0;
 428     U8*palette = 0;
 429     int palettelen = 0;
 430     U8*alphapalette = 0;
 431     int alphapalettelen = 0;
 432     struct png_header header;
 433     int bypp;
 434
 435     FILE *fi;
 436     U8 *scanline;
 437
 438     if ((fi = fopen(sname, "rb")) == NULL) {
 439         if (VERBOSE(1))
 440             fprintf(stderr, "Read access failed: %s\n", sname);
 441         return t;
 442     }
 443
 444     if(!png_read_header(fi, &header))
 445         return 0;
 446
 447     if(header.mode == 3) bypp = 1;
 448     else
 449     if(header.mode == 2) bypp = 3;
 450     else
 451     if(header.mode == 6) bypp = 4;
 452     else
 453         return 0;
 454     imagedatalen = bypp * header.width * header.height + 65536;
 455     imagedata = malloc(imagedatalen);
 456
 457     fseek(fi,8,SEEK_SET);
 458     while(!feof(fi))
 459     {
 460         if(!png_read_chunk(&tagid, &len, &data, fi))
 461             break;
 462         if(!strncmp(tagid, "IEND", 4)) {
 463             break;
 464         }
 465         if(!strncmp(tagid, "PLTE", 4)) {
 466             palette = data;
 467             palettelen = len/3;
 468             data = 0; //don't free data
 469             if(VERBOSE(2))
 470                 printf("%d colors in palette\n", palettelen);
 471         }
 472         if(!strncmp(tagid, "tRNS", 4)) {
 473             if(header.mode == 3) {
 474                 alphapalette = data;
 475                 alphapalettelen = len;
 476                 data = 0; //don't free data
 477                 if(VERBOSE(2))
 478                     printf("found %d alpha colors\n", alphapalettelen);
 479             }
 480         }
 481         if(!strncmp(tagid, "IDAT", 4)) {
 482             if(!zimagedata) {
 483                 zimagedatalen = len;
 484                 zimagedata = malloc(len);
 485                 memcpy(zimagedata,data,len);
 486             } else {
 487                 zimagedata = realloc(zimagedata, zimagedatalen+len);
 488                 memcpy(&zimagedata[zimagedatalen], data, len);
 489                 zimagedatalen += len;
 490             }
 491         }
 492         if(data)
 493             free(data);
 494     }
 495
 496     if(!zimagedata || uncompress(imagedata, &imagedatalen, zimagedata, zimagedatalen) != Z_OK) {
 497         fprintf(stderr, "Couldn't uncompress %s!\n", sname);
 498         if(zimagedata)
 499             free(zimagedata);
 500         return 0;
 501     }
 502     free(zimagedata);
 503
 504     if(alphapalette)
 505         t = swf_InsertTag(t, ST_DEFINEBITSLOSSLESS2);
 506     else
 507         t = swf_InsertTag(t, ST_DEFINEBITSLOSSLESS);
 508
 509     swf_SetU16(t, id);          // id
 510     if(header.mode == 2 || header.mode == 6) {
 511         U8*data2 = malloc(header.width*header.height*4);
 512         int i,s=0;
 513         int x,y;
 514         int pos=0;
 515         int opaque=0;
 516         int transparent=0;
 517         /* in case for mode 2, the following also performs 24->32 bit conversion */
 518         for(y=0;y<header.height;y++) {
 519             int mode = imagedata[pos++]; //filter mode
 520             U8*src;
 521             U8*dest;
 522             U8*old;
 523             dest = &data2[(y*header.width)*4];
 524
 525             if(header.bpp == 8)
 526             {
 527                 /* one byte per pixel */
 528                 src = &imagedata[pos];
 529                 pos+=header.width*(header.mode==6?4:3);
 530             } else {
 531                 /* not implemented yet */
 532                 exit(1);
 533             }
 534
 535             if(!y) {
 536                 memset(data2,0,header.width*4);
 537                 old = &data2[y*header.width*4];
 538             } else {
 539                 old = &data2[(y-1)*header.width*4];
 540             }
 541             if(header.mode==6)
 542                 applyfilter4(mode, src, old, dest, header.width);
 543             else
 544                 applyfilter3(mode, src, old, dest, header.width);
 545         }
 546
 547 #ifdef HAVE_LIBJPEG
 548         /* the image is now compressed and stored in data. Now let's take
 549            a look at the alpha values to determine which bitmap type we
 550            should write */
 551         if(header.mode == 6)
 552         for(y=0;y<header.height;y++) {
 553             U8*l = &data2[(y*header.width)*4];
 554             for(x=0;x<header.width;x++) {
 555                 if(l[x*4+0]==255) transparent++;
 556                 if(l[x*4+0]==0) opaque++;
 557             }
 558         }
 559         /* mode 6 images which are not fully opaque or fully transparent
 560            will be stored as definejpeg3 */
 561         if(header.mode == 6 && transparent != header.width*header.height
 562                             && opaque != header.width*header.height) {
 563
 564             printf("Image has transparency information. Storing as DefineBitsJpeg3 Tag (jpeg+alpha)\n");
 565
 566             // we always use quality 100, since png2swf is expected to
 567             // use more or less lossless compression
 568
 569             swf_SetJPEGBits3(t, header.width, header.height, (RGBA*)data2, 100);
 570             t->id = ST_DEFINEBITSJPEG3;
 571         }
 572         else
 573 #endif
 574         {
 575             swf_SetLosslessBits(t, header.width, header.height, data2, BMF_32BIT);
 576         }
 577         free(data2);
 578     }
 579     else {
 580         RGBA*rgba = (RGBA*)malloc(palettelen*sizeof(RGBA));
 581         int swf_width = BYTES_PER_SCANLINE(header.width);
 582         U8*data2 = malloc(swf_width*header.height);
 583         U8*tmpline = malloc(header.width);
 584         int i,x,y;
 585         int pos=0;
 586         if(!palette) {
 587             fprintf(stderr, "Error: No palette found!\n");
 588             exit(1);
 589         }
 590         /* 24->32 bit conversion */
 591         for(i=0;i<palettelen;i++) {
 592             rgba[i].r = palette[i*3+0];
 593             rgba[i].g = palette[i*3+1];
 594             rgba[i].b = palette[i*3+2];
 595             if(alphapalette && i<alphapalettelen) {
 596                 rgba[i].a = alphapalette[i];
 597                 if(alphapalette[i] == 0) {
 598                     /* if the color is fully transparent, it doesn't matter
 599                        what it's rgb values are. furthermore, all Flash
 600                        players up to Flash 5 can't deal with anything beyond
 601                        one transparent color with value (00,00,00,00). */
 602                     rgba[i].r = rgba[i].g = rgba[i].b = 0;
 603                 }
 604             } else {
 605                 rgba[i].a = 255;
 606             }
 607         }
 608
 609         for(y=0;y<header.height;y++) {
 610             int mode = imagedata[pos++]; //filter mode
 611             U8*old;
 612             U8*dest = &data2[y*swf_width];
 613             U8*src;
 614             src = &imagedata[pos];
 615             if(header.bpp == 8) {
 616                 pos+=header.width;
 617             } else {
 618                 int x,s=0;
 619                 int bitpos = 0;
 620                 U32 v = (1<<header.bpp)-1;
 621                 for(x=0;x<header.width;x++) {
 622                     U32 r = src[s/8]<<8 |
 623                             src[s/8+1];
 624                     int t;
 625                     tmpline[x] = (r>>(16-header.bpp-(s&7)))&v;
 626                     s+=header.bpp;
 627                 }
 628                 src = tmpline;
 629                 pos+=(header.width*header.bpp+7)/8;
 630             }
 631
 632             if(!y) {
 633                 memset(data2,0,swf_width);
 634                 old = &data2[y*swf_width];
 635             } else {
 636                 old = &data2[(y-1)*swf_width];
 637             }
 638             applyfilter1(mode, src, old, dest, header.width);
 639         }
 640         swf_SetLosslessBitsIndexed(t, header.width, header.height, data2, rgba, palettelen);
 641         free(tmpline);
 642         free(rgba);
 643         free(data2);
 644     }
 645
 646     t = swf_InsertTag(t, ST_DEFINESHAPE3);
 647
 648     swf_ShapeNew(&s);
 649     swf_GetMatrix(NULL, &m);
 650     m.sx = 20 * 0x10000;
 651     m.sy = 20 * 0x10000;
 652     fs = swf_ShapeAddBitmapFillStyle(s, &m, id, 0);
 653
 654     swf_SetU16(t, id + 1);      // id
 655
 656     r.xmin = r.ymin = 0;
 657     r.xmax = header.width * 20;
 658     r.ymax = header.height * 20;
 659     swf_SetRect(t, &r);
 660
 661     swf_SetShapeHeader(t, s);
 662
 663     swf_ShapeSetAll(t, s, 0, 0, 0, fs, 0);
 664     swf_ShapeSetLine(t, s, r.xmax, 0);
 665     swf_ShapeSetLine(t, s, 0, r.ymax);
 666     swf_ShapeSetLine(t, s, -r.xmax, 0);
 667     swf_ShapeSetLine(t, s, 0, -r.ymax);
 668
 669     swf_ShapeSetEnd(t);
 670
 671     t = swf_InsertTag(t, ST_REMOVEOBJECT2);
 672     swf_SetU16(t, 50);          // depth
 673
 674     t = swf_InsertTag(t, ST_PLACEOBJECT2);
 675
 676     swf_GetMatrix(NULL, &m);
 677     m.tx = (swf->movieSize.xmax - (int) header.width * 20) / 2;
 678     m.ty = (swf->movieSize.ymax - (int) header.height * 20) / 2;
 679     swf_ObjectPlace(t, id + 1, 50, &m, NULL, NULL);
 680
 681     t = swf_InsertTag(t, ST_SHOWFRAME);
 682
 683     fclose(fi);
 684
 685     return t;
 686 }
 687
 688
 689 int CheckInputFile(char *fname, char **realname)
 690 {
 691     FILE *fi;
 692     char *s = malloc(strlen(fname) + 5);
 693     struct png_header head;
 694
 695     if (!s)
 696         exit(2);
 697     (*realname) = s;
 698     strcpy(s, fname);
 699
 700     // Check whether file exists (with typical extensions)
 701
 702     if ((fi = fopen(s, "rb")) == NULL) {
 703         sprintf(s, "%s.png", fname);
 704         if ((fi = fopen(s, "rb")) == NULL) {
 705             sprintf(s, "%s.PNG", fname);
 706             if ((fi = fopen(s, "rb")) == NULL) {
 707                 sprintf(s, "%s.Png", fname);
 708                 if ((fi = fopen(s, "rb")) == NULL)
 709                     fprintf(stderr, "Couldn't open %s!\n", fname);
 710                     return -1;
 711             }
 712         }
 713     }
 714
 715     if(!png_read_header(fi, &head)) {
 716         fprintf(stderr, "%s is not a PNG file!\n", fname);
 717         return -1;
 718     }
 719
 720     if (global.max_image_width < head.width)
 721         global.max_image_width = head.width;
 722     if (global.max_image_height < head.height)
 723         global.max_image_height = head.height;
 724
 725     fclose(fi);
 726
 727     return 0;
 728 }
 729
 730 int args_callback_option(char *arg, char *val)
 731 {
 732     int res = 0;
 733     if (arg[1])
 734         res = -1;
 735     else
 736         switch (arg[0]) {
 737         case 'r':
 738             if (val)
 739                 global.framerate = atoi(val);
 740             if ((global.framerate < 1) ||(global.framerate > 5000)) {
 741                 if (VERBOSE(1))
 742                     fprintf(stderr,
 743                             "Error: You must specify a valid framerate between 1 and 10000.\n");
 744                 exit(1);
 745             }
 746             res = 1;
 747             break;
 748
 749         case 'o':
 750             if (val)
 751                 global.outfile = val;
 752             res = 1;
 753             break;
 754
 755         case 'v':
 756             if (val)
 757                 global.verbose = atoi(val);
 758             res = 1;
 759             break;
 760
 761         case 'X':
 762             if (val)
 763                 global.force_width = atoi(val);
 764             res = 1;
 765             break;
 766
 767         case 'Y':
 768             if (val)
 769                 global.force_height = atoi(val);
 770             res = 1;
 771             break;
 772
 773         case 'V':
 774             printf("png2swf - part of %s %s\n", PACKAGE, VERSION);
 775             exit(0);
 776
 777         default:
 778             res = -1;
 779             break;
 780         }
 781
 782     if (res < 0) {
 783         if (VERBOSE(1))
 784             fprintf(stderr, "Unknown option: -%s\n", arg);
 785         exit(1);
 786         return 0;
 787     }
 788     return res;
 789 }
 790
 791 struct options_t options[] =
 792 {
 793 {"o", "output"},
 794 {"r", "rate"},
 795 {"v", "verbose"},
 796 {"X", "width"},
 797 {"Y", "height"},
 798 {"V", "version"},
 799 };
 800
 801 int args_callback_longoption(char *name, char *val)
 802 {
 803     return args_long2shortoption(options, name, val);
 804 }
 805
 806 int args_callback_command(char *arg, char *next)        // actually used as filename
 807 {
 808     char *s;
 809     if (CheckInputFile(arg, &s) < 0) {
 810         if (VERBOSE(1))
 811             fprintf(stderr, "Error opening input file: %s\n", arg);
 812         free(s);
 813     } else {
 814         image[global.nfiles].filename = s;
 815         global.nfiles++;
 816         if (global.nfiles >= MAX_INPUT_FILES) {
 817             if (VERBOSE(1))
 818                 fprintf(stderr, "Error: Too many input files.\n");
 819             exit(1);
 820         }
 821     }
 822     return 0;
 823 }
 824
 825 void args_callback_usage(char *name)
 826 {
 827     printf("Usage: %s  [-options [value]] imagefiles[.png] [...]\n", name);
 828     printf("-r framerate          (rate) Set movie framerate (100/sec)\n");
 829     printf("-o outputfile         (output) Set name for SWF output file\n");
 830     printf("-X pixel              (width) Force movie width to pixel (default: autodetect)\n");
 831     printf("-Y pixel              (height) Force movie height to pixel (default: autodetect)\n");
 832     printf("-v level              (verbose) Set verbose level (0=quiet, 1=default, 2=debug)\n");
 833     printf("-V                    (version) Print version information and exit\n");
 834 }
 835
 836
 837 int main(int argc, char **argv)
 838 {
 839     SWF swf;
 840     TAG *t;
 841
 842     memset(&global, 0x00, sizeof(global));
 843
 844     global.framerate = 100;
 845     global.verbose = 1;
 846
 847     processargs(argc, argv);
 848
 849     if(global.nfiles<=0)
 850         return 1;
 851
 852     if (VERBOSE(2))
 853         fprintf(stderr, "Processing %i file(s)...\n", global.nfiles);
 854
 855     t = MovieStart(&swf, global.framerate,
 856                    global.force_width ? global.force_width : global.
 857                    max_image_width,
 858                    global.force_height ? global.force_height : global.
 859                    max_image_height);
 860
 861     {
 862         int i;
 863         for (i = 0; i < global.nfiles; i++) {
 864             if (VERBOSE(3))
 865                 fprintf(stderr, "[%03i] %s\n", i,
 866                         image[i].filename);
 867             t = MovieAddFrame(&swf, t, image[i].filename, (i * 2) + 1);
 868             free(image[i].filename);
 869         }
 870     }
 871
 872     MovieFinish(&swf, t, global.outfile);
 873
 874     return 0;
 875 }