Merging r46096 through r46110 from trunk into soc-2011-tomato
[blender-staging.git] / source / blender / avi / intern / endian.c
1 /*
2  *
3  * This is external code. Streams bytes to output depending on the
4  * endianness of the system.
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  *
31  */
32
33 /** \file blender/avi/intern/endian.c
34  *  \ingroup avi
35  */
36
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include <stdio.h> 
41 #include "AVI_avi.h"
42 #include "endian.h"
43 #include "avi_intern.h"
44
45 #ifdef __BIG_ENDIAN__
46 #include "MEM_guardedalloc.h"
47 #endif
48
49 #ifdef __BIG_ENDIAN__
50 static void invert (int *num)
51 {
52         int new=0, i, j;
53
54         for (j=0; j < 4; j++) {
55                 for (i=0; i<8; i++) {
56                         new |= ((*num>>(j*8+i))&1)<<((3-j)*8+i);
57                 }
58         }
59         
60         *num = new;
61 }
62
63 static void sinvert (short int *num)
64 {
65         short int new=0;
66         int i, j;
67
68         for (j=0; j < 2; j++) {
69                 for (i=0; i<8; i++) {
70                         new |= ((*num>>(j*8+i))&1)<<((1-j)*8+i);
71                 }
72         }
73
74         *num = new;
75 }
76
77 static void Ichunk (AviChunk *chunk)
78 {
79         invert (&chunk->fcc);
80         invert (&chunk->size);
81 }
82 #endif
83
84 #ifdef __BIG_ENDIAN__
85 static void Ilist (AviList *list)
86 {
87         invert (&list->fcc);
88         invert (&list->size);
89         invert (&list->ids);
90 }
91
92 static void Imainh (AviMainHeader *mainh)
93 {
94         invert (&mainh->fcc);
95         invert (&mainh->size);
96         invert (&mainh->MicroSecPerFrame);
97         invert (&mainh->MaxBytesPerSec);
98         invert (&mainh->PaddingGranularity);
99         invert (&mainh->Flags);
100         invert (&mainh->TotalFrames);
101         invert (&mainh->InitialFrames);
102         invert (&mainh->Streams);
103         invert (&mainh->SuggestedBufferSize);
104         invert (&mainh->Width);
105         invert (&mainh->Height);
106         invert (&mainh->Reserved[0]);
107         invert (&mainh->Reserved[1]);
108         invert (&mainh->Reserved[2]);
109         invert (&mainh->Reserved[3]);
110 }
111
112 static void Istreamh (AviStreamHeader *streamh)
113 {
114         invert (&streamh->fcc);
115         invert (&streamh->size);
116         invert (&streamh->Type);
117         invert (&streamh->Handler);
118         invert (&streamh->Flags);
119         sinvert (&streamh->Priority);
120         sinvert (&streamh->Language);
121         invert (&streamh->InitialFrames);
122         invert (&streamh->Scale);
123         invert (&streamh->Rate);
124         invert (&streamh->Start);
125         invert (&streamh->Length);
126         invert (&streamh->SuggestedBufferSize);
127         invert (&streamh->Quality);
128         invert (&streamh->SampleSize);
129         sinvert (&streamh->left);
130         sinvert (&streamh->right);
131         sinvert (&streamh->top);
132         sinvert (&streamh->bottom);
133 }
134
135 static void Ibitmaph (AviBitmapInfoHeader *bitmaph)
136 {
137         invert (&bitmaph->fcc);
138         invert (&bitmaph->size);
139         invert (&bitmaph->Size);
140         invert (&bitmaph->Width);
141         invert (&bitmaph->Height);
142         sinvert (&bitmaph->Planes);
143         sinvert (&bitmaph->BitCount);
144         invert (&bitmaph->Compression);
145         invert (&bitmaph->SizeImage);
146         invert (&bitmaph->XPelsPerMeter);
147         invert (&bitmaph->YPelsPerMeter);
148         invert (&bitmaph->ClrUsed);
149         invert (&bitmaph->ClrImportant);
150 }
151
152 static void Imjpegu (AviMJPEGUnknown *mjpgu)
153 {
154         invert (&mjpgu->a);
155         invert (&mjpgu->b);
156         invert (&mjpgu->c);
157         invert (&mjpgu->d);
158         invert (&mjpgu->e);
159         invert (&mjpgu->f);
160         invert (&mjpgu->g);
161 }
162
163 static void Iindexe (AviIndexEntry *indexe)
164 {
165         invert (&indexe->ChunkId);
166         invert (&indexe->Flags);
167         invert (&indexe->Offset);
168         invert (&indexe->Size);
169 }
170 #endif /* __BIG_ENDIAN__ */
171
172 void awrite(AviMovie *movie, void *datain, int block, int size, FILE *fp, int type)
173 {
174 #ifdef __BIG_ENDIAN__
175         void *data;
176
177         data = MEM_mallocN (size, "avi endian");
178
179         memcpy (data, datain, size);
180
181         switch (type) {
182         case AVI_RAW:
183                 fwrite (data, block, size, fp);
184                 break;
185         case AVI_CHUNK:
186                 Ichunk ((AviChunk *) data);
187                 fwrite (data, block, size, fp);
188                 break;
189         case AVI_LIST:
190                 Ilist ((AviList *) data);
191                 fwrite (data, block, size, fp);
192                 break;
193         case AVI_MAINH:
194                 Imainh ((AviMainHeader *) data);
195                 fwrite (data, block, size, fp);
196                 break;
197         case AVI_STREAMH:
198                 Istreamh ((AviStreamHeader *) data);
199                 fwrite (data, block, size, fp);
200                 break;
201         case AVI_BITMAPH:
202                 Ibitmaph ((AviBitmapInfoHeader *) data);
203                 if (size==sizeof(AviBitmapInfoHeader) + sizeof(AviMJPEGUnknown)) {
204                         Imjpegu((AviMJPEGUnknown*)((char*)data+sizeof(AviBitmapInfoHeader)));
205                 }
206                 fwrite (data, block, size, fp);
207                 break;
208         case AVI_MJPEGU:
209                 Imjpegu ((AviMJPEGUnknown *) data);
210                 fwrite (data, block, size, fp);
211                 break;
212         case AVI_INDEXE:
213                 Iindexe ((AviIndexEntry *) data);
214                 fwrite (data, block, size, fp);
215                 break;
216         default:
217                 break;
218         }
219
220         MEM_freeN (data);
221 #else /* __BIG_ENDIAN__ */
222         (void)movie; /* unused */
223         (void)type; /* unused */
224         fwrite (datain, block, size, fp);
225 #endif /* __BIG_ENDIAN__ */
226 }