?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d2/tfile.h: Call ungetc() when test for non-primary transformation command fails.
[Ale.git] / d2 / tfile.h
blob77826d3e078891b5b83e84cec719ca6e924bc8fb
1 // Copyright 2002, 2003 David Hilvert <dhilvert@auricle.dyndns.org>,
2 // <dhilvert@ugcs.caltech.edu>
3
4 /* This file is part of the Anti-Lamenessing Engine.
5
6 The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with the Anti-Lamenessing Engine; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /*
22 * tfile.h: Read and write transformation data files.
23 */
24
25 /*
26 * This version of ALE reads transformation data file versions 0, 1, 2, and 3,
27 * and writes version 2 and 3 transformation data files. Data file versions 1
28 * and higher are identified by a version command "V x", where x is the version
29 * number, prior to any transformation command. Data file version 0 is
30 * identified by having no version command.
31 */
32
33 #ifndef __tfile_h__
34 #define __tfile_h__
35
36 #include "transformation.h"
37
38 #define TFILE_VERSION 3
39 #define TFILE_VERSION_MAX 3
40
41 extern int tfile_input_version;
42 extern int tfile_output_version;
43
44 /*
45 * Structure to describe a transformation data file to load data from.
46 */
47
48 struct tload_t {
49 const char *filename;
50 FILE *file;
51 };
52
53 /*
54 * Structure to describe a transformation data file to write data to.
55 */
56
57 struct tsave_t {
58 const char *filename;
59 const char *target;
60 const char *orig;
61 pixel orig_apm;
62 FILE *file;
63 };
64
65 /*
66 * Create a new tload_t transformation data file structure, used for
67 * reading data from transformation data files.
68 */
69
70 static inline struct tload_t *tload_new(const char *filename) {
71 FILE *file = fopen (filename, "r");
72 struct tload_t *result = NULL;
73
74 if (!file) {
75 fprintf(stderr, "tload: Error: could not open transformation data file '%s'.", filename);
76 exit(1);
77 }
78
79 result = (struct tload_t *)
80 malloc(sizeof(struct tload_t));
81 result->filename = filename;
82 result->file = file;
83
84 return result;
85 }
86
87 /*
88 * Load the first transformation from a transformation data file associated with
89 * transformation data file structure T, or return the default transformation
90 * if no transformation is available.
91 *
92 * T is a pointer to the tload_t transformation data file structure.
93 *
94 * IS_P is nonzero if a projective transformation is expected.
95 *
96 * DEFAULT_TRANSFORM is the default transformation result.
97 *
98 * IS_DEFAULT is used to signal a non-default transformation result.
99 */
100
101 static inline transformation tload_first(struct tload_t *t, int is_p,
102 transformation default_transform, int *is_default) {
103
104 transformation result = default_transform;
105
106 *is_default = 1;
107
108 /*
109 * If there is no file, return the default.
110 */
111
112 if (t == NULL)
113 return result;
114
115 /*
116 * Search through the initial part of the file to determine
117 * its version.
118 */
119
120 /*
121 * Skip comments
122 */
123
124 int first_character;
125
126 first_character = fgetc(t->file);
127
128 while (first_character == ' '
129 || first_character == 0xa
130 || first_character == 0xd
131 || first_character == '\t'
132 || first_character == '#') {
133 ungetc(first_character, t->file);
134 char line[1024];
135 fgets(line, 1024, t->file);
136 if (strlen(line) >= 1023) {
137 fprintf(stderr,
138 "\ntrans-load: Error: line too long in input file\n");
139 exit(1);
140 }
141
142 first_character = fgetc(t->file);
143 }
144
145 if (first_character != EOF)
146 ungetc(first_character, t->file);
147
148 /*
149 * Check for version 0
150 */
151
152 if (first_character != 'V')
153
154 /*
155 * Must be version 0.
156 */
157
158 return result;
159
160 /*
161 * Obtain version from version command string.
162 */
163
164 char line[1024];
165 fgets(line, 1024, t->file);
166 if (strlen(line) >= 1023) {
167 fprintf(stderr,
168 "\ntrans-load: Error: line too long in input file\n");
169 exit(1);
170 }
171
172 int count = sscanf(line, "V %d", &tfile_input_version);
173
174 if (count < 1) {
175 fprintf(stderr, "Error in transformation "
176 "file version command.\n");
177 exit(1);
178 } else if (tfile_input_version > TFILE_VERSION_MAX) {
179 fprintf(stderr, "Unsupported transformation "
180 "file version %d\n",
181 tfile_input_version);
182 exit(1);
183 }
184
185 /*
186 * Handle versions lower than 3.
187 */
188
189 if (tfile_input_version < 3)
190
191 /*
192 * Versions lower than 3 use the default transformation
193 * for the original frame.
194 */
195
196 return result;
197
198 /*
199 * Read each line of the file until we find a transformation
200 * or EOF.
201 */
202
203 while (!feof(t->file)) {
204 char line[1024];
205
206 fgets(line, 1024, t->file);
207
208 if (feof(t->file))
209 return result;
210
211 if (strlen(line) >= 1023) {
212 fprintf(stderr,
213 "\ntrans-load: Error: line too long in input file\n");
214 exit(1);
215 }
216
217 switch (line[0]) {
218 case ' ':
219 case 0xa:
220 case 0xd:
221 case '\t':
222 case '#':
223 /* Comment or whitespace */
224 break;
225 case 'D':
226 case 'd':
227 /* Default transformation */
228 return result;
229 case 'B':
230 case 'b':
231 if (tfile_input_version < 3) {
232 fprintf(stderr, "\ntrans-load: Error: "
233 "Barrel distortion not supported "
234 "for version %d input files.\n"
235 "trans-load: Hint: Use version 3 "
236 "file syntax.\n", tfile_input_version);
237 exit(1);
238 } else {
239 unsigned int count;
240 unsigned int pos = 0, chars;
241 unsigned int bdc;
242 double dparameters[BARREL_DEGREE];
243 ale_pos parameters[BARREL_DEGREE];
244
245 count = sscanf(line, "B %u%n", &bdc, &chars);
246 pos += chars;
247
248 if (count < 1) {
249 fprintf(stderr, "\ntrans-load: Error: "
250 "Malformed 'B' command.\n");
251 exit(1);
252 }
253
254 if (bdc > result.bd_max()) {
255 fprintf(stderr, "\ntrans-load: Error: "
256 "Barrel distortion degree %d "
257 "is too large. (Maximum is %d.)\n"
258 "trans-load: Hint: "
259 "Reduce degree or re-compile "
260 "with BD_DEGREE=%d\n", bdc, BARREL_DEGREE, bdc);
261 exit(1);
262 }
263
264 for (unsigned int d = 0; d < bdc; d++) {
265 count = sscanf(line + pos, "%lf%n", &dparameters[d], &chars);
266 pos += chars;
267
268 if (count < 1) {
269 fprintf(stderr, "\ntrans-load: Error: "
270 "Malformed 'B' command.\n");
271 exit(1);
272 }
273
274 parameters[d] = dparameters[d];
275 }
276
277 result.bd_set(bdc, parameters);
278 }
279 break;
280 case 'P':
281 case 'p':
282 /* Projective transformation data */
283 *is_default = 0;
284 if (is_p == 0) {
285 fprintf(stderr, "\ntrans-load: Error: "
286 "Projective data for euclidean "
287 "transformation.\n"
288 "trans-load: Hint: "
289 "Use command-line option --projective.\n");
290 exit(1);
291 } else {
292 double width, height, values[8];
293 int count, i;
294 point x[4];
295
296 count = sscanf(line, "P %lf%lf%lf%lf%lf%lf%lf%lf%lf%lf", &width, &height,
297 &values[0], &values[1], &values[2], &values[3],
298 &values[4], &values[5], &values[6], &values[7]);
299
300 int index = 0;
301 for (int i = 0; i < 4; i++)
302 for (int j = 1; j >= 0; j--)
303 x[i][j] = values[index++];
304
305 if (count < 10)
306 fprintf(stderr, "\ntrans-load: warning:"
307 "Missing args for 'P'\n");
308
309 for (i = 0; i < count - 2; i++) {
310 ale_pos factor = (i % 2)
311 ? (result.scaled_width() / width)
312 : (result.scaled_height() / height);
313
314 x[i / 2][i % 2] *= factor;
315 }
316
317 result.gpt_set(x);
318
319 return result;
320 }
321 break;
322 case 'E':
323 case 'e':
324 /* Euclidean transformation data */
325 *is_default = 0;
326 {
327 double width, height;
328 double values[3] = {0, 0, 0};
329 int count, i;
330 ale_pos eu[3];
331
332 count = sscanf(line, "E %lf%lf%lf%lf%lf",
333 &width, &height,
334 &values[0], &values[1], &values[2]);
335
336 eu[1] = values[0];
337 eu[0] = values[1];
338 eu[2] = values[2];
339
340 if (count < 5)
341 fprintf(stderr, "\ntrans-load: warning:"
342 "Missing args for 'E'\n");
343
344 for (i = 0; (i < count - 2) && (i < 2); i++) {
345 ale_pos factor = (i % 2)
346 ? (result.scaled_width() / width)
347 : (result.scaled_height() / height);
348
349 eu[i] *= factor;
350 }
351
352 result.eu_set(eu);
353
354 return result;
355 }
356 break;
357 default:
358 fprintf(stderr,
359 "\ntrans-load: Error in tload_first: unrecognized command '%s'\n",
360 line);
361 exit(1);
362 }
363 }
364
365 /*
366 * EOF reached: return default transformation.
367 */
368
369 return result;
370 }
371
372 /*
373 * Load the next transformation from a transformation data file associated with
374 * transformation data file structure T, or return the default transformation
375 * if no transformation is available.
376 *
377 * T is a pointer to the tload_t transformation data file structure.
378 *
379 * IS_P is nonzero if a projective transformation is expected.
380 *
381 * DEFAULT_TRANSFORM is the default transformation result.
382 *
383 * IS_DEFAULT is used to signal a non-default transformation result.
384 *
385 * IS_PRIMARY is used to differentiate primary and non-primary
386 * transformations
387 */
388
389 static inline transformation tload_next(struct tload_t *t, int is_p,
390 transformation default_transform, int *is_default,
391 int is_primary) {
392
393 transformation result = default_transform;
394
395 *is_default = 1;
396
397 /*
398 * Read each line of the file until we find a transformation.
399 */
400
401 while (t && !feof(t->file)) {
402
403 char c = fgetc(t->file);
404 if (!feof(t->file) && c != EOF)
405 ungetc(c, t->file);
406
407 if (feof(t->file)
408 || (!is_primary
409 && c != EOF
410 && c != 'F'
411 && c != 'f'
412 && c != 'Q'
413 && c != 'q')) {
414 return result;
415 }
416
417 char line[1024];
418
419 fgets(line, 1024, t->file);
420
421 if (feof(t->file))
422 return result;
423
424 if (strlen(line) >= 1023) {
425 fprintf(stderr,
426 "\ntrans-load: warning: line too long in input file\n");
427 }
428
429 switch (line[0]) {
430 case ' ':
431 case 0xa:
432 case 0xd:
433 case '\t':
434 case '#':
435 /* Comment or whitespace */
436 break;
437 case 'D':
438 case 'd':
439 /* Default transformation */
440 return result;
441 case 'B':
442 case 'b':
443 if (tfile_input_version < 3) {
444 fprintf(stderr, "\ntrans-load: Error: "
445 "Barrel distortion not supported "
446 "for version %d input files.\n"
447 "trans-load: Hint: Use version 3 "
448 "file syntax.\n", tfile_input_version);
449 exit(1);
450 } else {
451 unsigned int count;
452 unsigned int pos = 0, chars;
453 unsigned int bdc;
454 ale_pos parameters[BARREL_DEGREE];
455 double dparameters[BARREL_DEGREE];
456
457 count = sscanf(line, "B %u%n", &bdc, &chars);
458 pos += chars;
459
460 if (count < 1) {
461 fprintf(stderr, "\ntrans-load: Error: "
462 "Malformed 'B' command.\n");
463 exit(1);
464 }
465
466 if (bdc > result.bd_max()) {
467 fprintf(stderr, "\ntrans-load: Error: "
468 "Barrel distortion degree %d "
469 "is too large. (Maximum is %d.)\n"
470 "trans-load: Hint: "
471 "Reduce degree or re-compile "
472 "with BD_DEGREE=%d\n", bdc, BARREL_DEGREE, bdc);
473 exit(1);
474 }
475
476 for (unsigned int d = 0; d < bdc; d++) {
477 count = sscanf(line + pos, "%lf%n", &dparameters[d], &chars);
478 pos += chars;
479
480 if (count < 1) {
481 fprintf(stderr, "\ntrans-load: Error: "
482 "Malformed 'B' command.\n");
483 exit(1);
484 }
485
486 parameters[d] = dparameters[d];
487 }
488
489 result.bd_set(bdc, parameters);
490 }
491 break;
492 case 'Q':
493 case 'q':
494 if (is_primary)
495 break;
496 case 'P':
497 case 'p':
498 /* Projective transformation data */
499 *is_default = 0;
500 if (is_p == 0) {
501 fprintf(stderr, "\ntrans-load: Error: "
502 "Projective data for euclidean "
503 "transformation.\n"
504 "trans-load: Hint: "
505 "Use command-line option --projective.\n");
506 exit(1);
507 } else {
508 double width, height, values[8];
509 int count, i;
510 point x[4];
511
512 count = sscanf(line, "P %lf%lf%lf%lf%lf%lf%lf%lf%lf%lf", &width, &height,
513 &values[0], &values[1], &values[2], &values[3],
514 &values[4], &values[5], &values[6], &values[7]);
515
516 int index = 0;
517 for (int i = 0; i < 4; i++)
518 for (int j = 1; j >= 0; j--)
519 x[i][j] = values[index++];
520
521 if (count < 10)
522 fprintf(stderr, "\ntrans-load: warning:"
523 "Missing args for 'P'\n");
524
525 for (i = 0; i < count - 2; i++) {
526 ale_pos factor = (i % 2)
527 ? (result.scaled_width() / width)
528 : (result.scaled_height() / height);
529
530 x[i / 2][i % 2] *= factor;
531 }
532
533 if (tfile_input_version < 1) {
534 /*
535 * Accommodate older versions
536 * of tfile.
537 */
538 for (i = 0; i < 4; i++) {
539 ale_pos y = x[i][0];
540 x[i][0] = x[i][1];
541 x[i][1] = y;
542 }
543 result.gpt_v0_set(x);
544 } else {
545 result.gpt_set(x);
546 }
547
548 return result;
549 }
550 break;
551 case 'F':
552 case 'f':
553 if (is_primary)
554 break;
555 case 'E':
556 case 'e':
557 /* Euclidean transformation data */
558 *is_default = 0;
559 {
560 double width, height;
561 double values[3] = {0, 0, 0};
562 int count, i;
563 ale_pos eu[3];
564
565 count = sscanf(line, "E %lf%lf%lf%lf%lf",
566 &width, &height,
567 &values[0], &values[1], &values[2]);
568
569 eu[1] = values[0];
570 eu[0] = values[1];
571 eu[2] = values[2];
572
573 if (tfile_input_version < 2) {
574 ale_pos t = eu[0];
575 eu[0] = eu[1];
576 eu[1] = t;
577 }
578
579
580 if (count < 5)
581 fprintf(stderr, "\ntrans-load: warning:"
582 "Missing args for 'E'\n");
583
584 for (i = 0; (i < count - 2) && (i < 2); i++) {
585 ale_pos factor = (i % 2)
586 ? (result.scaled_width() / width)
587 : (result.scaled_height() / height);
588
589 eu[i] *= factor;
590 }
591
592 if (tfile_input_version < 1) {
593 result.eu_v0_set(eu);
594 } else {
595 result.eu_set(eu);
596 }
597
598 return result;
599 }
600 break;
601 default:
602 fprintf(stderr,
603 "\ntrans-load: Error in tload_next: unrecognized command '%s'\n",
604 line);
605 exit(1);
606 }
607 }
608
609 return result;
610 }
611
612 /*
613 * Create a new tsave_t transformation data file structure, used for
614 * writing data to transformation data files.
615 */
616
617 static inline struct tsave_t *tsave_new(const char *filename) {
618 FILE *file = fopen (filename, "w");
619 struct tsave_t *result = NULL;
620
621 if (!file) {
622 fprintf(stderr, "tsave: Error: could not open transformation data file '%s'.", filename);
623 exit(1);
624 }
625
626 result = (struct tsave_t *)
627 malloc(sizeof(struct tsave_t));
628 result->filename = filename;
629 result->file = file;
630 result->orig = "unknown";
631 result->target = "unknown";
632
633 fprintf(file, "# created by ALE transformation file handler version %d\n",
634 TFILE_VERSION);
635
636 fclose(file);
637
638 return result;
639 }
640
641 /*
642 * Save the first transformation to a transformation data file associated with
643 * transformation data file structure T, or do nothing if T is NULL. This
644 * function also establishes the output file version.
645 *
646 * OFFSET is the transformation to be saved.
647 *
648 * IS_PROJECTIVE indicates whether to write a projective transformation.
649 *
650 */
651
652 static inline void tsave_first(struct tsave_t *t, transformation offset, int is_projective) {
653
654 if (t == NULL)
655 return;
656
657 t->file = fopen(t->filename, "a");
658
659 /*
660 * Determine the output version to use. We use version 3 output syntax only when
661 * necessary. This comprises two cases:
662 *
663 * (i) an input file is used, and this file uses version 3 syntax.
664 * (ii) non-degenerate barrel distortion correction is selected.
665 *
666 * (i) can be directly examined. When (i) does not hold, (ii) can be
667 * inferred from offset.bd_count(), since this value should be constant
668 * when (i) does not hold. XXX: This logic should be reviewed.
669 */
670
671 if (tfile_input_version == 3 || offset.bd_count() > 0)
672 tfile_output_version = 3;
673 else
674 tfile_output_version = 2;
675
676
677 fprintf(t->file, "# producing transformation file syntax version %d\n", tfile_output_version);
678 fprintf(t->file, "V %d\n", tfile_output_version);
679
680 fprintf(t->file, "# Comment: Target output file is %s\n", t->target);
681 fprintf(t->file, "# Comment: Original frame is %s\n", t->orig);
682 fprintf(t->file, "# Comment: Avg magnitude [r=%f g=%f b=%f]\n", t->orig_apm[0], t->orig_apm[1], t->orig_apm[2]);
683
684 if (tfile_output_version < 3) {
685 fclose(t->file);
686 return;
687 }
688
689 if (offset.bd_count() > 0) {
690 assert (tfile_output_version >= 3);
691 unsigned int i;
692
693 fprintf(t->file, "B ");
694 fprintf(t->file, "%u ", offset.bd_count());
695 for (i = 0; i < offset.bd_count(); i++)
696 fprintf(t->file, "%f ", (double) offset.bd_get(i));
697 fprintf(t->file, "\n");
698 }
699
700
701 if (is_projective) {
702 int i, j;
703
704 fprintf(t->file, "P ");
705 fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
706 for (i = 0; i < 4; i++)
707 for (j = 1; j >= 0; j--)
708 fprintf(t->file, "%f ", (double) offset.gpt_get(i, j));
709 } else {
710 fprintf(t->file, "E ");
711 fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
712 fprintf(t->file, "%f ", (double) offset.eu_get(1));
713 fprintf(t->file, "%f ", (double) offset.eu_get(0));
714 fprintf(t->file, "%f ", (double) offset.eu_get(2));
715 }
716
717 fprintf(t->file, "\n");
718
719 fclose(t->file);
720 }
721
722 /*
723 * Save the next transformation to a transformation data file associated with
724 * transformation data file structure T, or do nothing if T is NULL.
725 *
726 * OFFSET is the transformation to be saved.
727 *
728 * IS_PROJECTIVE indicates whether to write a projective transformation.
729 *
730 * IS_PRIMARY indicates whether to write a primary transformation
731 *
732 */
733
734 static inline void tsave_next(struct tsave_t *t, transformation offset, int is_projective,
735 int is_primary) {
736
737 if (t == NULL)
738 return;
739
740 t->file = fopen(t->filename, "a");
741
742 if (is_primary && offset.bd_count() > 0) {
743 assert (tfile_output_version >= 3);
744 unsigned int i;
745
746 fprintf(t->file, "B ");
747 fprintf(t->file, "%u ", offset.bd_count());
748 for (i = 0; i < offset.bd_count(); i++)
749 fprintf(t->file, "%f ", (double) offset.bd_get(i));
750 fprintf(t->file, "\n");
751 }
752
753 if (is_projective) {
754 int i, j;
755
756 fprintf(t->file, is_primary ? "P " : "Q ");
757 fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
758 for (i = 0; i < 4; i++)
759 for (j = 1; j >= 0; j--)
760 fprintf(t->file, "%f ", (double) offset.gpt_get(i, j));
761 } else {
762 fprintf(t->file, is_primary ? "E " : "F ");
763 fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
764 fprintf(t->file, "%f ", (double) offset.eu_get(1));
765 fprintf(t->file, "%f ", (double) offset.eu_get(0));
766 fprintf(t->file, "%f ", (double) offset.eu_get(2));
767 }
768
769 fprintf(t->file, "\n");
770
771 fclose(t->file);
772 }
773
774 /*
775 * Write information to a transformation file indicating the target output
776 * file.
777 */
778
779 static inline void tsave_target(struct tsave_t *t, const char *filename) {
780 if (t == NULL)
781 return;
782
783 t->target = filename;
784 if (t != NULL) {
785 t->file = fopen(t->filename, "a");
786
787
788 fclose(t->file);
789 }
790 }
791
792 /*
793 * Write information to a transformation data file indicating the filename
794 * of the original frame (i.e. the first frame in the sequence of input
795 * frames).
796 */
797
798 static inline void tsave_orig(struct tsave_t *t, const char *filename, pixel apm) {
799 if (t == NULL)
800 return;
801
802 t->orig = filename;
803 t->orig_apm = apm;
804 }
805
806 /*
807 * Write information to a transformation data file indicating the filename
808 * of a supplemental frame (i.e. a frame in the sequence of input frames
809 * that is not the first frame).
810 */
811
812 static inline void tsave_info(struct tsave_t *t, const char *filename) {
813 if (t != NULL) {
814 t->file = fopen(t->filename, "a");
815
816 fprintf(t->file, "# Comment: Supplemental frame %s\n", filename);
817
818 fclose(t->file);
819 }
820 }
821
822 /*
823 * Write information to a transformation data file indicating the tonal
824 * registration multiplier.
825 */
826
827 static inline void tsave_trm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
828 if (t != NULL) {
829 t->file = fopen(t->filename, "a");
830
831 fprintf(t->file, "# Comment: Exposure [r=%f g=%f b=%f]\n", r, g, b);
832
833 fclose(t->file);
834 }
835 }
836
837 /*
838 * Write information to a transformation data file indicating the average
839 * pixel magnitude.
840 */
841
842 static inline void tsave_apm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
843 if (t != NULL) {
844 t->file = fopen(t->filename, "a");
845
846 fprintf(t->file, "# Comment: Avg magnitude [r=%f g=%f b=%f]\n", r, g, b);
847
848 fclose(t->file);
849 }
850 }
851
852
853 /*
854 * Destroy a tload_t transformation data file structure.
855 */
856
857 static inline void tload_delete(struct tload_t *victim) {
858 if (victim)
859 fclose(victim->file);
860 free(victim);
861 }
862
863 /*
864 * Destroy a tsave_t transformation data file structure.
865 */
866
867 static inline void tsave_delete(struct tsave_t *victim) {
868 free(victim);
869 }
870
871 #endif
synthetic capture engine and renderer