JHHM

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}