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
  48 #if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
  49 #define WORDS_BIGENDIAN
  50 #endif
  51
  52 static void invert (int *num) {
  53         int new=0,i,j;
  54
  55         for (j=0; j < 4; j++) {
  56                 for (i=0; i<8; i++) {
  57                         new |= ((*num>>(j*8+i))&1)<<((3-j)*8+i);
  58                 }
  59         }
  60
  61         *num = new;
  62 }
  63
  64 static void sinvert (short int *num) {
  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         invert (&chunk->fcc);
  79         invert (&chunk->size);
  80 }
  81
  82 #ifdef WORDS_BIGENDIAN
  83 static void Ilist (AviList *list){
  84         invert (&list->fcc);
  85         invert (&list->size);
  86         invert (&list->ids);
  87 }
  88
  89 static void Imainh (AviMainHeader *mainh) {
  90         invert (&mainh->fcc);
  91         invert (&mainh->size);
  92         invert (&mainh->MicroSecPerFrame);
  93         invert (&mainh->MaxBytesPerSec);
  94         invert (&mainh->PaddingGranularity);
  95         invert (&mainh->Flags);
  96         invert (&mainh->TotalFrames);
  97         invert (&mainh->InitialFrames);
  98         invert (&mainh->Streams);
  99         invert (&mainh->SuggestedBufferSize);
 100         invert (&mainh->Width);
 101         invert (&mainh->Height);
 102         invert (&mainh->Reserved[0]);
 103         invert (&mainh->Reserved[1]);
 104         invert (&mainh->Reserved[2]);
 105         invert (&mainh->Reserved[3]);
 106 }
 107
 108 static void Istreamh (AviStreamHeader *streamh) {
 109         invert (&streamh->fcc);
 110         invert (&streamh->size);
 111         invert (&streamh->Type);
 112         invert (&streamh->Handler);
 113         invert (&streamh->Flags);
 114         sinvert (&streamh->Priority);
 115         sinvert (&streamh->Language);
 116         invert (&streamh->InitialFrames);
 117         invert (&streamh->Scale);
 118         invert (&streamh->Rate);
 119         invert (&streamh->Start);
 120         invert (&streamh->Length);
 121         invert (&streamh->SuggestedBufferSize);
 122         invert (&streamh->Quality);
 123         invert (&streamh->SampleSize);
 124         sinvert (&streamh->left);
 125         sinvert (&streamh->right);
 126         sinvert (&streamh->top);
 127         sinvert (&streamh->bottom);
 128 }
 129
 130 static void Ibitmaph (AviBitmapInfoHeader *bitmaph) {
 131         invert (&bitmaph->fcc);
 132         invert (&bitmaph->size);
 133         invert (&bitmaph->Size);
 134         invert (&bitmaph->Width);
 135         invert (&bitmaph->Height);
 136         sinvert (&bitmaph->Planes);
 137         sinvert (&bitmaph->BitCount);
 138         invert (&bitmaph->Compression);
 139         invert (&bitmaph->SizeImage);
 140         invert (&bitmaph->XPelsPerMeter);
 141         invert (&bitmaph->YPelsPerMeter);
 142         invert (&bitmaph->ClrUsed);
 143         invert (&bitmaph->ClrImportant);
 144 }
 145
 146 static void Imjpegu (AviMJPEGUnknown *mjpgu) {
 147         invert (&mjpgu->a);
 148         invert (&mjpgu->b);
 149         invert (&mjpgu->c);
 150         invert (&mjpgu->d);
 151         invert (&mjpgu->e);
 152         invert (&mjpgu->f);
 153         invert (&mjpgu->g);
 154 }
 155
 156 static void Iindexe (AviIndexEntry *indexe) {
 157         invert (&indexe->ChunkId);
 158         invert (&indexe->Flags);
 159         invert (&indexe->Offset);
 160         invert (&indexe->Size);
 161 }
 162 #endif /* WORDS_BIGENDIAN */
 163
 164 void awrite (AviMovie *movie, void *datain, int block, int size, FILE *fp, int type) {
 165 #ifdef WORDS_BIGENDIAN
 166         void *data;
 167
 168         data = malloc (size);
 169
 170         memcpy (data, datain, size);
 171
 172         switch (type) {
 173         case AVI_RAW:
 174                 fwrite (data, block, size, fp);
 175                 break;
 176         case AVI_CHUNK:
 177                 Ichunk ((AviChunk *) data);
 178                 fwrite (data, block, size, fp);
 179                 break;
 180         case AVI_LIST:
 181                 Ilist ((AviList *) data);
 182                 fwrite (data, block, size, fp);
 183                 break;
 184         case AVI_MAINH:
 185                 Imainh ((AviMainHeader *) data);
 186                 fwrite (data, block, size, fp);
 187                 break;
 188         case AVI_STREAMH:
 189                 Istreamh ((AviStreamHeader *) data);
 190                 fwrite (data, block, size, fp);
 191                 break;
 192         case AVI_BITMAPH:
 193                 Ibitmaph ((AviBitmapInfoHeader *) data);
 194                 if (size==sizeof(AviBitmapInfoHeader) + sizeof(AviMJPEGUnknown)) {
 195                         Imjpegu((AviMJPEGUnknown*)((char*)data+sizeof(AviBitmapInfoHeader)));
 196                 }
 197                 fwrite (data, block, size, fp);
 198                 break;
 199         case AVI_MJPEGU:
 200                 Imjpegu ((AviMJPEGUnknown *) data);
 201                 fwrite (data, block, size, fp);
 202                 break;
 203         case AVI_INDEXE:
 204                 Iindexe ((AviIndexEntry *) data);
 205                 fwrite (data, block, size, fp);
 206                 break;
 207         default:
 208                 break;
 209         }
 210
 211         free (data);
 212 #else /* WORDS_BIGENDIAN */
 213         fwrite (datain, block, size, fp);
 214 #endif /* WORDS_BIGENDIAN */
 215 }