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                 }
 313                 if(run) {
 314                     DEBUG printf(" (%d) %s%d", run, level>0?"+":"",level);
 315                 } else {
 316                     DEBUG printf(" %s%d", level>0?"+":"",level);
 317                 }
 318             }
 319             pos += run+1;
 320             //DEBUG printf("run:%d level:%d\n", run, level);
 321             if(last) {
 322                 DEBUG printf("] pos: %d", pos);
 323                 if(pos>64) {
 324                     printf("\nerror:bad pos (%d)\n", pos);
 325                     exit(1);
 326                 }
 327                 return;
 328             }
 329         }
 330     }
 331 }
 332
 333 int readMVD(TAG*tag)
 334 {
 335     int index = gethuffvalue2(tag, mvd, mvd_tree);
 336     DEBUG printf("mvd index:%d\n", index);
 337     return index;
 338 }
 339
 340 char has_quant[] = {0,1,0,0,1};
 341 char has_mvd[] = {1,1,3,0,0};
 342
 343 #define TYPE_INTRA 0
 344 #define TYPE_INTER 1
 345
 346 int tagnr = 0;
 347
 348 void decode_block(TAG*tag, int pictype)
 349 {
 350     int t;
 351     int mb_type = -1, cbpc = -1;
 352     int dquant;
 353     int cbpy_index, cbpy_value;
 354     int intrablock = 0;
 355     int type;
 356     if(pictype == TYPE_INTER) /* non-intra pictures have a cod flag */
 357     {
 358         int cod = swf_GetBits(tag, 1);
 359         DEBUG printf("cod=%d\n",cod);
 360         if(cod) {
 361             printf(".");
 362             return;
 363         }
 364     }
 365     type = -1;
 366
 367     /* read mcbpc */
 368
 369     if(pictype == TYPE_INTRA) { /* I-frame */
 370         type = gethuffvalue2(tag, mcbpc_intra, mcbpc_intra_tree);
 371         DEBUG printf("mcbpc=%d\n",type);
 372         mb_type = mcbpc_intra_params[type].mb_type;
 373         cbpc = mcbpc_intra_params[type].cbpc;
 374         if(type == MCBPC_INTRA_STUFFING) {
 375             printf("stuffing not supported yet!\n");
 376             exit(1); //TODO: goto COD
 377         }
 378     }
 379     else if(pictype == 1) { /* P-frame */
 380         type = gethuffvalue2(tag, mcbpc_inter, mcbpc_inter_tree);
 381         DEBUG printf("mcbpc=%d\n",type);
 382         mb_type = mcbpc_inter_params[type].mb_type;
 383         cbpc = mcbpc_inter_params[type].cbpc;
 384         if(type == MCBPC_INTER_STUFFING) {
 385             printf("stuffing not supported yet!(2)\n");
 386             exit(1); //TODO: goto COD
 387         }
 388     }
 389
 390     if(mb_type == 3 || mb_type == 4)
 391     {
 392         intrablock = 1;
 393     }
 394
 395     printf("%c", "vqVii"[mb_type]);
 396
 397     DEBUG printf("mcbpc type: %d mb_type:%d cbpc:%d\n", type, mb_type, cbpc);
 398
 399     /* read cbpy */
 400
 401     cbpy_index = gethuffvalue2(tag, cbpy, cbpy_tree);
 402     cbpy_value = cbpy_index;
 403     if(!intrablock)
 404         cbpy_value ^= 15;
 405     DEBUG printf("cbpy value:%d (%d)\n", cbpy_value, cbpy_index);
 406
 407
 408     /* I 0: 00 mcbpc/cbpy
 409        P 0: 00 cod/mcbpc/cbpy/mvd
 410        P 6: 10 cod/mcbpc/cbpy/dquant/mvd
 411        P 8: 00 cod/mcbpc/cbpy/mvd/mvd24
 412     */
 413
 414     /* quantizer */
 415     if(has_quant[mb_type]) {
 416         dquant = swf_GetBits(tag, 2);
 417         if(dquant == 0) dquant = -1;
 418         else if(dquant == 1) dquant = -2;
 419         else if(dquant == 2) dquant = +1;
 420         else if(dquant == 3) dquant = +2;
 421         DEBUG printf("dquant: %d\n", dquant);
 422     }
 423
 424     if(has_mvd[mb_type]&1) {
 425         int x,y;
 426         x = readMVD(tag); //horizontal
 427         y = readMVD(tag); //vertical
 428         /*if(x==32 && y==32)
 429             printf("\b0"); // prediction was 100% match
 430          */
 431     }
 432     if(has_mvd[mb_type]&2) {
 433         /* only in advanced prediction mode */
 434         readMVD(tag); //horizontal
 435         readMVD(tag); //vertical
 436         readMVD(tag); //horizontal
 437         readMVD(tag); //vertical
 438         readMVD(tag); //horizontal
 439         readMVD(tag); //vertical
 440     }
 441
 442     for(t=0;t<4;t++) {
 443         int has_intradc = intrablock;
 444         int has_tcoef = cbpy_value & (8>>t);
 445         DEBUG printf("luminance%d ", t);
 446         get_DC_TCOEF(tag, t, has_intradc, has_tcoef); /*luminance - affected by cbpy*/
 447         DEBUG printf("\n");
 448     }
 449     for(t=0;t<2;t++) {
 450         int has_intradc = intrablock;
 451         int has_tcoef = cbpc & (2>>t);
 452         DEBUG printf("chrominance%d ", t);
 453         get_DC_TCOEF(tag, t, has_intradc, has_tcoef); /*chrominance - affected by mcbc*/
 454         DEBUG printf("\n");
 455     }
 456 }
 457
 458 void handleVideoFrame(TAG*tag, char*prefix)
 459 {
 460     U32 code, version, reference, sizeflags;
 461     U32 width, height;
 462     U8 blocktype, pictype;
 463     U16 id = swf_GetU16(tag);
 464     U16 frame = swf_GetU16(tag);
 465     U8 deblock,flags, tmp, bit;
 466     U32 quantizer, extrainfo;
 467     int skipped = 0;
 468     int pos=0;
 469     int num;
 470     int disposable = 0;
 471     int blocknum;
 472     int bbx,bby,bx,by;
 473     char*types[] = {"intra- (I-)frame", "inter- (P-)frame", "disposable interframe", "<reserved>"};
 474     printf("============================= frame %d ===================================", frame);
 475
 476     /* video packet follows */
 477     printf("\n");
 478     code = swf_GetBits(tag, 17);
 479     if(code!=1) {
 480         printf("code: %x (?)\n", code);
 481         return;
 482     }
 483     version = swf_GetBits(tag, 5); /*actually, part of the picture start code */
 484     //printf("version: %x\n", version); /*usually 0*/
 485     if(version >= 1) {
 486         /* version 1 has some different transform coefficient coding which we
 487            can't handle yet */
 488         printf("spark version %d not supported yet\n", version);
 489         exit(1);
 490     }
 491     reference = swf_GetBits(tag, 8);
 492     DEBUG printf("reference: %d\n", reference); /*usually same as frame number (unless frames were skipped while encoding)*/
 493
 494     sizeflags = swf_GetBits(tag, 3);
 495     switch(sizeflags)
 496     {
 497         case 0: width = swf_GetBits(tag,8); height = swf_GetBits(tag,8); break;
 498         case 1: width = swf_GetBits(tag, 16); height = swf_GetBits(tag, 16); break;
 499         case 2: width = 352; height = 288; break;
 500         case 3: width = 176; height = 144; break;
 501         case 4: width = 128; height = 96; break;
 502         case 5: width = 320; height = 240; break;
 503         case 6: width = 160; height = 120; break;
 504         case 7: width = -1; height = -1;/*reserved*/ break;
 505     }
 506
 507     pictype = swf_GetBits(tag, 2);
 508     if(pictype==3) {
 509         printf("error: unknown pictype: %d\n", pictype);
 510         exit(1);
 511     }
 512     if(pictype==2)  {
 513         pictype = TYPE_INTER;
 514         disposable = 1;
 515     }
 516     if(pictype==TYPE_INTER)
 517         printf("INTER P%s", disposable?" (disposeable)":"");
 518     else
 519         printf("INTRA I");
 520
 521     deblock = swf_GetBits(tag, 1); /*usually 0*/
 522     DEBUG printf("deblock: %d\n", deblock);
 523     quantizer = swf_GetBits(tag, 5); /*usually 9*/
 524     DEBUG printf("quantizer: %d\n", quantizer);
 525
 526     extrainfo = swf_GetBits(tag, 1); /*usually none */
 527     while(extrainfo) {
 528         extrainfo = swf_GetBits(tag, 8);
 529         printf("extrainfo: %02x\n", extrainfo);
 530         extrainfo = swf_GetBits(tag, 1);
 531     }
 532
 533     /* macro block */
 534     bbx = (width+15)/16;
 535     bby = (height+15)/16;
 536     blocknum = bbx*bby;
 537     printf("%dx%d [blocks: %dx%d=%d]\n", width, height, bbx,bby, blocknum);
 538
 539     /*if(pictype == TYPE_INTER)
 540         return;*/
 541     /*if(pictype == TYPE_INTRA)
 542         return;*/
 543
 544     /*tagnr++;
 545     if(tagnr!=2)
 546         return;*/
 547
 548     DEBUG printf("\n");
 549     for(by=0;by<bby;by++)
 550     {
 551         for(bx=0;bx<bbx;bx++)
 552         {
 553             decode_block(tag, pictype);
 554         }
 555         printf("\n");
 556     }
 557 }
 558
 559 void hexdumpTag(TAG*tag, char* prefix)
 560 {
 561     int t;
 562     printf("                %s-=> ",prefix);
 563     for(t=0;t<tag->len;t++) {
 564         printf("%02x ", tag->data[t]);
 565         if((t && ((t&15)==15)) || (t==tag->len-1))
 566         {
 567             if(t==tag->len-1)
 568                 printf("\n");
 569             else
 570                 printf("\n                %s-=> ",prefix);
 571         }
 572     }
 573 }
 574
 575 int main (int argc,char ** argv)
 576 {
 577     TAG*tag;
 578     SWF swf;
 579     int f;
 580     char prefix[128];
 581     int filesize = 0;
 582     prefix[0] = 0;
 583
 584     checkhufftable(rle, "rle");
 585     checkhufftable(mcbpc_intra, "intra");
 586     checkhufftable(mcbpc_inter, "inter");
 587     checkhufftable(cbpy, "cbpy");
 588     checkhufftable(mvd, "mvd");
 589
 590     rle_tree = huffcode2tree(rle);
 591     mcbpc_intra_tree = huffcode2tree(mcbpc_intra);
 592     mcbpc_inter_tree = huffcode2tree(mcbpc_inter);
 593     cbpy_tree = huffcode2tree(cbpy);
 594     mvd_tree = huffcode2tree(mvd);
 595
 596     processargs(argc, argv);
 597     if(!filename) {
 598         fprintf(stderr, "You must supply a filename.\n");
 599         return 1;
 600     }
 601
 602     f = open(filename,O_RDONLY);
 603
 604     if (f<0) {
 605         perror("Couldn't open file: ");
 606         exit(1);
 607     }
 608     if FAILED(swf_ReadSWF(f,&swf)) {
 609         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
 610         close(f);
 611         exit(1);
 612     }
 613
 614     close(f);
 615
 616     printf("[HEADER]        File version: %d\n", swf.fileVersion);
 617     if(swf.compressed) {
 618         printf("[HEADER]        File is zlib compressed.");
 619         if(filesize && swf.fileSize)
 620             printf(" Ratio: %02d%%\n", filesize*100/(swf.fileSize));
 621         else
 622             printf("\n");
 623     }
 624     printf("[HEADER]        File size: %ld%s\n", swf.fileSize, swf.compressed?" (Depacked)":"");
 625     printf("[HEADER]        Frame rate: %f\n",swf.frameRate/256.0);
 626     printf("[HEADER]        Frame count: %d\n",swf.frameCount);
 627     printf("[HEADER]        Movie width: %.2f",(swf.movieSize.xmax-swf.movieSize.xmin)/20.0);
 628     if(swf.movieSize.xmin)
 629         printf(" (left offset: %.2f)\n", swf.movieSize.xmin/20.0);
 630     else
 631         printf("\n");
 632     printf("[HEADER]        Movie height: %.2f",(swf.movieSize.ymax-swf.movieSize.ymin)/20.0);
 633     if(swf.movieSize.ymin)
 634         printf(" (top offset: %.2f)\n", swf.movieSize.ymin/20.0);
 635     else
 636         printf("\n");
 637
 638     tag = swf.firstTag;
 639
 640     while(tag) {
 641         char*name = swf_TagGetName(tag);
 642         char myprefix[128];
 643         //printf("[%03x] %9ld %s%s", tag->id, tag->len, prefix, swf_TagGetName(tag));
 644
 645         if(swf_isDefiningTag(tag)) {
 646             U16 id = swf_GetDefineID(tag);
 647             //printf(" defines id %04d", id);
 648         }
 649         else if(swf_isPseudoDefiningTag(tag)) {
 650             U16 id = swf_GetDefineID(tag);
 651             //printf(" adds information to id %04d", id);
 652         }
 653
 654         if(tag->id == ST_VIDEOFRAME) {
 655             handleVideoFrame(tag, myprefix);
 656             //printf("\n");
 657         }
 658         else if(tag->id == ST_DEFINEVIDEOSTREAM) {
 659             handleVideoStream(tag, myprefix);
 660             printf("\n");
 661         }
 662         else {
 663             //printf("\n");
 664         }
 665
 666         sprintf(myprefix, "                %s", prefix);
 667
 668         if(tag->len && hex) {
 669             hexdumpTag(tag, prefix);
 670         }
 671         tag = tag->next;
 672         fflush(stdout);
 673     }
 674
 675     swf_FreeTags(&swf);
 676     return 0;
 677 }
 678
 679