JHHM

dedit

a tool for Teeworlds demo file shenanigens
git clone https://jhhm.no/repos/dedit.git

dedit/src/demo.c

get raw file: demo.c

1/* This file is part of dedit - a tool for editing Teeworlds/DDNet demo files
2   Copyright (C) 2024-2026 JHHM
3
4   Dedit is free software: you can redistribute it and/or modify
5   it under the terms of the GNU General Public License as published by
6   the Free Software Foundation, either version 3 of the License, or
7   (at your option) any later version.
8
9   Dedit is distributed in the hope that it will be useful,
10   but WITHOUT ANY WARRANTY; without even the implied warranty of
11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   GNU General Public License for more details.
13
14   You should have received a copy of the GNU General Public License
15   along with dedit.  If not, see <https://www.gnu.org/licenses/>. */
16
17#define _POSIX_C_SOURCE 200112L
18
19#include "demo.h"
20#include "huffman.h"
21#include "pack.h"
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#define CHUNK_TICK_MASK 0x80          // 0b10000000
28#define CHUNK_TICK_KEYFRAME_MASK 0x40 // 0b01000000
29#define CHUNK_TICK_INLINE_MASK 0x20   // 0b00100000
30#define CHUNK_TICK_DELTA_V3_MASK 0x3f // 0b00111111
31#define CHUNK_TICK_DELTA_V5_MASK 0x1f // 0b00011111
32#define CHUNK_NORMAL_TYPE_MASK 0x60   // 0b01100000
33#define CHUNK_NORMAL_SIZE_MASK 0x1f   // 0b00011111
34
35const char headermagic[7] = "TWDEMO";
36const unsigned char mapmagic[] = {0x6b, 0xe6, 0xda, 0x4a, 0xce, 0xbd, 0x38, 0x0c,
37                                  0x9b, 0x5b, 0x12, 0x89, 0xc8, 0x42, 0xd7, 0x80};
38
39#define BUFF_SIZE 1024 * 64
40
41int snapitemsizes06[] = {
42    0,  // index 0, unused
43    10, // id  1
44    6,  // id  2
45    5,  // id  3
46    4,  // id  4
47    3,  // id  5
48    8,  // id  6
49    4,  // id  7
50    15, // id  8
51    22, // id  9
52    5,  // id 10
53    17, // id 11
54    3,  // id 12
55    2,  // id 13
56    2,  // id 14
57    2,  // id 15
58    2,  // id 16
59    3,  // id 17
60    3,  // id 18
61    3,  // id 19
62    3   // id 20
63};
64
65void freedemo(demo *demo)
66{
67    free(demo->map.data);
68    freedemodata(&demo->data);
69}
70
71void freedemodata(demodata *data)
72{
73    for (int i = 0; i < data->numchunks; i++)
74    {
75        demochunk *chunk = &data->chunks[i];
76        switch (chunk->type)
77        {
78        case DEMOTICK:
79            free(chunk->data.tick);
80            break;
81        case DEMOSNAP:
82            for (int y = 0; y < chunk->data.snap->numitems; y++)
83                free(chunk->data.snap->items[y].data);
84            free(chunk->data.snap->offsets);
85            free(chunk->data.snap->items);
86            free(chunk->data.snap);
87            break;
88        case DEMOMESSAGE:
89            free(chunk->data.message->data);
90            free(chunk->data.message);
91            break;
92        case DEMODELTA:
93            free(chunk->data.delta->removeditemkeys);
94            for (int i = 0; i < chunk->data.delta->numitemdeltas; i++)
95                free(chunk->data.delta->itemdeltas[i].data);
96            free(chunk->data.delta->itemdeltas);
97            free(chunk->data.delta);
98            break;
99        default:
100            break;
101        }
102    }
103    free(data->chunks);
104    data->chunks = NULL;
105    data->numchunks = 0;
106}
107
108/* readers */
109
110int readdemoheader(FILE *fp, demoheader *dh)
111{
112    char magicbuff[sizeof(headermagic)];
113    unsigned char intbuff[4];
114
115    fread(magicbuff, 1, sizeof(headermagic), fp);
116    if (strcmp(magicbuff, headermagic) != 0)
117        return -1;
118
119    if (fread(&dh->version, 1, 1, fp) != 1)
120        return -2;
121
122    if (fread(&dh->netversion, 1, 64, fp) != 64)
123        return -3;
124
125    if (fread(&dh->mapname, 1, 64, fp) != 64)
126        return -4;
127
128    if (fread(intbuff, 1, 4, fp) != 4)
129        return -5;
130    dh->mapsize = frombigendian(intbuff);
131
132    if (fread(intbuff, 1, 4, fp) != 4)
133        return -6;
134    dh->mapcrc = frombigendian(intbuff);
135
136    if (fread(dh->type, 1, 8, fp) != 8)
137        return -7;
138
139    if (fread(intbuff, 1, 4, fp) != 4)
140        return -8;
141    dh->length = frombigendian(intbuff);
142
143    if (fread(dh->timestamp, 1, 20, fp) != 20)
144        return -9;
145
146    return 1;
147}
148
149int readdemotimeline(FILE *fp, demotimeline *dt)
150{
151    if (fread(dt->data, 1, DEMO_TIMELINE_LENGTH, fp) != DEMO_TIMELINE_LENGTH)
152        return -1;
153    return 1;
154}
155
156int readdemomap(FILE *fp, demomap *dm, int mapsize, unsigned char ver)
157{
158    if (ver >= 6)
159    {
160        char magicbuf[sizeof(mapmagic)];
161
162        fread(magicbuf, 1, sizeof(mapmagic), fp);
163        if (memcmp(magicbuf, mapmagic, sizeof(mapmagic)) != 0)
164            return -1;
165
166        if (fread(dm->sha256, 1, 32, fp) != 32)
167            return -2;
168    }
169
170    dm->data = (char *)malloc(mapsize);
171    if (fread(dm->data, 1, mapsize, fp) != (size_t)mapsize)
172        return -3;
173
174    return 1;
175}
176
177int readdemotick(FILE *fp, char chunkhead, demotick *tick, unsigned char ver)
178{
179    tick->keyframe = (chunkhead & CHUNK_TICK_KEYFRAME_MASK) >> 6;
180
181    if (ver >= 5)
182    {
183        if (chunkhead & CHUNK_TICK_INLINE_MASK)
184        {
185            tick->innline = 1;
186            tick->delta = (chunkhead & CHUNK_TICK_DELTA_V5_MASK);
187        }
188        else
189        {
190            tick->innline = 0;
191            unsigned char tickdelta[4];
192            fread(tickdelta, 1, 4, fp);
193            tick->delta = frombigendian(tickdelta);
194        }
195    }
196    else
197    {
198        if ((chunkhead & CHUNK_TICK_DELTA_V3_MASK) != 0)
199        {
200            tick->delta = (chunkhead & CHUNK_TICK_DELTA_V3_MASK);
201            tick->innline = 1;
202        }
203        else
204        {
205            tick->innline = 0;
206            unsigned char tickdelta[4];
207            fread(tickdelta, 1, 4, fp);
208            tick->delta = frombigendian(tickdelta);
209        }
210    }
211    return 1;
212}
213
214int readdemosnap(FILE *fp, demosnap *snap, int size)
215{
216    char data[size];
217    char unpacked[BUFF_SIZE];
218
219    fread(data, 1, size, fp);
220
221    if (decompresshuff((char *)data, size, (char *)unpacked, BUFF_SIZE) < 0)
222    {
223        printf("[ ERROR ] error while decompressing snap cunk!\n");
224        return 0;
225    }
226
227    char *cp = unpacked;
228
229    snap->datasize = readint(&cp);
230    snap->numitems = readint(&cp);
231
232    snap->offsets = (int *)malloc(snap->numitems * sizeof(int));
233    snap->items = (demosnapitem *)malloc(snap->numitems * sizeof(demosnapitem));
234
235    for (int i = 0; i < snap->numitems; i++)
236        snap->offsets[i] = readint(&cp);
237
238    for (int i = 0; i < snap->numitems; i++)
239    {
240        unsigned int item_key = (unsigned int)readint(&cp);
241
242        snap->items[i].type = (item_key >> 16) & 0xffff;
243        snap->items[i].id = (item_key & 0xffff);
244
245        if (i == (snap->numitems - 1))
246            snap->items[i].numdata = (snap->datasize - snap->offsets[i]) / 4 - 1;
247        else
248            snap->items[i].numdata = (snap->offsets[i + 1] - snap->offsets[i]) / 4 - 1;
249
250        snap->items[i].data = (int *)malloc(snap->items[i].numdata * sizeof(int));
251
252        for (int y = 0; y < snap->items[i].numdata; y++)
253            snap->items[i].data[y] = readint(&cp);
254    }
255
256    return 1;
257}
258
259int readdemomessage(FILE *fp, demomessage *message, int size)
260{
261    unsigned char data[size];
262    if (fread(data, 1, size, fp) != (size_t)size)
263        return -1;
264
265    message->data = (char *)malloc(size);
266    memcpy(message->data, data, size);
267    message->datasize = size;
268
269    return 1;
270}
271
272int readdemodelta(FILE *fp, demodelta *delta, int size)
273{
274    char data[size];
275    if (fread(data, 1, size, fp) != (size_t)size)
276        return -1;
277
278    char unpacked[BUFF_SIZE];
279
280    int s = decompresshuff(data, size, unpacked, BUFF_SIZE);
281    if (s < 0)
282    {
283        printf("[ ERROR ] error while decompressing delta cunk!\n");
284        return 0;
285    }
286
287    char *cp = unpacked;
288    delta->numremoveditems = readint(&cp);
289    delta->numitemdeltas = readint(&cp);
290    int zeros = readint(&cp);
291
292    if (zeros != 0)
293        printf("[ WARNING ] zeroes in delta is not zero!\n");
294
295     delta->removeditemkeys = NULL;
296     delta->itemdeltas = NULL;
297
298    if (delta->numremoveditems > 0)
299        delta->removeditemkeys = (int *)malloc(delta->numremoveditems * sizeof(int));
300
301    for (int i = 0; i < delta->numremoveditems; i++)
302        delta->removeditemkeys[i] = readint(&cp);
303
304    if (delta->numitemdeltas > 0)
305        delta->itemdeltas = (demodeltaitem *)malloc(delta->numitemdeltas * sizeof(demodeltaitem));
306
307    for (int i = 0; i < delta->numitemdeltas; i++)
308    {
309        demodeltaitem *item = &delta->itemdeltas[i];
310        item->type = readint(&cp);
311        item->id = readint(&cp);
312
313        // TODO: 1 <= type <= 20 is 0.6 protocol spesific
314        if (item->type >= 1 && item->type <= 20)
315            item->size = snapitemsizes06[item->type];
316        else
317            item->size = readint(&cp);
318
319        item->data = (int *)malloc(item->size * sizeof(int));
320
321        for (int i = 0; i < item->size; i++)
322            item->data[i] = readint(&cp);
323    }
324
325    return 1;
326}
327
328int readdemochunk(FILE *fp, demochunk *chunk, unsigned char ver)
329{
330    char chunkhead;
331    chunkhead = (char)fgetc(fp);
332
333    if (chunkhead == EOF)
334        return 0;
335
336    if (chunkhead & CHUNK_TICK_MASK)
337    {
338        demotick *tick = (demotick *)malloc(sizeof(demotick));
339        memset(tick, 0, sizeof(demotick)); // TODO idk if necessary
340
341        if (readdemotick(fp, chunkhead, tick, ver))
342        {
343            chunk->type = DEMOTICK;
344            chunk->data.tick = tick;
345        }
346        else
347        {
348            printf("[ ERROR ] error while reading tick!\n");
349            return -1;
350        }
351    }
352    else
353    {
354        demochunktype type = (demochunktype)((chunkhead & CHUNK_NORMAL_TYPE_MASK) >> 5);
355        short size = (chunkhead & CHUNK_NORMAL_SIZE_MASK);
356
357        if (size == 30)
358            size = (short)fgetc(fp);
359        else if (size == 31)
360            fread(&size, sizeof(short), 1, fp);
361
362        if (type == DEMOSNAP)
363        {
364            demosnap *snap = (demosnap *)malloc(sizeof(demosnap));
365            memset(snap, 0, sizeof(demosnap)); // TODO idk if necessary
366
367            if (readdemosnap(fp, snap, size))
368            {
369                chunk->type = DEMOSNAP;
370                chunk->data.snap = snap;
371            }
372            else
373            {
374                printf("[ ERROR ] error while reading snapshot!\n");
375                return -1;
376            }
377        }
378        else if (type == DEMOMESSAGE)
379        {
380            demomessage *message = (demomessage *)malloc(sizeof(demomessage));
381            readdemomessage(fp, message, size);
382            chunk->type = DEMOMESSAGE;
383            chunk->data.message = message;
384        }
385        else if (type == DEMODELTA)
386        {
387            demodelta *delta = (demodelta *)malloc(sizeof(demodelta));
388            readdemodelta(fp, delta, size);
389            chunk->type = DEMODELTA;
390            chunk->data.delta = delta;
391        }
392        else
393        {
394            printf("[ ERROR ] unknown chunk type!\n");
395        }
396    }
397    return 1;
398}
399
400int readdemochunks(FILE *fp, demodata *dd, unsigned char ver)
401{
402    int chunkcap = 1024;
403    dd->numchunks = 0;
404    dd->chunks = (demochunk *)malloc(chunkcap * sizeof(demochunk));
405
406    while (readdemochunk(fp, &dd->chunks[dd->numchunks], ver))
407    {
408        dd->numchunks++;
409        if (dd->numchunks >= chunkcap)
410        {
411            chunkcap *= 2;
412            dd->chunks = (demochunk *)realloc(dd->chunks, chunkcap * sizeof(demochunk));
413        }
414    }
415
416    dd->chunks = (demochunk *)realloc(dd->chunks, dd->numchunks * sizeof(demochunk));
417
418    return 1;
419}
420
421int readdemo(FILE *fp, demo *demo)
422{
423    if (readdemoheader(fp, &demo->header) <= 0)
424        return -1;
425
426    if (readdemotimeline(fp, &demo->timeline) <= 0)
427        return -2;
428
429    if (readdemomap(fp, &demo->map, demo->header.mapsize, demo->header.version) <= 0)
430        return -3;
431
432    readdemochunks(fp, &demo->data, demo->header.version);
433
434    return 1;
435}
436
437/* writers */
438
439int writedemoheader(FILE *fp, demoheader *dh)
440{
441    unsigned char intbuff[4];
442    if (fwrite(headermagic, 1, sizeof(headermagic), fp) != sizeof(headermagic))
443        return -1;
444
445    if (fwrite(&dh->version, 1, 1, fp) != 1)
446        return -2;
447
448    if (fwrite(dh->netversion, 1, 64, fp) != 64)
449        return -3;
450
451    if (fwrite(dh->mapname, 1, 64, fp) != 64)
452        return -4;
453
454    tobigendian(dh->mapsize, intbuff);
455    if (fwrite(intbuff, 1, 4, fp) != 4)
456        return -5;
457
458    tobigendian(dh->mapcrc, intbuff);
459    if (fwrite(intbuff, 1, 4, fp) != 4)
460        return -5;
461
462    if (fwrite(dh->type, 1, 8, fp) != 8)
463        return -6;
464
465    tobigendian(dh->length, intbuff);
466    if (fwrite(intbuff, 1, 4, fp) != 4)
467        return -7;
468
469    if (fwrite(dh->timestamp, 1, 20, fp) != 20)
470        return -8;
471
472    return 1;
473}
474
475int writedemotimeline(FILE *fp, demotimeline *dt)
476{
477    if (fwrite(dt->data, 1, DEMO_TIMELINE_LENGTH, fp) != DEMO_TIMELINE_LENGTH)
478        return -1;
479    return 1;
480}
481
482int writedemomap(FILE *fp, demomap *dm, int mapsize, unsigned char ver)
483{
484    if (ver >= 6)
485    {
486        // TODO is this magic for v6+ only?
487        if (fwrite(mapmagic, 1, sizeof(mapmagic), fp) != sizeof(mapmagic))
488            return -1;
489        if (fwrite(dm->sha256, 1, 32, fp) != 32)
490            return -1;
491    }
492
493    if (fwrite(dm->data, 1, mapsize, fp) != (size_t)mapsize)
494        return -2;
495
496    return 1;
497}
498
499/*
500  Function is derived from DDNet code (DDNet License).
501  See NOTICES file for full license details.
502
503  https://github.com/ddnet/ddnet/blob/79df5893ff26fa75d67e46f99e58f75b739ac362/src/engine/shared/demo.cpp#L270
504*/
505int writedemochunkheader(FILE *fp, demochunktype type, int size)
506{
507    unsigned char header[3];
508    header[0] = (((int)type) & 0x3) << 5;
509    if (size < 30)
510    {
511        header[0] |= size;
512        fputc(*header, fp);
513    }
514    else
515    {
516        if (size < 256)
517        {
518            header[0] |= 30;
519            header[1] = size & 0xff;
520            fwrite(header, 1, 2, fp);
521        }
522        else
523        {
524            header[0] |= 31;
525            header[1] = size & 0xff;
526            header[2] = size >> 8;
527            fwrite(header, 1, 3, fp);
528        }
529    }
530    return -1;
531}
532
533// TODO add erro checking
534int writedemotick(FILE *fp, demotick *tick, unsigned char ver)
535{
536    unsigned char header = CHUNK_TICK_MASK;
537    header |= tick->keyframe << 6;
538    if (ver >= 5)
539        header |= tick->innline << 5;
540
541    if (tick->innline)
542    {
543        header |= tick->delta;
544        fputc(header, fp);
545    }
546    else
547    {
548        fputc(header, fp);
549        unsigned char intbuf[4];
550        tobigendian(tick->delta, intbuf);
551        fwrite(intbuf, 4, 1, fp);
552    }
553
554    return 1;
555}
556
557int writedemosnap(FILE *fp, demosnap *snap)
558{
559    char compressed[BUFF_SIZE];
560    char decompressed[BUFF_SIZE];
561
562    char *cp = decompressed;
563
564    writeint(snap->datasize, &cp);
565    writeint(snap->numitems, &cp);
566
567    for (int i = 0; i < snap->numitems; i++)
568        writeint(snap->offsets[i], &cp);
569
570    for (int i = 0; i < snap->numitems; i++)
571    {
572        unsigned int key = (snap->items[i].type << 16) | snap->items[i].id;
573        writeint((int)key, &cp);
574
575        for (int y = 0; y < snap->items[i].numdata; y++)
576            writeint(snap->items[i].data[y], &cp);
577    }
578    int size = cp - decompressed;
579
580    int datasize = compresshuff(decompressed, size, compressed, BUFF_SIZE);
581
582    writedemochunkheader(fp, DEMOSNAP, datasize);
583    fwrite(compressed, 1, datasize, fp);
584
585    return 1;
586}
587
588int writedemomessage(FILE *fp, demomessage *message)
589{
590    writedemochunkheader(fp, DEMOMESSAGE, message->datasize);
591    fwrite(message->data, 1, message->datasize, fp);
592
593    return 1;
594}
595
596int writedemodelta(FILE *fp, demodelta *delta)
597{
598    char compressed[BUFF_SIZE];
599    char decompressed[BUFF_SIZE];
600
601    char *cp = decompressed;
602
603    writeint(delta->numremoveditems, &cp);
604    writeint(delta->numitemdeltas, &cp);
605    writeint(0, &cp);
606
607    for (int i = 0; i < delta->numremoveditems; i++)
608        writeint(delta->removeditemkeys[i], &cp);
609
610    for (int i = 0; i < delta->numitemdeltas; i++)
611    {
612        demodeltaitem *item = &delta->itemdeltas[i];
613        writeint(item->type, &cp);
614        writeint(item->id, &cp);
615
616        // TODO: 1 <= type <= 20 is 0.6 protocol spesific
617        if (!(item->type >= 1 && item->type <= 20))
618            writeint(item->size, &cp);
619
620        for (int i = 0; i < item->size; i++)
621            writeint(item->data[i], &cp);
622    }
623
624    int size = cp - decompressed;
625
626    int datasize = compresshuff(decompressed, size, compressed, BUFF_SIZE);
627
628    writedemochunkheader(fp, DEMODELTA, datasize);
629    fwrite(compressed, 1, datasize, fp);
630
631    return 1;
632}
633
634int writedemo(FILE *fp, demo *demo)
635{
636    if (writedemoheader(fp, &demo->header) <= 0)
637        return -1;
638
639    if (writedemotimeline(fp, &demo->timeline) <= 0)
640        return -2;
641
642    if (writedemomap(fp, &demo->map, demo->header.mapsize, demo->header.version) <= 0)
643        return -3;
644
645    for (int i = 0; i < demo->data.numchunks; i++)
646    {
647        demochunk *chunk = &demo->data.chunks[i];
648        switch (chunk->type)
649        {
650        case DEMOTICK:
651            writedemotick(fp, chunk->data.tick, demo->header.version);
652            break;
653        case DEMOSNAP:
654            writedemosnap(fp, chunk->data.snap);
655            break;
656        case DEMOMESSAGE:
657            writedemomessage(fp, chunk->data.message);
658            break;
659        case DEMODELTA:
660            writedemodelta(fp, chunk->data.delta);
661            break;
662        default:
663            printf("UNKNOWN CHUNK\n");
664            break;
665        }
666    }
667
668    return 1;
669}
670
671/* printers */
672
673void printdemoheader(demoheader *header)
674{
675    if (header->version == 6)
676        printf("version:    v6ddnet\n");
677    else
678        printf("version:    v%d\n", header->version);
679
680    printf("netversion: %s\n", header->netversion);
681    printf("mapname:    %s\n", header->mapname);
682    printf("mapsize:    %d\n", header->mapsize);
683    printf("mapcrc:     %d\n", header->mapcrc);
684    printf("type:       %s\n", header->type);
685    printf("length:     %d\n", header->length);
686    printf("timestamp:  %s\n", header->timestamp);
687}
688
689void printdemotick(demotick *tick)
690{
691    printf("TICK={keyframe: %s, innline: %s, delta: %d}\n", tick->keyframe ? "true" : "false",
692           tick->innline ? "true" : "false", tick->delta);
693}
694
695void printdemosnap(demosnap *snap)
696{
697    printf("SNAPSHOT={datasize: %d, numitems: %d,\n  offsets: [ ", snap->datasize, snap->numitems);
698    for (int i = 0; i < snap->numitems; i++)
699        printf("%d%s ", snap->offsets[i], (i != snap->numitems - 1) ? "," : "");
700
701    printf("],\n  items: [\n");
702    for (int i = 0; i < snap->numitems; i++)
703    {
704        printf("    (type: %d, id: %d) {", snap->items[i].type, snap->items[i].id);
705        for (int y = 0; y < snap->items[i].numdata; y++)
706            printf("%x%s", snap->items[i].data[y], (y != snap->items[i].numdata - 1) ? "," : "");
707        printf("}\n");
708    }
709    printf("]}\n");
710}
711
712void printdemomessage(demomessage *message)
713{
714    printf("MESSAGE={datasize: %d}\n", message->datasize);
715}
716
717void printdemodelta(demodelta *delta)
718{
719    printf("DELTA={numremoveditems: %d, numitemdeltas: %d\n  removeditems: [ ", delta->numremoveditems,
720           delta->numitemdeltas);
721
722    for (int i = 0; i < delta->numremoveditems; i++)
723    {
724        short type = (delta->removeditemkeys[i] >> 16) & 0xffff;
725        short id = (delta->removeditemkeys[i] & 0xffff);
726        printf("(type: %d, id: %d)%s ", type, id, (i != delta->numremoveditems - 1) ? "," : "");
727    }
728
729    printf("],\n  itemdeltas: [\n");
730    for (int i = 0; i < delta->numitemdeltas; i++)
731    {
732        printf("    (type: %d, id: %d) {", delta->itemdeltas[i].type, delta->itemdeltas[i].id);
733        for (int y = 0; y < delta->itemdeltas[i].size; y++)
734            printf("%x%s", delta->itemdeltas[i].data[y], (y != delta->itemdeltas[i].size - 1) ? "," : "");
735        printf("}\n");
736    }
737    printf("]}\n");
738}
739
740void printdemo(demo *demo, char printchunks)
741{
742    printdemoheader(&demo->header);
743    printf("\n");
744
745    if (printchunks)
746        printf("CHUNKS:\n");
747
748    int typecount[4] = {0, 0, 0, 0};
749    for (int i = 0; i < demo->data.numchunks; i++)
750    {
751        demochunk *chunk = &demo->data.chunks[i];
752        switch (chunk->type)
753        {
754        case DEMOTICK:
755            if (printchunks)
756                printdemotick(chunk->data.tick);
757            typecount[(int)DEMOTICK]++;
758            break;
759        case DEMOSNAP:
760            if (printchunks)
761                printdemosnap(chunk->data.snap);
762            typecount[(int)DEMOSNAP]++;
763            break;
764        case DEMOMESSAGE:
765            if (printchunks)
766                printdemomessage(chunk->data.message);
767            typecount[(int)DEMOMESSAGE]++;
768            break;
769        case DEMODELTA:
770            if (printchunks)
771                printdemodelta(chunk->data.delta);
772            typecount[(int)DEMODELTA]++;
773            break;
774        default:
775            printf("UNKNOWN CHUNK\n");
776            break;
777        }
778    }
779    if (printchunks)
780        printf("\n");
781
782    printf("chunk count: %d\n", demo->data.numchunks);
783    printf("chunk counts: [\n");
784    printf("  ticks: %d\n", typecount[0]);
785    printf("  snaps: %d\n", typecount[1]);
786    printf("  messages: %d\n", typecount[2]);
787    printf("  deltas: %d\n", typecount[3]);
788    printf("]\n");
789}