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