lib/h.263/video.c

   1 /* video.c
   2    Shows the structure of a swf file containing video
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program 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
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include "../../config.h"
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #include <stdarg.h>
  27 #include <assert.h>
  28 #include "../rfxswf.h"
  29 #include "../args.h"
  30 #include "h263tables.h"
  31
  32 static char * filename = 0;
  33 static char * indent = "                ";
  34 int hex = 0;
  35 int debug = 0;
  36
  37 struct options_t options[] =
  38 {
  39  {"v","verbose"},
  40  {"V","version"},
  41  {"d","hex"},
  42  {"M","video"},
  43  {0,0}
  44 };
  45
  46 /* TODO:
  47    * check rle tables
  48 */
  49 int args_callback_option(char*name,char*val)
  50 {
  51     if(!strcmp(name, "V")) {
  52         printf("swfdump - part of %s %s\n", PACKAGE, VERSION);
  53         exit(0);
  54     }
  55     else if(name[0]=='d') {
  56         hex = 1;
  57         return 0;
  58     }
  59     else if(name[0]=='v') {
  60         debug = 1;
  61         return 0;
  62     }
  63     else {
  64         printf("Unknown option: -%s\n", name);
  65         exit(1);
  66     }
  67
  68     return 0;
  69 }
  70 int args_callback_longoption(char*name,char*val)
  71 {
  72     return args_long2shortoption(options, name, val);
  73 }
  74 void args_callback_usage(char*name)
  75 {
  76     printf("Usage: %s [-at] file.swf\n", name);
  77     printf("\t-h , --help\t\t Print help and exit\n");
  78     printf("\t-d , --hex\t\t Print hex output of tag data, too\n");
  79     printf("\t-v , --verbose\t\t Print debugging information\n");
  80     printf("\t-V , --version\t\t Print program version and exit\n");
  81 }
  82 int args_callback_command(char*name,char*val)
  83 {
  84     if(filename) {
  85         fprintf(stderr, "Only one file allowed. You supplied at least two. (%s and %s)\n",
  86                  filename, name);
  87     }
  88     filename = name;
  89     return 0;
  90 }
  91
  92 #define DEBUG if(debug)
  93
  94 void handleVideoStream(TAG*tag, char*prefix)
  95 {
  96     U16 id = swf_GetU16(tag);
  97     U16 frames = swf_GetU16(tag);
  98     U16 width = swf_GetU16(tag);
  99     U16 height = swf_GetU16(tag);
 100     U8 flags = swf_GetU8(tag); //5-2(videopacket 01=off 10=on)-1(smoothing 1=on)
 101     U8 codec = swf_GetU8(tag);
 102     printf(" (%d frames, %dx%d", frames, width, height);
 103     if(flags&1)
 104         printf(" smoothed");
 105     if(codec == 2)
 106         printf(" sorenson h.263)");
 107     else
 108         printf(" codec 0x%02x)", codec);
 109 }
 110
 111 int checkhufftable(struct huffcode*code, char*name)
 112 {
 113     int t=0;
 114     while(code[t].code) {
 115         int s=0;
 116         if(strlen(code[t].code)!=code[t].len) {
 117             printf("len mismatch in %s, index %d\n", name, t);
 118             exit(1);
 119         }
 120         if(t != code[t].index) {
 121             printf("index mismatch in %s, index %d\n", name, t);
 122             exit(1);
 123         }
 124         while(code[s].code) {
 125             char*a = code[s].code;
 126             char*b = code[t].code;
 127             int ai = s;
 128             int bi = t;
 129             if(s==t) {s++;continue;}
 130             if(code[t].len < code[s].len) {
 131                  a = code[t].code;
 132                  b = code[s].code;
 133                  ai = t; bi = s;
 134             }
 135             if(!strncmp(a,b,strlen(a))) {
 136                 printf("index %d (%s) is prefix of %d (%s)\n", ai, a, bi, b);
 137                 exit(1);
 138             }
 139
 140             s++;
 141         }
 142
 143         t++;
 144     }
 145 }
 146
 147
 148 struct hufftree
 149 {
 150     struct hufftree*left;//0
 151     struct hufftree*right;//1
 152     int index;
 153 };
 154
 155 struct hufftree * rle_tree;
 156 struct hufftree * mcbpc_intra_tree;
 157 struct hufftree * mcbpc_inter_tree;
 158 struct hufftree * cbpy_tree;
 159 struct hufftree * mvd_tree;
 160
 161 static void insert(struct hufftree*tree, char*code, int index)
 162 {
 163     if(!*code) {
 164         assert(!tree->left); //shannon conditional
 165         assert(!tree->right);
 166         tree->left = 0;
 167         tree->right = 0;
 168         tree->index = index;
 169         return;
 170     }
 171     if(code[0] == '0') {
 172         if(!tree->left) {
 173             tree->left = (struct hufftree*)malloc(sizeof(struct hufftree));
 174             memset(tree->left, 0, sizeof(struct hufftree));
 175             tree->left->index = -1;
 176         }
 177         insert(tree->left, code+1, index);
 178         return;
 179     } else {
 180         assert(code[0] == '1');
 181         if(!tree->right) {
 182             tree->right = (struct hufftree*)malloc(sizeof(struct hufftree));
 183             memset(tree->right, 0, sizeof(struct hufftree));
 184             tree->right->index = -1;
 185         }
 186         insert(tree->right, code+1, index);
 187         return;
 188     }
 189 }
 190
 191 struct hufftree* huffcode2tree(struct huffcode*code)
 192 {
 193     struct hufftree* t = malloc(sizeof(struct hufftree));
 194     memset(t, 0, sizeof(struct hufftree));
 195     t->index = -1;
 196     while(code->code) {
 197         insert(t, code->code, code->index);
 198         code++;
 199     }
 200     return t;
 201 }
 202
 203 int gethuffvalue(TAG*tag, struct huffcode*code)
 204 {
 205     int len = 0;
 206     char bits[80];
 207     while(1) {
 208         int t=0,pot=0;
 209         bits[len] = swf_GetBits(tag, 1)+0x30;
 210         len++;
 211         bits[len] = 0;
 212         while(code[t].code) {
 213             if(!strcmp(bits, code[t].code))
 214                 return t;
 215             t++;
 216             if(code[t].len >= len)
 217                 pot++;
 218         }
 219         if(!pot) {
 220             int nr=0;
 221             printf("error: %s\n", bits);
 222             while(tag->pos < tag->len && nr<80) {
 223                 int b = swf_GetBits(tag, 1);
 224                 printf("%d", b);
 225                 nr++;
 226             }
 227             if(nr==80)
 228                 printf("...");
 229             printf("\n");
 230             exit(1);
 231             return -1;
 232         }
 233     }
 234
 235         /*type = 0; // mb-type =3, cbpc = 00
 236         if(!bit) {
 237             printf("can't handle i-frame mcbpc bits %d yet\n", bit);
 238         }
 239         bit = swf_GetBits(tag, 1);
 240         type = 0; // mb-type =0, cbpc = 00
 241         if(!bit) {
 242             bit = swf_GetBits(tag, 2);
 243             type = 8; // mb-type =2, cbpc = 00
 244             if(bit!=3) {
 245                 printf("can't handle p-frame mcbpc bits 0-%d yet\n", bit);
 246                 exit(1);
 247             }
 248         }*/
 249 }
 250
 251 int gethuffvalue2(TAG*tag, struct huffcode*code, struct hufftree*tree)
 252 {
 253     while(1) {
 254         if(tree->index>=0) {
 255             return tree->index;
 256         }
 257         if(!swf_GetBits(tag, 1)) {
 258             assert(tree->left);
 259             tree=tree->left;
 260         } else {
 261             assert(tree->right);
 262             tree=tree->right;
 263         }
 264     }
 265 }
 266
 267 void get_DC_TCOEF(TAG*tag, int t, int has_dc, int has_tcoef)
 268 {
 269     int dc;
 270     int ac;// = swf_GetBits();
 271     int index;
 272     int pos = 0;
 273     //printf("DC:%d\n", dc);
 274     if(has_dc) {
 275         dc = swf_GetBits(tag, 8);
 276         if(dc == 0 || dc == 128) {
 277             printf("error: dc=%d\n", dc);
 278             exit(1);
 279         }
 280         DEBUG printf(" %d ", dc);
 281         pos++;
 282     }
 283
 284     if(has_tcoef) {
 285         DEBUG printf("[");
 286         while(1) {
 287             int last;
 288             int run;
 289             int level;
 290             index = gethuffvalue2(tag, rle, rle_tree);
 291             last = rle_params[index].last;
 292             run = rle_params[index].run;
 293             level = rle_params[index].level;
 294             //DEBUG printf("index:%d\n", index);
 295             if(index == RLE_ESCAPE) {
 296                 last = swf_GetBits(tag, 1);
 297                 run = swf_GetBits(tag, 6);
 298                 level = swf_GetBits(tag, 8);
 299                 if(run)
 300                     DEBUG printf("(%d) E%d", run, level);
 301                 else
 302                     DEBUG printf("E");
 303                 if(level == 0 || level == 128) {
 304                     printf("error: level=%d\n", level);
 305                     exit(1);
 306                 }
 307                 level = (int)((signed char)level);
 308             } else {
 309                 int sign = swf_GetBits(tag, 1);
 310                 if(sign)
 311                     level = -level;
 312                 if(run)
 313                     DEBUG printf("(%d) %s%d", run, level>0?"+":"",level);
 314                 else
 315                     DEBUG printf("%s%d", level>0?"+":"",level);
 316             }
 317             pos += run+1;
 318             //DEBUG printf("run:%d level:%d\n", run, level);
 319             if(last) {
 320                 DEBUG printf("] pos: %d", pos);
 321                 if(pos>64) {
 322                     printf("\nerror:bad pos (%d)\n", pos);
 323                     exit(1);
 324                 }
 325                 return;
 326             }
 327         }
 328     }
 329 }
 330
 331 int readMVD(TAG*tag)
 332 {
 333     int index = gethuffvalue2(tag, mvd, mvd_tree);
 334     DEBUG printf("mvd index:%d\n", index);
 335     return index;
 336 }
 337
 338 char has_quant[] = {0,1,0,0,1};
 339 char has_mvd[] = {1,1,3,0,0};
 340
 341 #define TYPE_INTRA 0
 342 #define TYPE_INTER 1
 343
 344 int tagnr = 0;
 345
 346 void decode_block(TAG*tag, int pictype)
 347 {
 348     int t;
 349     int mb_type = -1, cbpc = -1;
 350     int dquant;
 351     int cbpy_index, cbpy_value;
 352     int intrablock = 0;
 353     int type;
 354     if(pictype == TYPE_INTER) /* non-intra pictures have a cod flag */
 355     {
 356         int cod = swf_GetBits(tag, 1);
 357         DEBUG printf("cod=%d\n",cod);
 358         if(cod) {
 359             printf(".");
 360             return;
 361         }
 362     }
 363     type = -1;
 364
 365     /* read mcbpc */
 366
 367     if(pictype == TYPE_INTRA) { /* I-frame */
 368         type = gethuffvalue2(tag, mcbpc_intra, mcbpc_intra_tree);
 369         DEBUG printf("mcbpc=%d\n",type);
 370         mb_type = mcbpc_intra_params[type].mb_type;
 371         cbpc = mcbpc_intra_params[type].cbpc;
 372         if(type == MCBPC_INTRA_STUFFING) {
 373             printf("stuffing not supported yet!\n");
 374             exit(1); //TODO: goto COD
 375         }
 376     }
 377     else if(pictype == 1) { /* P-frame */
 378         type = gethuffvalue2(tag, mcbpc_inter, mcbpc_inter_tree);
 379         DEBUG printf("mcbpc=%d\n",type);
 380         mb_type = mcbpc_inter_params[type].mb_type;
 381         cbpc = mcbpc_inter_params[type].cbpc;
 382         if(type == MCBPC_INTER_STUFFING) {
 383             printf("stuffing not supported yet!(2)\n");
 384             exit(1); //TODO: goto COD
 385         }
 386     }
 387
 388     if(mb_type == 3 || mb_type == 4)
 389     {
 390         intrablock = 1;
 391     }
 392
 393     printf("%c", "vqVii"[mb_type]);
 394
 395     DEBUG printf("mcbpc type: %d mb_type:%d cbpc:%d\n", type, mb_type, cbpc);
 396
 397     /* read cbpy */
 398
 399     cbpy_index = gethuffvalue2(tag, cbpy, cbpy_tree);
 400     cbpy_value = cbpy_index;
 401     if(!intrablock)
 402         cbpy_value ^= 15;
 403     DEBUG printf("cbpy value:%d (%d)\n", cbpy_value, cbpy_index);
 404
 405
 406     /* I 0: 00 mcbpc/cbpy
 407        P 0: 00 cod/mcbpc/cbpy/mvd
 408        P 6: 10 cod/mcbpc/cbpy/dquant/mvd
 409        P 8: 00 cod/mcbpc/cbpy/mvd/mvd24
 410     */
 411
 412     /* quantizer */
 413     if(has_quant[mb_type]) {
 414         dquant = swf_GetBits(tag, 2);
 415         if(dquant == 0) dquant = -1;
 416         else if(dquant == 1) dquant = -2;
 417         else if(dquant == 2) dquant = +1;
 418         else if(dquant == 3) dquant = +2;
 419         DEBUG printf("dquant: %d\n", dquant);
 420     }
 421
 422     if(has_mvd[mb_type]&1) {
 423         int x,y;
 424         x = readMVD(tag); //horizontal
 425         y = readMVD(tag); //vertical
 426         if(x==32 && y==32)
 427             printf("\b0");
 428     }
 429     if(has_mvd[mb_type]&2) {
 430         /* only in advanced prediction mode */
 431         readMVD(tag); //horizontal
 432         readMVD(tag); //vertical
 433         readMVD(tag); //horizontal
 434         readMVD(tag); //vertical
 435         readMVD(tag); //horizontal
 436         readMVD(tag); //vertical
 437     }
 438
 439     for(t=0;t<4;t++) {
 440         int has_intradc = intrablock;
 441         int has_tcoef = cbpy_value & (8>>t);
 442         DEBUG printf("luminance%d ", t);
 443         get_DC_TCOEF(tag, t, has_intradc, has_tcoef); /*luminance - affected by cbpy*/
 444         DEBUG printf("\n");
 445     }
 446     for(t=0;t<2;t++) {
 447         int has_intradc = intrablock;
 448         int has_tcoef = cbpc & (2>>t);
 449         DEBUG printf("chrominance%d ", t);
 450         get_DC_TCOEF(tag, t, has_intradc, has_tcoef); /*chrominance - affected by mcbc*/
 451         DEBUG printf("\n");
 452     }
 453 }
 454
 455 void handleVideoFrame(TAG*tag, char*prefix)
 456 {
 457     U32 code, version, reference, sizeflags;
 458     U32 width, height;
 459     U8 blocktype, pictype;
 460     U16 id = swf_GetU16(tag);
 461     U16 frame = swf_GetU16(tag);
 462     U8 deblock,flags, tmp, bit;
 463     U32 quantizer, extrainfo;
 464     int skipped = 0;
 465     int pos=0;
 466     int num;
 467     int disposable = 0;
 468     int blocknum;
 469     int bbx,bby,bx,by;
 470     char*types[] = {"intra- (I-)frame", "inter- (P-)frame", "disposable interframe", "<reserved>"};
 471     printf("============================= frame %d ===================================", frame);
 472
 473     /* video packet follows */
 474     printf("\n");
 475     code = swf_GetBits(tag, 17);
 476     if(code!=1) {
 477         printf("code: %x (?)\n", code);
 478         return;
 479     }
 480     version = swf_GetBits(tag, 5); /*actually, part of the picture start code */
 481     //printf("version: %x\n", version); /*usually 0*/
 482     if(version >= 1) {
 483         /* version 1 has some different transform coefficient coding which we
 484            can't handle yet */
 485         printf("spark version %d not supported yet\n", version);
 486         exit(1);
 487     }
 488     reference = swf_GetBits(tag, 8);
 489     DEBUG printf("reference: %d\n", reference); /*usually same as frame number (unless frames were skipped while encoding)*/
 490
 491     sizeflags = swf_GetBits(tag, 3);
 492     switch(sizeflags)
 493     {
 494         case 0: width = swf_GetBits(tag,8); height = swf_GetBits(tag,8); break;
 495         case 1: width = swf_GetBits(tag, 16); height = swf_GetBits(tag, 16); break;
 496         case 2: width = 352; height = 288; break;
 497         case 3: width = 176; height = 144; break;
 498         case 4: width = 128; height = 96; break;
 499         case 5: width = 320; height = 240; break;
 500         case 6: width = 160; height = 120; break;
 501         case 7: width = -1; height = -1;/*reserved*/ break;
 502     }
 503
 504     pictype = swf_GetBits(tag, 2);
 505     if(pictype==3) {
 506         printf("error: unknown pictype: %d\n", pictype);
 507         exit(1);
 508     }
 509     if(pictype==2)  {
 510         pictype = TYPE_INTER;
 511         disposable = 1;
 512     }
 513     if(pictype==TYPE_INTER)
 514         printf("INTER P%s", disposable?" (disposeable)":"");
 515     else
 516         printf("INTRA I");
 517
 518     deblock = swf_GetBits(tag, 1); /*usually 0*/
 519     DEBUG printf("deblock: %d\n", deblock);
 520     quantizer = swf_GetBits(tag, 5); /*usually 9*/
 521     DEBUG printf("quantizer: %d\n", quantizer);
 522
 523     extrainfo = swf_GetBits(tag, 1); /*usually none */
 524     while(extrainfo) {
 525         extrainfo = swf_GetBits(tag, 8);
 526         printf("extrainfo: %02x\n", extrainfo);
 527         extrainfo = swf_GetBits(tag, 1);
 528     }
 529
 530     /* macro block */
 531     bbx = (width+15)/16;
 532     bby = (height+15)/16;
 533     blocknum = bbx*bby;
 534     printf("%dx%d [blocks: %dx%d=%d]\n", width, height, bbx,bby, blocknum);
 535
 536     /*if(pictype == TYPE_INTER)
 537         return;*/
 538     /*if(pictype == TYPE_INTRA)
 539         return;*/
 540
 541     /*tagnr++;
 542     if(tagnr!=2)
 543         return;*/
 544
 545     DEBUG printf("\n");
 546     for(by=0;by<bby;by++)
 547     {
 548         for(bx=0;bx<bbx;bx++)
 549         {
 550             decode_block(tag, pictype);
 551         }
 552         printf("\n");
 553     }
 554 }
 555
 556 void hexdumpTag(TAG*tag, char* prefix)
 557 {
 558     int t;
 559     printf("                %s-=> ",prefix);
 560     for(t=0;t<tag->len;t++) {
 561         printf("%02x ", tag->data[t]);
 562         if((t && ((t&15)==15)) || (t==tag->len-1))
 563         {
 564             if(t==tag->len-1)
 565                 printf("\n");
 566             else
 567                 printf("\n                %s-=> ",prefix);
 568         }
 569     }
 570 }
 571
 572 int main (int argc,char ** argv)
 573 {
 574     TAG*tag;
 575     SWF swf;
 576     int f;
 577     char prefix[128];
 578     int filesize = 0;
 579     prefix[0] = 0;
 580
 581     checkhufftable(rle, "rle");
 582     checkhufftable(mcbpc_intra, "intra");
 583     checkhufftable(mcbpc_inter, "inter");
 584     checkhufftable(cbpy, "cbpy");
 585     checkhufftable(mvd, "mvd");
 586
 587     rle_tree = huffcode2tree(rle);
 588     mcbpc_intra_tree = huffcode2tree(mcbpc_intra);
 589     mcbpc_inter_tree = huffcode2tree(mcbpc_inter);
 590     cbpy_tree = huffcode2tree(cbpy);
 591     mvd_tree = huffcode2tree(mvd);
 592
 593     processargs(argc, argv);
 594     if(!filename) {
 595         fprintf(stderr, "You must supply a filename.\n");
 596         return 1;
 597     }
 598
 599     f = open(filename,O_RDONLY);
 600
 601     if (f<0) {
 602         perror("Couldn't open file: ");
 603         exit(1);
 604     }
 605     if FAILED(swf_ReadSWF(f,&swf)) {
 606         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
 607         close(f);
 608         exit(1);
 609     }
 610
 611     close(f);
 612
 613     printf("[HEADER]        File version: %d\n", swf.fileVersion);
 614     if(swf.compressed) {
 615         printf("[HEADER]        File is zlib compressed.");
 616         if(filesize && swf.fileSize)
 617             printf(" Ratio: %02d%%\n", filesize*100/(swf.fileSize));
 618         else
 619             printf("\n");
 620     }
 621     printf("[HEADER]        File size: %ld%s\n", swf.fileSize, swf.compressed?" (Depacked)":"");
 622     printf("[HEADER]        Frame rate: %f\n",swf.frameRate/256.0);
 623     printf("[HEADER]        Frame count: %d\n",swf.frameCount);
 624     printf("[HEADER]        Movie width: %.2f",(swf.movieSize.xmax-swf.movieSize.xmin)/20.0);
 625     if(swf.movieSize.xmin)
 626         printf(" (left offset: %.2f)\n", swf.movieSize.xmin/20.0);
 627     else
 628         printf("\n");
 629     printf("[HEADER]        Movie height: %.2f",(swf.movieSize.ymax-swf.movieSize.ymin)/20.0);
 630     if(swf.movieSize.ymin)
 631         printf(" (top offset: %.2f)\n", swf.movieSize.ymin/20.0);
 632     else
 633         printf("\n");
 634
 635     tag = swf.firstTag;
 636
 637     while(tag) {
 638         char*name = swf_TagGetName(tag);
 639         char myprefix[128];
 640         //printf("[%03x] %9ld %s%s", tag->id, tag->len, prefix, swf_TagGetName(tag));
 641
 642         if(swf_isDefiningTag(tag)) {
 643             U16 id = swf_GetDefineID(tag);
 644             //printf(" defines id %04d", id);
 645         }
 646         else if(swf_isPseudoDefiningTag(tag)) {
 647             U16 id = swf_GetDefineID(tag);
 648             //printf(" adds information to id %04d", id);
 649         }
 650
 651         if(tag->id == ST_VIDEOFRAME) {
 652             handleVideoFrame(tag, myprefix);
 653             //printf("\n");
 654         }
 655         else if(tag->id == ST_DEFINEVIDEOSTREAM) {
 656             handleVideoStream(tag, myprefix);
 657             printf("\n");
 658         }
 659         else {
 660             //printf("\n");
 661         }
 662
 663         sprintf(myprefix, "                %s", prefix);
 664
 665         if(tag->len && hex) {
 666             hexdumpTag(tag, prefix);
 667         }
 668         tag = tag->next;
 669         fflush(stdout);
 670     }
 671
 672     swf_FreeTags(&swf);
 673     return 0;
 674 }
 675
 676