← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Devices/Graphics/shaderlib/wine/include/aviriff.h

  • Committer: Package Import Robot
  • Author(s): Gianfranco Costamagna
  • Date: 2016-02-23 14:28:26 UTC
  • Revision ID: package-import@ubuntu.com-20160223142826-bdu69el2z6wa2a44
Tags: upstream-4.3.36-dfsg
Import upstream version 4.3.36-dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Devices/Graphics/shaderlib/wine/include/aviriff.h
 
1
/*
 
2
 * Copyright (C) 2003 Robert Shearman
 
3
 * Copyright (C) 2008 Maarten Lankhorst
 
4
 *
 
5
 * This library is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU Lesser General Public
 
7
 * License as published by the Free Software Foundation; either
 
8
 * version 2.1 of the License, or (at your option) any later version.
 
9
 *
 
10
 * This library is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 * Lesser General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU Lesser General Public
 
16
 * License along with this library; if not, write to the Free Software
 
17
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 
18
 */
 
19
 
 
20
/*
 
21
 * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
 
22
 * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
 
23
 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
 
24
 * a choice of LGPL license versions is made available with the language indicating
 
25
 * that LGPLv2 or any later version may be used, or where a choice of which version
 
26
 * of the LGPL is applied is otherwise unspecified.
 
27
 */
 
28
 
 
29
/* All definitions here are packed structures of on-disk formats */
 
30
#include <pshpack2.h>
 
31
 
 
32
typedef struct _riffchunk
 
33
{
 
34
    FOURCC fcc;
 
35
    DWORD cb;
 
36
} RIFFCHUNK, * LPRIFFCHUNK;
 
37
 
 
38
typedef struct _rifflist
 
39
{
 
40
    FOURCC fcc;
 
41
    DWORD cb;
 
42
    FOURCC fccListType;
 
43
} RIFFLIST, * LPRIFFLIST;
 
44
 
 
45
#define FCC( ch0, ch1, ch2, ch3 ) \
 
46
    ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) <<  8 ) | \
 
47
    ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
 
48
 
 
49
#define RIFFROUND(cb) ((cb) + ((cb)&1))
 
50
#define RIFFNEXT(pChunk) (LPRIFFCHUNK)((LPBYTE)(pChunk)+sizeof(RIFFCHUNK)+RIFFROUND(((LPRIFFCHUNK)pChunk)->cb))
 
51
 
 
52
/* flags for dwFlags member of AVIMAINHEADER */
 
53
#define AVIF_HASINDEX       0x00000010
 
54
#define AVIF_MUSTUSEINDEX   0x00000020
 
55
#define AVIF_ISINTERLEAVED  0x00000100
 
56
#define AVIF_TRUSTCKTYPE    0x00000800
 
57
#define AVIF_WASCAPTUREFILE 0x00010000
 
58
#define AVIF_COPYRIGHTED    0x00020000
 
59
 
 
60
#define ckidMAINAVIHEADER FCC('a','v','i','h')
 
61
typedef struct _avimainheader
 
62
{
 
63
    FOURCC fcc;
 
64
    DWORD cb;
 
65
    DWORD dwMicroSecPerFrame;
 
66
    DWORD dwMaxBytesPerSec;
 
67
    DWORD dwPaddingGranularity;
 
68
    DWORD dwFlags;
 
69
    DWORD dwTotalFrames;
 
70
    DWORD dwInitialFrames;
 
71
    DWORD dwStreams;
 
72
    DWORD dwSuggestedBufferSize;
 
73
    DWORD dwWidth;
 
74
    DWORD dwHeight;
 
75
    DWORD dwReserved[4];
 
76
} AVIMAINHEADER;
 
77
 
 
78
#define ckidODML FCC('o','d','m','l')
 
79
#define ckidAVIEXTHEADER  FCC('d','m','l','h')
 
80
typedef struct _aviextheader
 
81
{
 
82
    FOURCC fcc;
 
83
    DWORD cb;
 
84
    DWORD dwGrandFrames;
 
85
    DWORD dwFuture[61];
 
86
} AVIEXTHEADER;
 
87
 
 
88
#define ckidSTREAMLIST FCC('s','t','r','l')
 
89
 
 
90
/* flags for dwFlags member of AVISTREAMHEADER */
 
91
#define AVISF_DISABLED         0x00000001
 
92
#define AVISF_VIDEO_PALCHANGES 0x00010000
 
93
 
 
94
#ifndef ckidSTREAMHEADER
 
95
#define ckidSTREAMHEADER FCC('s','t','r','h')
 
96
#endif
 
97
 
 
98
#ifndef streamtypeVIDEO
 
99
#define streamtypeVIDEO FCC('v','i','d','s')
 
100
#define streamtypeAUDIO FCC('a','u','d','s')
 
101
#define streamtypeMIDI FCC('m','i','d','s')
 
102
#define streamtypeTEXT FCC('t','x','t','s')
 
103
#endif
 
104
 
 
105
typedef struct _avistreamheader
 
106
{
 
107
    FOURCC fcc;
 
108
    DWORD cb;
 
109
    FOURCC fccType;
 
110
    FOURCC fccHandler;
 
111
    DWORD dwFlags;
 
112
    WORD wPriority;
 
113
    WORD wLanguage;
 
114
    DWORD dwInitialFrames;
 
115
    DWORD dwScale;
 
116
    DWORD dwRate;
 
117
    DWORD dwStart;
 
118
    DWORD dwLength;
 
119
    DWORD dwSuggestedBufferSize;
 
120
    DWORD dwQuality;
 
121
    DWORD dwSampleSize;
 
122
    struct
 
123
    {
 
124
        short int left;
 
125
        short int top;
 
126
        short int right;
 
127
        short int bottom;
 
128
    } rcFrame;
 
129
} AVISTREAMHEADER;
 
130
 
 
131
#ifndef ckidSTREAMFORMAT
 
132
#define ckidSTREAMFORMAT FCC('s','t','r','f')
 
133
#endif
 
134
#define ckidAVIOLDINDEX FCC('i','d','x','1')
 
135
 
 
136
/* flags for dwFlags member of _avioldindex_entry */
 
137
#define AVIIF_LIST       0x00000001
 
138
#define AVIIF_KEYFRAME   0x00000010
 
139
#define AVIIF_NO_TIME    0x00000100
 
140
#define AVIIF_COMPRESSOR 0x0FFF0000
 
141
 
 
142
typedef struct _avioldindex
 
143
{
 
144
    FOURCC fcc;
 
145
    DWORD cb;
 
146
    struct _avioldindex_entry
 
147
    {
 
148
        DWORD dwChunkId;
 
149
        DWORD dwFlags;
 
150
        DWORD dwOffset;
 
151
        DWORD dwSize;
 
152
    } aIndex[ANYSIZE_ARRAY];
 
153
} AVIOLDINDEX;
 
154
 
 
155
typedef union _timecode
 
156
{
 
157
    struct
 
158
    {
 
159
        WORD wFrameRate;
 
160
        WORD wFrameFract;
 
161
        LONG cFrames;
 
162
    } DUMMYSTRUCTNAME;
 
163
    DWORDLONG qw;
 
164
} TIMECODE;
 
165
 
 
166
#define TIMECODE_RATE_30DROP 0
 
167
 
 
168
/* flags for dwSMPTEflags member of TIMECODEDATA */
 
169
#define TIMECODE_SMPTE_BINARY_GROUP 0x07
 
170
#define TIMECODE_SMPTE_COLOR_FRAME  0x08
 
171
 
 
172
typedef struct _timecodedata
 
173
{
 
174
    TIMECODE time;
 
175
    DWORD dwSMPTEflags;
 
176
    DWORD dwUser;
 
177
} TIMECODEDATA;
 
178
 
 
179
#define AVI_INDEX_OF_INDEXES      0x00
 
180
#define AVI_INDEX_OF_CHUNKS       0x01
 
181
#define AVI_INDEX_OF_TIMED_CHUNKS 0x02
 
182
#define AVI_INDEX_OF_SUB_2FIELD   0x03
 
183
#define AVI_INDEX_IS_DATA         0x80
 
184
 
 
185
#define AVI_INDEX_SUB_DEFAULT     0x00
 
186
#define AVI_INDEX_SUB_2FIELD      0x01
 
187
 
 
188
typedef struct _avimetaindex
 
189
{
 
190
    FOURCC fcc;
 
191
    UINT cb;
 
192
    WORD wLongsPerEntry;
 
193
    BYTE bIndexSubType;
 
194
    BYTE bIndexType;
 
195
    DWORD nEntriesInUse;
 
196
    DWORD dwChunkId;
 
197
    DWORD dwReserved[3];
 
198
    DWORD adwIndex[ANYSIZE_ARRAY];
 
199
} AVIMETAINDEX;
 
200
 
 
201
#define ckidAVISUPERINDEX FCC('i','n','d','x')
 
202
typedef struct _avisuperindex {
 
203
    FOURCC fcc;
 
204
    UINT cb;
 
205
    WORD wLongsPerEntry;
 
206
    BYTE bIndexSubType;
 
207
    BYTE bIndexType;
 
208
    DWORD nEntriesInUse;
 
209
    DWORD dwChunkId;
 
210
    DWORD dwReserved[3];
 
211
    struct _avisuperindex_entry {
 
212
        DWORDLONG qwOffset;
 
213
        DWORD dwSize;
 
214
        DWORD dwDuration;
 
215
    } aIndex[ANYSIZE_ARRAY];
 
216
} AVISUPERINDEX;
 
217
 
 
218
#define AVISTDINDEX_DELTAFRAME (0x80000000)
 
219
#define AVISTDINDEX_SIZEMASK (~0x80000000)
 
220
 
 
221
typedef struct _avistdindex_entry {
 
222
    DWORD dwOffset;
 
223
    DWORD dwSize;
 
224
} AVISTDINDEX_ENTRY;
 
225
 
 
226
typedef struct _avistdindex {
 
227
    FOURCC fcc;
 
228
    UINT cb;
 
229
    WORD wLongsPerEntry;
 
230
    BYTE bIndexSubType;
 
231
    BYTE bIndexType;
 
232
    DWORD    nEntriesInUse;
 
233
    DWORD    dwChunkId;
 
234
    DWORDLONG qwBaseOffset;
 
235
    DWORD    dwReserved_3;
 
236
    AVISTDINDEX_ENTRY aIndex[ANYSIZE_ARRAY];
 
237
} AVISTDINDEX;
 
238
 
 
239
typedef struct _avitimedindex_entry {
 
240
    DWORD dwOffset;
 
241
    DWORD dwSize;
 
242
    DWORD dwDuration;
 
243
} AVITIMEDINDEX_ENTRY;
 
244
 
 
245
typedef struct _avitimedindex {
 
246
    FOURCC fcc;
 
247
    UINT cb;
 
248
    WORD wLongsPerEntry;
 
249
    BYTE bIndexSubType;
 
250
    BYTE bIndexType;
 
251
    DWORD nEntriesInUse;
 
252
    DWORD dwChunkId;
 
253
    DWORDLONG qwBaseOffset;
 
254
    DWORD dwReserved_3;
 
255
    AVITIMEDINDEX_ENTRY aIndex[ANYSIZE_ARRAY];
 
256
    /* DWORD adwTrailingFill[ANYSIZE_ARRAY]; */
 
257
} AVITIMEDINDEX;
 
258
 
 
259
typedef struct _avitimecodeindex {
 
260
    FOURCC fcc;
 
261
    UINT cb;
 
262
    WORD wLongsPerEntry;
 
263
    BYTE bIndexSubType;
 
264
    BYTE bIndexType;
 
265
    DWORD nEntriesInUse;
 
266
    DWORD dwChunkId;
 
267
    DWORD dwReserved[3];
 
268
    TIMECODEDATA aIndex[ANYSIZE_ARRAY];
 
269
} AVITIMECODEINDEX;
 
270
 
 
271
typedef struct _avitcdlindex_entryA {
 
272
    DWORD dwTick;
 
273
    TIMECODE time;
 
274
    DWORD dwSMPTEflags;
 
275
    DWORD dwUser;
 
276
    CHAR szReelId[12];
 
277
} AVITCDLINDEX_ENTRYA;
 
278
 
 
279
typedef struct _avitcdlindex_entryW {
 
280
    DWORD dwTick;
 
281
    TIMECODE time;
 
282
    DWORD dwSMPTEflags;
 
283
    DWORD dwUser;
 
284
    WCHAR szReelId[12];
 
285
} AVITCDLINDEX_ENTRYW;
 
286
 
 
287
typedef struct _avitcdlindexA {
 
288
    FOURCC fcc;
 
289
    UINT cb;
 
290
    WORD wLongsPerEntry;
 
291
    BYTE bIndexSubType;
 
292
    BYTE bIndexType;
 
293
    DWORD nEntriesInUse;
 
294
    DWORD dwChunkId;
 
295
    DWORD dwReserved[3];
 
296
    AVITCDLINDEX_ENTRYA aIndex[ANYSIZE_ARRAY];
 
297
    /* DWORD adwTrailingFill[ANYSIZE_ARRAY]; */
 
298
} AVITCDLINDEXA;
 
299
 
 
300
typedef struct _avitcdlindexW {
 
301
    FOURCC fcc;
 
302
    UINT cb;
 
303
    WORD wLongsPerEntry;
 
304
    BYTE bIndexSubType;
 
305
    BYTE bIndexType;
 
306
    DWORD nEntriesInUse;
 
307
    DWORD dwChunkId;
 
308
    DWORD dwReserved[3];
 
309
    AVITCDLINDEX_ENTRYW aIndex[ANYSIZE_ARRAY];
 
310
    /* DWORD adwTrailingFill[ANYSIZE_ARRAY]; */
 
311
} AVITCDLINDEXW;
 
312
 
 
313
#define AVITCDLINDEX_ENTRY WINELIB_NAME_AW(AVITCDLINDEX_ENTRY)
 
314
#define AVITCDLINDEX WINELIB_NAME_AW(AVITCDLINDEX)
 
315
 
 
316
typedef struct _avifieldindex_chunk {
 
317
    FOURCC fcc;
 
318
    DWORD cb;
 
319
    WORD wLongsPerEntry;
 
320
    BYTE bIndexSubType;
 
321
    BYTE bIndexType;
 
322
    DWORD nEntriesInUse;
 
323
    DWORD dwChunkId;
 
324
    DWORDLONG qwBaseOffset;
 
325
    DWORD dwReserved3;
 
326
    struct _avifieldindex_entry {
 
327
        DWORD dwOffset;
 
328
        DWORD dwSize;
 
329
        DWORD dwOffsetField2;
 
330
    } aIndex[ANYSIZE_ARRAY];
 
331
} AVIFIELDINDEX, * PAVIFIELDINDEX;
 
332
 
 
333
#include <poppack.h>