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