Object tracking: configurable scale for object solution
[blender-staging.git] / source / blender / blenloader / intern / undofile.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program 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 this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2004 Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  * .blend file reading entry point
27  */
28
29 /** \file blender/blenloader/intern/undofile.c
30  *  \ingroup blenloader
31  */
32
33
34 #include <stdlib.h>
35 #include <string.h>
36 #include <stdio.h>
37 #include <math.h>
38
39 #include "MEM_guardedalloc.h"
40
41 #include "DNA_listBase.h"
42
43
44 #include "BLO_undofile.h"
45
46 #include "BLI_blenlib.h"
47 #include "BLI_linklist.h"
48
49
50
51 /* **************** support for memory-write, for undo buffers *************** */
52
53 /* not memfile itself */
54 void BLO_free_memfile(MemFile *memfile)
55 {
56         MemFileChunk *chunk;
57         
58         while( (chunk = (memfile->chunks.first) ) ) {
59                 if(chunk->ident==0) MEM_freeN(chunk->buf);
60                 BLI_remlink(&memfile->chunks, chunk);
61                 MEM_freeN(chunk);
62         }
63         memfile->size= 0;
64 }
65
66 /* to keep list of memfiles consistent, 'first' is always first in list */
67 /* result is that 'first' is being freed */
68 void BLO_merge_memfile(MemFile *first, MemFile *second)
69 {
70         MemFileChunk *fc, *sc;
71         
72         fc= first->chunks.first;
73         sc= second->chunks.first;
74         while (fc || sc) {
75                 if(fc && sc) {
76                         if(sc->ident) {
77                                 sc->ident= 0;
78                                 fc->ident= 1;
79                         }
80                 }
81                 if(fc) fc= fc->next;
82                 if(sc) sc= sc->next;
83         }
84         
85         BLO_free_memfile(first);
86 }
87
88 static int my_memcmp(int *mem1, int *mem2, int len)
89 {
90         register int a= len, *mema= mem1, *memb= mem2;
91         
92         while(a--) {
93                 if( *mema != *memb) return 1;
94                 mema++;
95                 memb++;
96         }
97         return 0;
98 }
99
100 void add_memfilechunk(MemFile *compare, MemFile *current, char *buf, unsigned int size)
101 {
102         static MemFileChunk *compchunk=NULL;
103         MemFileChunk *curchunk;
104         
105         /* this function inits when compare != NULL or when current==NULL */
106         if(compare) {
107                 compchunk= compare->chunks.first;
108                 return;
109         }
110         if(current==NULL) {
111                 compchunk= NULL;
112                 return;
113         }
114         
115         curchunk= MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk");
116         curchunk->size= size;
117         curchunk->buf= NULL;
118         curchunk->ident= 0;
119         BLI_addtail(&current->chunks, curchunk);
120         
121         /* we compare compchunk with buf */
122         if(compchunk) {
123                 if(compchunk->size == curchunk->size) {
124                         if( my_memcmp((int *)compchunk->buf, (int *)buf, size/4)==0) {
125                                 curchunk->buf= compchunk->buf;
126                                 curchunk->ident= 1;
127                         }
128                 }
129                 compchunk= compchunk->next;
130         }
131         
132         /* not equal... */
133         if(curchunk->buf==NULL) {
134                 curchunk->buf= MEM_mallocN(size, "Chunk buffer");
135                 memcpy(curchunk->buf, buf, size);
136                 current->size += size;
137         }
138 }
139