dedit
a tool for Teeworlds demo file shenanigens
git clone https://jhhm.no/repos/dedit.git
dedit/src/snap.c
get raw file: snap.c
1/* This file is part of dedit - a tool for editing Teeworlds/DDNet demo files 2 Copyright (C) 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 "snap.h" 20#include "demo.h" 21 22#include <stdlib.h> 23#include <string.h> 24 25void snapinit(demosnap *snap) 26{ 27 snap->datasize = 0; 28 snap->numitems = 0; 29 snap->offsets = NULL; 30 snap->items = NULL; 31} 32 33void snapfree(demosnap *snap) 34{ 35 for (int i = 0; i < snap->numitems; i++) 36 free(snap->items[i].data); 37 free(snap->offsets); 38 free(snap->items); 39 snapinit(snap); 40} 41 42/* Sets item to a new item with type and id, copying numdata ints from data */ 43/* If data is NULL the item data is zeroed */ 44static int setitem(demosnapitem *item, int type, int id, int numdata, const int *data) 45{ 46 item->type = type; 47 item->id = id; 48 item->numdata = numdata; 49 item->data = (int *)calloc(numdata > 0 ? numdata : 1, sizeof(int)); 50 if (item->data == NULL) 51 return -1; 52 53 if (data != NULL && numdata > 0) 54 memcpy(item->data, data, numdata * sizeof(int)); 55 56 return 1; 57} 58 59int snapcopy(demosnap *dst, const demosnap *src) 60{ 61 snapinit(dst); 62 if (src->numitems == 0) 63 return 1; 64 65 dst->items = (demosnapitem *)malloc(src->numitems * sizeof(demosnapitem)); 66 if (dst->items == NULL) 67 return -1; 68 69 for (int i = 0; i < src->numitems; i++) 70 { 71 const demosnapitem *item = &src->items[i]; 72 if (setitem(&dst->items[i], item->type, item->id, item->numdata, item->data) < 0) 73 { 74 snapfree(dst); 75 return -1; 76 } 77 dst->numitems++; 78 } 79 80 if (snapupdateoffsets(dst) < 0) 81 { 82 snapfree(dst); 83 return -1; 84 } 85 86 return 1; 87} 88 89int snapfinditem(const demosnap *snap, int type, int id) 90{ 91 for (int i = 0; i < snap->numitems; i++) 92 { 93 if (snap->items[i].type == type && snap->items[i].id == id) 94 return i; 95 } 96 return -1; 97} 98 99int snapadditem(demosnap *snap, int type, int id, int numdata, const int *data) 100{ 101 demosnapitem *items = (demosnapitem *)realloc(snap->items, (snap->numitems + 1) * sizeof(demosnapitem)); 102 if (items == NULL) 103 return -1; 104 snap->items = items; 105 106 if (setitem(&snap->items[snap->numitems], type, id, numdata, data) < 0) 107 return -1; 108 snap->numitems++; 109 110 return 1; 111} 112 113int snapupdateoffsets(demosnap *snap) 114{ 115 free(snap->offsets); 116 snap->offsets = NULL; 117 snap->datasize = 0; 118 119 if (snap->numitems == 0) 120 return 1; 121 122 snap->offsets = (int *)malloc(snap->numitems * sizeof(int)); 123 if (snap->offsets == NULL) 124 return -1; 125 126 for (int i = 0; i < snap->numitems; i++) 127 { 128 snap->offsets[i] = snap->datasize; 129 snap->datasize += (1 + snap->items[i].numdata) * sizeof(int); 130 } 131 132 return 1; 133} 134 135int snapsize(const demosnap *snap) 136{ 137 return (2 + snap->numitems) * sizeof(int) + snap->datasize; 138} 139 140/* 141 Function is derived from DDNet code (DDNet License). 142 See NOTICES file for full license details. 143 144 https://github.com/ddnet/ddnet/blob/master/src/engine/shared/snapshot.cpp (CSnapshotDelta::UnpackDelta) 145*/ 146int snapapplydelta(const demosnap *from, const demodelta *delta, demosnap *to) 147{ 148 int maxitems = from->numitems + delta->numitemdeltas; 149 150 snapinit(to); 151 to->items = (demosnapitem *)malloc((maxitems > 0 ? maxitems : 1) * sizeof(demosnapitem)); 152 if (to->items == NULL) 153 return -1; 154 155 // copy all items that are not removed 156 for (int i = 0; i < from->numitems; i++) 157 { 158 const demosnapitem *item = &from->items[i]; 159 int key = SNAP_KEY(item->type, item->id); 160 char keep = 1; 161 162 for (int y = 0; y < delta->numremoveditems; y++) 163 { 164 if (delta->removeditemkeys[y] == key) 165 { 166 keep = 0; 167 break; 168 } 169 } 170 171 if (!keep) 172 continue; 173 174 if (setitem(&to->items[to->numitems], item->type, item->id, item->numdata, item->data) < 0) 175 { 176 snapfree(to); 177 return -1; 178 } 179 to->numitems++; 180 } 181 182 // apply updated items 183 for (int i = 0; i < delta->numitemdeltas; i++) 184 { 185 const demodeltaitem *ditem = &delta->itemdeltas[i]; 186 int index = snapfinditem(to, ditem->type, ditem->id); 187 188 if (index == -1) 189 { 190 index = to->numitems; 191 if (setitem(&to->items[index], ditem->type, ditem->id, ditem->size, NULL) < 0) 192 { 193 snapfree(to); 194 return -1; 195 } 196 to->numitems++; 197 } 198 else if (to->items[index].numdata != ditem->size) 199 { 200 snapfree(to); 201 return -2; 202 } 203 204 int *data = to->items[index].data; 205 int fromindex = snapfinditem(from, ditem->type, ditem->id); 206 207 if (fromindex != -1) 208 { 209 const demosnapitem *fromitem = &from->items[fromindex]; 210 if (fromitem->numdata != ditem->size) 211 { 212 snapfree(to); 213 return -3; 214 } 215 216 // wrapping adition by casting to unsigned 217 for (int y = 0; y < ditem->size; y++) 218 data[y] = (int)((unsigned int)fromitem->data[y] + (unsigned int)ditem->data[y]); 219 } 220 else if (ditem->size > 0) 221 { 222 memcpy(data, ditem->data, ditem->size * sizeof(int)); 223 } 224 } 225 226 if (snapupdateoffsets(to) < 0) 227 { 228 snapfree(to); 229 return -1; 230 } 231 232 return 1; 233} 234 235/* 236 Function is derived from DDNet code (DDNet License). 237 See NOTICES file for full license details. 238 239 https://github.com/ddnet/ddnet/blob/master/src/engine/shared/snapshot.cpp (CSnapshotDelta::CreateDelta) 240*/ 241int snapcreatedelta(const demosnap *from, const demosnap *to, demodelta *delta) 242{ 243 delta->numremoveditems = 0; 244 delta->numitemdeltas = 0; 245 delta->removeditemkeys = (int *)malloc((from->numitems > 0 ? from->numitems : 1) * sizeof(int)); 246 delta->itemdeltas = (demodeltaitem *)malloc((to->numitems > 0 ? to->numitems : 1) * sizeof(demodeltaitem)); 247 248 if (delta->removeditemkeys == NULL || delta->itemdeltas == NULL) 249 { 250 deltafree(delta); 251 return -1; 252 } 253 254 // removed items 255 for (int i = 0; i < from->numitems; i++) 256 { 257 const demosnapitem *item = &from->items[i]; 258 if (snapfinditem(to, item->type, item->id) == -1) 259 delta->removeditemkeys[delta->numremoveditems++] = SNAP_KEY(item->type, item->id); 260 } 261 262 // new and changed items 263 for (int i = 0; i < to->numitems; i++) 264 { 265 const demosnapitem *item = &to->items[i]; 266 demodeltaitem *ditem = &delta->itemdeltas[delta->numitemdeltas]; 267 int fromindex = snapfinditem(from, item->type, item->id); 268 269 if (fromindex != -1 && from->items[fromindex].numdata != item->numdata) 270 { 271 deltafree(delta); 272 return -2; 273 } 274 275 ditem->type = item->type; 276 ditem->id = item->id; 277 ditem->size = item->numdata; 278 ditem->data = (int *)malloc((item->numdata > 0 ? item->numdata : 1) * sizeof(int)); 279 if (ditem->data == NULL) 280 { 281 deltafree(delta); 282 return -1; 283 } 284 285 if (fromindex != -1) 286 { 287 const demosnapitem *fromitem = &from->items[fromindex]; 288 int needed = 0; 289 290 // wrapping subtraction by casting to unsigned 291 for (int y = 0; y < item->numdata; y++) 292 { 293 ditem->data[y] = (int)((unsigned int)item->data[y] - (unsigned int)fromitem->data[y]); 294 needed |= ditem->data[y]; 295 } 296 297 if (!needed) 298 { 299 free(ditem->data); 300 continue; 301 } 302 } 303 else if (item->numdata > 0) 304 { 305 memcpy(ditem->data, item->data, item->numdata * sizeof(int)); 306 } 307 delta->numitemdeltas++; 308 } 309 310 return (delta->numremoveditems > 0 || delta->numitemdeltas > 0) ? 1 : 0; 311} 312 313void deltafree(demodelta *delta) 314{ 315 for (int i = 0; i < delta->numitemdeltas; i++) 316 free(delta->itemdeltas[i].data); 317 free(delta->itemdeltas); 318 free(delta->removeditemkeys); 319 320 delta->numremoveditems = 0; 321 delta->numitemdeltas = 0; 322 delta->removeditemkeys = NULL; 323 delta->itemdeltas = NULL; 324} 325 326/* Returns the tick after tick marker t, given the previous tick */ 327static int nexttick(int tick, const demotick *t) 328{ 329 if (t->innline) 330 return tick + t->delta; 331 return t->delta; 332} 333 334void demostateinit(demostate *state, demo *demo) 335{ 336 int tick = -1; 337 338 state->demo = demo; 339 state->chunkidx = 0; 340 state->firstchunk = 0; 341 state->tick = -1; 342 state->firsttick = -1; 343 state->lasttick = -1; 344 state->hassnap = 0; 345 snapinit(&state->snap); 346 347 for (int i = 0; i < demo->data.numchunks; i++) 348 { 349 demochunk *chunk = &demo->data.chunks[i]; 350 if (chunk->type != DEMOTICK) 351 continue; 352 353 tick = nexttick(tick, chunk->data.tick); 354 if (state->firsttick == -1) 355 state->firsttick = tick; 356 state->lasttick = tick; 357 } 358} 359 360int demostatepeektick(const demostate *state) 361{ 362 demodata *data = &state->demo->data; 363 364 for (int i = state->chunkidx; i < data->numchunks; i++) 365 { 366 if (data->chunks[i].type == DEMOTICK) 367 return nexttick(state->tick, data->chunks[i].data.tick); 368 } 369 return -1; 370} 371 372/* 373 Function is derived from DDNet code (DDNet License). 374 See NOTICES file for full license details. 375 376 https://github.com/ddnet/ddnet/blob/master/src/engine/shared/demo.cpp (CDemoPlayer::DoTick) 377*/ 378int demostatenext(demostate *state) 379{ 380 demodata *data = &state->demo->data; 381 char seentick = 0; 382 demosnap snap; 383 384 state->firstchunk = state->chunkidx; 385 386 for (; state->chunkidx < data->numchunks; state->chunkidx++) 387 { 388 demochunk *chunk = &data->chunks[state->chunkidx]; 389 switch (chunk->type) 390 { 391 case DEMOTICK: 392 if (seentick) 393 return 1; 394 seentick = 1; 395 state->tick = nexttick(state->tick, chunk->data.tick); 396 break; 397 case DEMOSNAP: 398 if (snapcopy(&snap, chunk->data.snap) < 0) 399 return -1; 400 snapfree(&state->snap); 401 state->snap = snap; 402 state->hassnap = 1; 403 break; 404 case DEMODELTA: 405 if (!state->hassnap) 406 return -2; 407 if (snapapplydelta(&state->snap, chunk->data.delta, &snap) < 0) 408 return -3; 409 snapfree(&state->snap); 410 state->snap = snap; 411 break; 412 default: 413 break; 414 } 415 } 416 417 return seentick; 418} 419 420void demostatefree(demostate *state) 421{ 422 snapfree(&state->snap); 423 state->hassnap = 0; 424}