source/blender/avi/AVI_avi.h

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