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