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}