source/blender/avi/AVI_avi.h

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  *
  29  */
  30
  31 /** \file AVI_avi.h
  32  *  \ingroup avi
  33  * \section aviabout AVI module external interface
  34  *
  35  * \subsection about About the AVI module
  36  *
  37  * This is external code. It provides avi file import/export and
  38  * conversions. It has been adapted to make use of Blender memory
  39  * management functions, and because of this it needs module
  40  * blenlib. You need to provide this lib when linking with libavi.a .
  41  *
  42  * \subsection issues Known issues with AVI
  43  *
  44  * - avi uses mallocN, freeN from blenlib.
  45  * - Not all functions that are used externally are properly
  46  *   prototyped.
  47  *
  48  * This header has not been split, since it interleaves type defines
  49  * and functions. You would need the types to be able to include the
  50  * function headers anyway. And, after all, it is someone else's
  51  * code. So we keep it like this.
  52  *
  53  */
  54
  55 #ifndef __AVI_H__
  56 #define __AVI_H__
  57
  58 #include <stdio.h> /* for FILE */
  59
  60 typedef struct _AviChunk {
  61   int fcc;
  62   int size;
  63 } AviChunk;
  64
  65 typedef struct _AviList {
  66   int fcc;
  67   int size;
  68   int ids;
  69 } AviList;
  70
  71 typedef struct _AviMainHeader {
  72   int fcc;
  73   int size;
  74   int MicroSecPerFrame;       /* MicroSecPerFrame - timing between frames */
  75   int MaxBytesPerSec;        /* MaxBytesPerSec - approx bps system must handle */
  76   int PaddingGranularity;
  77   int Flags;
  78 #define AVIF_HASINDEX           0x00000010        /* had idx1 chunk */
  79 #define AVIF_MUSTUSEINDEX       0x00000020        /* must use idx1 chunk to determine order */
  80 #define AVIF_ISINTERLEAVED      0x00000100        /* AVI file is interleaved */
  81 #define AVIF_TRUSTCKTYPE        0x00000800
  82 #define AVIF_WASCAPTUREFILE     0x00010000        /* specially allocated used for capturing real time video */
  83 #define AVIF_COPYRIGHTED        0x00020000        /* contains copyrighted data */
  84
  85   int TotalFrames;
  86   int InitialFrames;    /* InitialFrames - initial frame before interleaving */
  87   int Streams;
  88   int SuggestedBufferSize;
  89   int Width;
  90   int Height;
  91   int Reserved[4];
  92 } AviMainHeader;
  93
  94 typedef struct _AviStreamHeader {
  95   int fcc;
  96   int size;
  97   int Type;
  98 #define AVIST_VIDEO FCC("vids")
  99 #define AVIST_AUDIO FCC("auds")
 100 #define AVIST_MIDI  FCC("mids")
 101 #define AVIST_TEXT  FCC("txts")
 102
 103   int Handler;
 104   int Flags;
 105 #define AVISF_DISABLED 0x00000001
 106 #define AVISF_VIDEO_PALCHANGES 0x00010000
 107
 108   short Priority;
 109   short Language;
 110   int InitialFrames;
 111   int Scale;
 112   int Rate;
 113   int Start;
 114   int Length;
 115   int SuggestedBufferSize;
 116   int Quality;
 117   int SampleSize;
 118   short left;
 119   short top;
 120   short right;
 121   short bottom;
 122 } AviStreamHeader;
 123
 124 typedef struct _AviBitmapInfoHeader {
 125   int fcc;
 126   int size;
 127   int Size;
 128   int Width;
 129   int Height;
 130   short Planes;
 131   short BitCount;
 132   int Compression;
 133   int SizeImage;
 134   int XPelsPerMeter;
 135   int YPelsPerMeter;
 136   int ClrUsed;
 137   int ClrImportant;
 138 } AviBitmapInfoHeader;
 139
 140 typedef struct _AviMJPEGUnknown {
 141   int a;
 142   int b;
 143   int c;
 144   int d;
 145   int e;
 146   int f;
 147   int g;
 148 } AviMJPEGUnknown;
 149
 150 typedef struct _AviIndexEntry {
 151   int ChunkId;
 152   int Flags;
 153 #define AVIIF_LIST       0x00000001
 154 #define AVIIF_KEYFRAME   0x00000010
 155 #define AVIIF_NO_TIME    0x00000100
 156 #define AVIIF_COMPRESSOR 0x0FFF0000
 157   int Offset;
 158   int Size;
 159 } AviIndexEntry;
 160
 161 typedef struct _AviIndex {
 162   int fcc;
 163   int size;
 164   AviIndexEntry *entrys;
 165 } AviIndex;
 166
 167 typedef enum {
 168   AVI_FORMAT_RGB24,  /* The most basic of forms, 3 bytes per pixel, 1 per r, g, b */
 169   AVI_FORMAT_RGB32,  /* The second most basic of forms, 4 bytes per pixel, 1 per r, g, b, alpha */
 170   AVI_FORMAT_AVI_RGB, /* Same as above, but is in the weird AVI order (bottom to top, left to right) */
 171   AVI_FORMAT_MJPEG /* Motion-JPEG */
 172 } AviFormat;
 173
 174 typedef struct _AviStreamRec {
 175   AviStreamHeader sh;
 176   void *sf;
 177   int sf_size;
 178   AviFormat format;
 179 } AviStreamRec;
 180
 181 typedef struct _AviMovie {
 182         FILE *fp;
 183
 184         int type;
 185 #define AVI_MOVIE_READ  0
 186 #define AVI_MOVIE_WRITE 1
 187
 188         unsigned long size;
 189
 190         AviMainHeader *header;
 191         AviStreamRec *streams;
 192         AviIndexEntry *entries;
 193         int index_entries;
 194
 195         int movi_offset;
 196         int read_offset;
 197         long *offset_table;
 198
 199         /* Local data goes here */
 200         int interlace;
 201         int odd_fields;
 202 } AviMovie;
 203
 204 typedef enum {
 205   AVI_ERROR_NONE=0,
 206   AVI_ERROR_COMPRESSION,
 207   AVI_ERROR_OPEN,
 208   AVI_ERROR_READING,
 209   AVI_ERROR_WRITING,
 210   AVI_ERROR_FORMAT,
 211   AVI_ERROR_ALLOC,
 212   AVI_ERROR_FOUND,
 213   AVI_ERROR_OPTION
 214 } AviError;
 215
 216 /* belongs to the option-setting function. */
 217 typedef enum {
 218   AVI_OPTION_WIDTH=0,
 219   AVI_OPTION_HEIGHT,
 220   AVI_OPTION_QUALITY,
 221   AVI_OPTION_FRAMERATE
 222 } AviOption;
 223
 224 /* The offsets that will always stay the same in AVI files we
 225  * write... used to seek around to the places where we need to write
 226  * the sizes */
 227
 228 #define AVI_RIFF_SOFF 4L
 229 #define AVI_HDRL_SOFF 16L
 230
 231 /**
 232  * This is a sort of MAKE_ID thing. Used in imbuf :( It is used
 233  * through options in the AVI header (AviStreamHeader). */
 234 #define FCC(ch4) (ch4[0] | ch4[1]<<8 | ch4[2]<<16 | ch4[3] << 24)
 235
 236 /**
 237  * Test whether this is an avi-format.
 238  */
 239 int AVI_is_avi (const char *name);
 240
 241
 242 /**
 243  * Open a compressed file, decompress it into memory.
 244  */
 245 AviError AVI_open_compress (char *name, AviMovie *movie, int streams, ...);
 246
 247 /**
 248  * Finalize a compressed output stream.
 249  */
 250 AviError AVI_close_compress (AviMovie *movie);
 251
 252 /**
 253  * Choose a compression option for <movie>. Possible options are
 254  * AVI_OPTION_TYPE_MAIN, AVI_OPTION_TYPE_STRH, AVI_OPTION_TYPE_STRF
 255  */
 256 AviError AVI_set_compress_option (AviMovie *movie,
 257                                                                   int option_type,
 258                                                                   int stream,
 259                                                                   AviOption option,
 260                                                                   void *opt_data);
 261 /* Hmmm... there should be some explanantion about what these mean */
 262 /**
 263  * Compression option, for use in avi_set_compress_option
 264  */
 265 #define AVI_OPTION_TYPE_MAIN 0
 266 /**
 267  * Compression option, for use in avi_set_compress_option
 268  */
 269 #define AVI_OPTION_TYPE_STRH 1
 270 /**
 271  * Compression option, for use in avi_set_compress_option
 272  */
 273 #define AVI_OPTION_TYPE_STRF 2
 274
 275 /**
 276  * Direct the streams <avist_type> to <movie>. Redirect <stream_num>
 277  * streams.
 278  */
 279 int AVI_get_stream (AviMovie *movie, int avist_type, int stream_num);
 280
 281 /**
 282  * Open a movie stream from file.
 283  */
 284 AviError AVI_open_movie (const char *name, AviMovie *movie);
 285
 286 /**
 287  * Read a frame from a movie stream.
 288  */
 289 void *AVI_read_frame (AviMovie *movie,
 290                                           AviFormat format,
 291                                           int frame,
 292                                           int stream);
 293 /**
 294  * Close an open movie stream.
 295  */
 296 AviError AVI_close (AviMovie *movie);
 297
 298 /**
 299  * Write frames to a movie stream.
 300  */
 301 AviError AVI_write_frame (AviMovie *movie, int frame_num, ...);
 302
 303 /**
 304  * Unused but still external
 305  */
 306 AviError AVI_print_error (AviError error);
 307 void AVI_set_debug (int mode);
 308
 309 #endif /* __AVI_H__ */
 310