source/blender/avi/AVI_avi.h

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