Commit | Line | Data |
---|---|---|
4c04e1fd | 1 | /* |
4f324b3a | 2 | * Copyright 2002 Michael Günnewig |
4c04e1fd MG |
3 | * |
4 | * This library is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU Lesser General Public | |
6 | * License as published by the Free Software Foundation; either | |
7 | * version 2.1 of the License, or (at your option) any later version. | |
8 | * | |
9 | * This library 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 GNU | |
12 | * Lesser General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU Lesser General Public | |
15 | * License along with this library; if not, write to the Free Software | |
360a3f91 | 16 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
4c04e1fd MG |
17 | */ |
18 | ||
19 | #include <assert.h> | |
e37c6e18 | 20 | #include <stdarg.h> |
4c04e1fd | 21 | |
e37c6e18 | 22 | #include "windef.h" |
4c04e1fd | 23 | #include "winbase.h" |
e37c6e18 | 24 | #include "wingdi.h" |
4c04e1fd MG |
25 | #include "winuser.h" |
26 | #include "winnls.h" | |
27 | #include "winerror.h" | |
4c04e1fd MG |
28 | #include "mmsystem.h" |
29 | #include "vfw.h" | |
45af4922 | 30 | #include "msacm.h" |
4c04e1fd MG |
31 | |
32 | #include "avifile_private.h" | |
33 | #include "extrachunk.h" | |
34 | ||
87bacf46 | 35 | #include "wine/unicode.h" |
4c04e1fd MG |
36 | #include "wine/debug.h" |
37 | ||
38 | WINE_DEFAULT_DEBUG_CHANNEL(avifile); | |
39 | ||
40 | /***********************************************************************/ | |
41 | ||
42 | #define formtypeWAVE mmioFOURCC('W','A','V','E') | |
43 | #define ckidWAVEFORMAT mmioFOURCC('f','m','t',' ') | |
44 | #define ckidWAVEFACT mmioFOURCC('f','a','c','t') | |
45 | #define ckidWAVEDATA mmioFOURCC('d','a','t','a') | |
46 | ||
47 | /***********************************************************************/ | |
48 | ||
645a36ce MG |
49 | #define ENDIAN_SWAPWORD(x) ((((x) >> 8) & 0xFF) | (((x) & 0xFF) << 8)) |
50 | #define ENDIAN_SWAPDWORD(x) (ENDIAN_SWAPWORD((x >> 16) & 0xFFFF) | \ | |
51 | ENDIAN_SWAPWORD(x & 0xFFFF) << 16) | |
52 | ||
53 | #ifdef WORDS_BIGENDIAN | |
54 | #define BE2H_WORD(x) (x) | |
55 | #define BE2H_DWORD(x) (x) | |
56 | #define LE2H_WORD(x) ENDIAN_SWAPWORD(x) | |
57 | #define LE2H_DWORD(x) ENDIAN_SWAPDWORD(x) | |
58 | #else | |
59 | #define BE2H_WORD(x) ENDIAN_SWAPWORD(x) | |
60 | #define BE2H_DWORD(x) ENDIAN_SWAPDWORD(x) | |
61 | #define LE2H_WORD(x) (x) | |
62 | #define LE2H_DWORD(x) (x) | |
63 | #endif | |
64 | ||
65 | typedef struct { | |
66 | FOURCC fccType; | |
67 | DWORD offset; | |
68 | DWORD size; | |
69 | INT encoding; | |
70 | DWORD sampleRate; | |
71 | DWORD channels; | |
72 | } SUNAUDIOHEADER; | |
73 | ||
74 | #define AU_ENCODING_ULAW_8 1 | |
75 | #define AU_ENCODING_PCM_8 2 | |
76 | #define AU_ENCODING_PCM_16 3 | |
77 | #define AU_ENCODING_PCM_24 4 | |
78 | #define AU_ENCODING_PCM_32 5 | |
79 | #define AU_ENCODING_FLOAT 6 | |
80 | #define AU_ENCODING_DOUBLE 7 | |
81 | #define AU_ENCODING_ADPCM_G721_32 23 | |
82 | #define AU_ENCODING_ADPCM_G722 24 | |
83 | #define AU_ENCODING_ADPCM_G723_24 25 | |
84 | #define AU_ENCODING_ADPCM_G723_5 26 | |
85 | #define AU_ENCODING_ALAW_8 27 | |
86 | ||
87 | /***********************************************************************/ | |
88 | ||
4c04e1fd MG |
89 | static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj); |
90 | static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface); | |
91 | static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface); | |
92 | static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size); | |
93 | static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam); | |
94 | static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi); | |
95 | static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size); | |
96 | static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size); | |
97 | static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface); | |
98 | static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam); | |
99 | ||
4625628e | 100 | static const struct IAVIFileVtbl iwavft = { |
4c04e1fd MG |
101 | IAVIFile_fnQueryInterface, |
102 | IAVIFile_fnAddRef, | |
103 | IAVIFile_fnRelease, | |
104 | IAVIFile_fnInfo, | |
105 | IAVIFile_fnGetStream, | |
106 | IAVIFile_fnCreateStream, | |
107 | IAVIFile_fnWriteData, | |
108 | IAVIFile_fnReadData, | |
109 | IAVIFile_fnEndRecord, | |
110 | IAVIFile_fnDeleteStream | |
111 | }; | |
112 | ||
113 | static HRESULT WINAPI IPersistFile_fnQueryInterface(IPersistFile*iface,REFIID refiid,LPVOID*obj); | |
114 | static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile*iface); | |
115 | static ULONG WINAPI IPersistFile_fnRelease(IPersistFile*iface); | |
116 | static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile*iface,CLSID*pClassID); | |
117 | static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile*iface); | |
118 | static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile*iface,LPCOLESTR pszFileName,DWORD dwMode); | |
119 | static HRESULT WINAPI IPersistFile_fnSave(IPersistFile*iface,LPCOLESTR pszFileName,BOOL fRemember); | |
120 | static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile*iface,LPCOLESTR pszFileName); | |
121 | static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile*iface,LPOLESTR*ppszFileName); | |
122 | ||
4625628e | 123 | static const struct IPersistFileVtbl iwavpft = { |
4c04e1fd MG |
124 | IPersistFile_fnQueryInterface, |
125 | IPersistFile_fnAddRef, | |
126 | IPersistFile_fnRelease, | |
127 | IPersistFile_fnGetClassID, | |
128 | IPersistFile_fnIsDirty, | |
129 | IPersistFile_fnLoad, | |
130 | IPersistFile_fnSave, | |
131 | IPersistFile_fnSaveCompleted, | |
132 | IPersistFile_fnGetCurFile | |
133 | }; | |
134 | ||
135 | static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj); | |
136 | static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface); | |
137 | static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface); | |
138 | static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2); | |
139 | static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size); | |
140 | static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags); | |
141 | static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize); | |
142 | static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize); | |
143 | static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread); | |
144 | static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten); | |
145 | static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples); | |
146 | static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread); | |
147 | static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size); | |
148 | static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen); | |
149 | ||
4625628e | 150 | static const struct IAVIStreamVtbl iwavst = { |
4c04e1fd MG |
151 | IAVIStream_fnQueryInterface, |
152 | IAVIStream_fnAddRef, | |
153 | IAVIStream_fnRelease, | |
154 | IAVIStream_fnCreate, | |
155 | IAVIStream_fnInfo, | |
156 | IAVIStream_fnFindSample, | |
157 | IAVIStream_fnReadFormat, | |
158 | IAVIStream_fnSetFormat, | |
159 | IAVIStream_fnRead, | |
160 | IAVIStream_fnWrite, | |
161 | IAVIStream_fnDelete, | |
162 | IAVIStream_fnReadData, | |
163 | IAVIStream_fnWriteData, | |
164 | IAVIStream_fnSetInfo | |
165 | }; | |
166 | ||
167 | typedef struct _IAVIFileImpl IAVIFileImpl; | |
168 | ||
169 | typedef struct _IPersistFileImpl { | |
170 | /* IUnknown stuff */ | |
4625628e | 171 | const IPersistFileVtbl *lpVtbl; |
4c04e1fd MG |
172 | |
173 | /* IPersistFile stuff */ | |
174 | IAVIFileImpl *paf; | |
175 | } IPersistFileImpl; | |
176 | ||
177 | typedef struct _IAVIStreamImpl { | |
178 | /* IUnknown stuff */ | |
4625628e | 179 | const IAVIStreamVtbl *lpVtbl; |
4c04e1fd MG |
180 | |
181 | /* IAVIStream stuff */ | |
182 | IAVIFileImpl *paf; | |
183 | } IAVIStreamImpl; | |
184 | ||
185 | struct _IAVIFileImpl { | |
186 | /* IUnknown stuff */ | |
4625628e | 187 | const IAVIFileVtbl *lpVtbl; |
723ee0a3 | 188 | LONG ref; |
4c04e1fd MG |
189 | |
190 | /* IAVIFile, IAVIStream stuff... */ | |
191 | IPersistFileImpl iPersistFile; | |
192 | IAVIStreamImpl iAVIStream; | |
193 | ||
194 | AVIFILEINFOW fInfo; | |
195 | AVISTREAMINFOW sInfo; | |
196 | ||
197 | LPWAVEFORMATEX lpFormat; | |
198 | LONG cbFormat; | |
199 | ||
200 | MMCKINFO ckData; | |
201 | ||
202 | EXTRACHUNKS extra; | |
203 | ||
204 | /* IPersistFile stuff ... */ | |
205 | HMMIO hmmio; | |
206 | LPWSTR szFileName; | |
207 | UINT uMode; | |
208 | BOOL fDirty; | |
209 | }; | |
210 | ||
211 | /***********************************************************************/ | |
212 | ||
213 | static HRESULT AVIFILE_LoadFile(IAVIFileImpl *This); | |
214 | static HRESULT AVIFILE_LoadSunFile(IAVIFileImpl *This); | |
b01c2c8a | 215 | static HRESULT AVIFILE_SaveFile(const IAVIFileImpl *This); |
4c04e1fd MG |
216 | |
217 | HRESULT AVIFILE_CreateWAVFile(REFIID riid, LPVOID *ppv) | |
218 | { | |
219 | IAVIFileImpl *pfile; | |
220 | HRESULT hr; | |
221 | ||
222 | assert(riid != NULL && ppv != NULL); | |
223 | ||
224 | *ppv = NULL; | |
225 | ||
aebc88d5 | 226 | pfile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIFileImpl)); |
4c04e1fd MG |
227 | if (pfile == NULL) |
228 | return AVIERR_MEMORY; | |
229 | ||
c2ebe1ff AJ |
230 | pfile->lpVtbl = &iwavft; |
231 | pfile->iPersistFile.lpVtbl = &iwavpft; | |
232 | pfile->iAVIStream.lpVtbl = &iwavst; | |
4c04e1fd MG |
233 | pfile->ref = 0; |
234 | pfile->iPersistFile.paf = pfile; | |
235 | pfile->iAVIStream.paf = pfile; | |
236 | ||
a8d2ba9d | 237 | hr = IAVIFile_QueryInterface((IAVIFile*)pfile, riid, ppv); |
4c04e1fd | 238 | if (FAILED(hr)) |
610fc08e | 239 | HeapFree(GetProcessHeap(), 0, pfile); |
4c04e1fd MG |
240 | |
241 | return hr; | |
242 | } | |
243 | ||
244 | static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile *iface, REFIID refiid, | |
245 | LPVOID *obj) | |
246 | { | |
39a696a1 | 247 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd MG |
248 | |
249 | TRACE("(%p,%s,%p)\n", This, debugstr_guid(refiid), obj); | |
250 | ||
251 | if (IsEqualGUID(&IID_IUnknown, refiid) || | |
252 | IsEqualGUID(&IID_IAVIFile, refiid)) { | |
253 | *obj = iface; | |
f884cf0d | 254 | IAVIFile_AddRef(iface); |
4c04e1fd MG |
255 | return S_OK; |
256 | } else if (This->fInfo.dwStreams == 1 && | |
257 | IsEqualGUID(&IID_IAVIStream, refiid)) { | |
258 | *obj = &This->iAVIStream; | |
f884cf0d | 259 | IAVIFile_AddRef(iface); |
4c04e1fd MG |
260 | return S_OK; |
261 | } else if (IsEqualGUID(&IID_IPersistFile, refiid)) { | |
262 | *obj = &This->iPersistFile; | |
f884cf0d | 263 | IAVIFile_AddRef(iface); |
4c04e1fd MG |
264 | return S_OK; |
265 | } | |
266 | ||
267 | return OLE_E_ENUM_NOMORE; | |
268 | } | |
269 | ||
270 | static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile *iface) | |
271 | { | |
39a696a1 | 272 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd MG |
273 | |
274 | TRACE("(%p)\n",iface); | |
275 | ||
c905d691 | 276 | return InterlockedIncrement(&This->ref); |
4c04e1fd MG |
277 | } |
278 | ||
279 | static ULONG WINAPI IAVIFile_fnRelease(IAVIFile *iface) | |
280 | { | |
39a696a1 | 281 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
c905d691 | 282 | ULONG ref = InterlockedDecrement(&This->ref); |
4c04e1fd MG |
283 | |
284 | TRACE("(%p)\n",iface); | |
285 | ||
c905d691 | 286 | if (!ref) { |
4c04e1fd MG |
287 | if (This->fDirty) { |
288 | /* need to write headers to file */ | |
289 | AVIFILE_SaveFile(This); | |
290 | } | |
291 | ||
292 | if (This->lpFormat != NULL) { | |
610fc08e | 293 | HeapFree(GetProcessHeap(), 0, This->lpFormat); |
4c04e1fd MG |
294 | This->lpFormat = NULL; |
295 | This->cbFormat = 0; | |
296 | } | |
297 | if (This->extra.lp != NULL) { | |
610fc08e | 298 | HeapFree(GetProcessHeap(), 0, This->extra.lp); |
4c04e1fd MG |
299 | This->extra.lp = NULL; |
300 | This->extra.cb = 0; | |
301 | } | |
fee72b60 MS |
302 | HeapFree(GetProcessHeap(), 0, This->szFileName); |
303 | This->szFileName = NULL; | |
d2667a4c | 304 | if (This->hmmio != NULL) { |
4c04e1fd | 305 | mmioClose(This->hmmio, 0); |
d2667a4c | 306 | This->hmmio = NULL; |
4c04e1fd MG |
307 | } |
308 | ||
610fc08e | 309 | HeapFree(GetProcessHeap(), 0, This); |
4c04e1fd MG |
310 | return 0; |
311 | } | |
c905d691 | 312 | return ref; |
4c04e1fd MG |
313 | } |
314 | ||
315 | static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile *iface, LPAVIFILEINFOW afi, | |
316 | LONG size) | |
317 | { | |
39a696a1 | 318 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd | 319 | |
f041a2b0 | 320 | TRACE("(%p,%p,%d)\n",iface,afi,size); |
4c04e1fd MG |
321 | |
322 | if (afi == NULL) | |
323 | return AVIERR_BADPARAM; | |
324 | if (size < 0) | |
325 | return AVIERR_BADSIZE; | |
326 | ||
327 | /* update file info */ | |
328 | This->fInfo.dwFlags = 0; | |
329 | This->fInfo.dwCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE; | |
330 | if (This->lpFormat != NULL) { | |
45af4922 MG |
331 | assert(This->sInfo.dwScale != 0); |
332 | ||
4c04e1fd MG |
333 | This->fInfo.dwStreams = 1; |
334 | This->fInfo.dwScale = This->sInfo.dwScale; | |
335 | This->fInfo.dwRate = This->sInfo.dwRate; | |
336 | This->fInfo.dwLength = This->sInfo.dwLength; | |
337 | This->fInfo.dwSuggestedBufferSize = This->ckData.cksize; | |
45af4922 MG |
338 | This->fInfo.dwMaxBytesPerSec = |
339 | MulDiv(This->sInfo.dwSampleSize,This->sInfo.dwRate,This->sInfo.dwScale); | |
4c04e1fd MG |
340 | } |
341 | ||
9f67cfef | 342 | memcpy(afi, &This->fInfo, min((DWORD)size, sizeof(This->fInfo))); |
4c04e1fd | 343 | |
9f67cfef | 344 | if ((DWORD)size < sizeof(This->fInfo)) |
4c04e1fd MG |
345 | return AVIERR_BUFFERTOOSMALL; |
346 | return AVIERR_OK; | |
347 | } | |
348 | ||
349 | static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile *iface, PAVISTREAM *avis, | |
350 | DWORD fccType, LONG lParam) | |
351 | { | |
39a696a1 | 352 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd | 353 | |
f041a2b0 | 354 | TRACE("(%p,%p,0x%08X,%d)\n", iface, avis, fccType, lParam); |
4c04e1fd MG |
355 | |
356 | /* check parameter */ | |
357 | if (avis == NULL) | |
358 | return AVIERR_BADPARAM; | |
359 | ||
360 | *avis = NULL; | |
361 | ||
362 | /* Does our stream exists? */ | |
363 | if (lParam != 0 || This->fInfo.dwStreams == 0) | |
364 | return AVIERR_NODATA; | |
365 | if (fccType != 0 && fccType != streamtypeAUDIO) | |
366 | return AVIERR_NODATA; | |
367 | ||
368 | *avis = (PAVISTREAM)&This->iAVIStream; | |
369 | IAVIFile_AddRef(iface); | |
370 | ||
371 | return AVIERR_OK; | |
372 | } | |
373 | ||
374 | static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile *iface,PAVISTREAM *avis, | |
375 | LPAVISTREAMINFOW asi) | |
376 | { | |
39a696a1 | 377 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd MG |
378 | |
379 | TRACE("(%p,%p,%p)\n", iface, avis, asi); | |
380 | ||
381 | /* check parameters */ | |
382 | if (avis == NULL || asi == NULL) | |
383 | return AVIERR_BADPARAM; | |
384 | ||
385 | *avis = NULL; | |
386 | ||
387 | /* We only support one audio stream */ | |
388 | if (This->fInfo.dwStreams != 0 || This->lpFormat != NULL) | |
389 | return AVIERR_UNSUPPORTED; | |
390 | if (asi->fccType != streamtypeAUDIO) | |
391 | return AVIERR_UNSUPPORTED; | |
392 | ||
393 | /* Does the user have write permission? */ | |
394 | if ((This->uMode & MMIO_RWMODE) == 0) | |
395 | return AVIERR_READONLY; | |
396 | ||
397 | This->cbFormat = 0; | |
398 | This->lpFormat = NULL; | |
399 | ||
400 | memcpy(&This->sInfo, asi, sizeof(This->sInfo)); | |
401 | ||
402 | /* make sure streaminfo if okay for us */ | |
403 | This->sInfo.fccHandler = 0; | |
404 | This->sInfo.dwFlags = 0; | |
405 | This->sInfo.dwCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE; | |
406 | This->sInfo.dwStart = 0; | |
407 | This->sInfo.dwInitialFrames = 0; | |
408 | This->sInfo.dwFormatChangeCount = 0; | |
409 | memset(&This->sInfo.rcFrame, 0, sizeof(This->sInfo.rcFrame)); | |
410 | ||
411 | This->fInfo.dwStreams = 1; | |
412 | This->fInfo.dwScale = This->sInfo.dwScale; | |
413 | This->fInfo.dwRate = This->sInfo.dwRate; | |
414 | This->fInfo.dwLength = This->sInfo.dwLength; | |
415 | ||
416 | This->ckData.dwDataOffset = 0; | |
417 | This->ckData.cksize = 0; | |
418 | ||
419 | *avis = (PAVISTREAM)&This->iAVIStream; | |
420 | IAVIFile_AddRef(iface); | |
421 | ||
422 | return AVIERR_OK; | |
423 | } | |
424 | ||
425 | static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile *iface, DWORD ckid, | |
426 | LPVOID lpData, LONG size) | |
427 | { | |
39a696a1 | 428 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd | 429 | |
f041a2b0 | 430 | TRACE("(%p,0x%08X,%p,%d)\n", iface, ckid, lpData, size); |
4c04e1fd MG |
431 | |
432 | /* check parameters */ | |
433 | if (lpData == NULL) | |
434 | return AVIERR_BADPARAM; | |
435 | if (size < 0) | |
436 | return AVIERR_BADSIZE; | |
437 | ||
438 | /* Do we have write permission? */ | |
439 | if ((This->uMode & MMIO_RWMODE) == 0) | |
440 | return AVIERR_READONLY; | |
441 | ||
442 | This->fDirty = TRUE; | |
443 | ||
444 | return WriteExtraChunk(&This->extra, ckid, lpData, size); | |
445 | } | |
446 | ||
447 | static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile *iface, DWORD ckid, | |
448 | LPVOID lpData, LONG *size) | |
449 | { | |
39a696a1 | 450 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd | 451 | |
f041a2b0 | 452 | TRACE("(%p,0x%08X,%p,%p)\n", iface, ckid, lpData, size); |
4c04e1fd MG |
453 | |
454 | return ReadExtraChunk(&This->extra, ckid, lpData, size); | |
455 | } | |
456 | ||
457 | static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile *iface) | |
458 | { | |
459 | TRACE("(%p)\n",iface); | |
460 | ||
461 | /* This is only needed for interleaved files. | |
462 | * We have only one stream, which can't be interleaved. | |
463 | */ | |
464 | return AVIERR_OK; | |
465 | } | |
466 | ||
467 | static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile *iface, DWORD fccType, | |
468 | LONG lParam) | |
469 | { | |
39a696a1 | 470 | IAVIFileImpl *This = (IAVIFileImpl *)iface; |
4c04e1fd | 471 | |
f041a2b0 | 472 | TRACE("(%p,0x%08X,%d)\n", iface, fccType, lParam); |
4c04e1fd MG |
473 | |
474 | /* check parameter */ | |
475 | if (lParam < 0) | |
476 | return AVIERR_BADPARAM; | |
477 | ||
6fb1a200 | 478 | /* Do we have our audio stream? */ |
4c04e1fd MG |
479 | if (lParam != 0 || This->fInfo.dwStreams == 0 || |
480 | (fccType != 0 && fccType != streamtypeAUDIO)) | |
481 | return AVIERR_NODATA; | |
482 | ||
483 | /* Have user write permissions? */ | |
484 | if ((This->uMode & MMIO_RWMODE) == 0) | |
485 | return AVIERR_READONLY; | |
486 | ||
610fc08e | 487 | HeapFree(GetProcessHeap(), 0, This->lpFormat); |
4c04e1fd MG |
488 | This->lpFormat = NULL; |
489 | This->cbFormat = 0; | |
490 | ||
491 | /* update infos */ | |
492 | This->ckData.dwDataOffset = 0; | |
493 | This->ckData.cksize = 0; | |
494 | ||
495 | This->sInfo.dwScale = 0; | |
496 | This->sInfo.dwRate = 0; | |
497 | This->sInfo.dwLength = 0; | |
498 | This->sInfo.dwSuggestedBufferSize = 0; | |
499 | ||
500 | This->fInfo.dwStreams = 0; | |
501 | This->fInfo.dwEditCount++; | |
502 | ||
503 | This->fDirty = TRUE; | |
504 | ||
505 | return AVIERR_OK; | |
506 | } | |
507 | ||
508 | /***********************************************************************/ | |
509 | ||
510 | static HRESULT WINAPI IPersistFile_fnQueryInterface(IPersistFile *iface, | |
511 | REFIID refiid, LPVOID *obj) | |
512 | { | |
39a696a1 | 513 | IPersistFileImpl *This = (IPersistFileImpl *)iface; |
4c04e1fd MG |
514 | |
515 | assert(This->paf != NULL); | |
516 | ||
517 | return IAVIFile_QueryInterface((PAVIFILE)This->paf, refiid, obj); | |
518 | } | |
519 | ||
520 | static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile *iface) | |
521 | { | |
39a696a1 | 522 | IPersistFileImpl *This = (IPersistFileImpl *)iface; |
4c04e1fd MG |
523 | |
524 | assert(This->paf != NULL); | |
525 | ||
526 | return IAVIFile_AddRef((PAVIFILE)This->paf); | |
527 | } | |
528 | ||
529 | static ULONG WINAPI IPersistFile_fnRelease(IPersistFile *iface) | |
530 | { | |
39a696a1 | 531 | IPersistFileImpl *This = (IPersistFileImpl *)iface; |
4c04e1fd MG |
532 | |
533 | assert(This->paf != NULL); | |
534 | ||
535 | return IAVIFile_Release((PAVIFILE)This->paf); | |
536 | } | |
537 | ||
538 | static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile *iface, | |
539 | LPCLSID pClassID) | |
540 | { | |
541 | TRACE("(%p,%p)\n", iface, pClassID); | |
542 | ||
543 | if (pClassID == NULL) | |
544 | return AVIERR_BADPARAM; | |
545 | ||
292fd135 | 546 | *pClassID = CLSID_WAVFile; |
4c04e1fd MG |
547 | |
548 | return AVIERR_OK; | |
549 | } | |
550 | ||
551 | static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile *iface) | |
552 | { | |
39a696a1 | 553 | IPersistFileImpl *This = (IPersistFileImpl *)iface; |
4c04e1fd MG |
554 | |
555 | TRACE("(%p)\n", iface); | |
556 | ||
557 | assert(This->paf != NULL); | |
558 | ||
559 | return (This->paf->fDirty ? S_OK : S_FALSE); | |
560 | } | |
561 | ||
562 | static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile *iface, | |
563 | LPCOLESTR pszFileName, DWORD dwMode) | |
564 | { | |
565 | IAVIFileImpl *This = ((IPersistFileImpl*)iface)->paf; | |
566 | ||
567 | WCHAR wszStreamFmt[50]; | |
568 | INT len; | |
569 | ||
f041a2b0 | 570 | TRACE("(%p,%s,0x%08X)\n", iface, debugstr_w(pszFileName), dwMode); |
4c04e1fd MG |
571 | |
572 | /* check parameter */ | |
573 | if (pszFileName == NULL) | |
574 | return AVIERR_BADPARAM; | |
575 | ||
576 | assert(This != NULL); | |
d2667a4c | 577 | if (This->hmmio != NULL) |
4c04e1fd MG |
578 | return AVIERR_ERROR; /* No reuse of this object for another file! */ |
579 | ||
f6caf1be | 580 | /* remember mode and name */ |
4c04e1fd MG |
581 | This->uMode = dwMode; |
582 | ||
583 | len = lstrlenW(pszFileName) + 1; | |
610fc08e | 584 | This->szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
4c04e1fd MG |
585 | if (This->szFileName == NULL) |
586 | return AVIERR_MEMORY; | |
587 | lstrcpyW(This->szFileName, pszFileName); | |
588 | ||
589 | /* try to open the file */ | |
590 | This->hmmio = mmioOpenW(This->szFileName, NULL, MMIO_ALLOCBUF | dwMode); | |
645a36ce MG |
591 | if (This->hmmio == NULL) { |
592 | /* mmioOpenW not in native DLLs of Win9x -- try mmioOpenA */ | |
87bacf46 MM |
593 | LPSTR szFileName; |
594 | len = WideCharToMultiByte(CP_ACP, 0, This->szFileName, -1, | |
595 | NULL, 0, NULL, NULL); | |
610fc08e | 596 | szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR)); |
645a36ce MG |
597 | if (szFileName == NULL) |
598 | return AVIERR_MEMORY; | |
599 | ||
600 | WideCharToMultiByte(CP_ACP, 0, This->szFileName, -1, szFileName, | |
601 | len, NULL, NULL); | |
602 | ||
603 | This->hmmio = mmioOpenA(szFileName, NULL, MMIO_ALLOCBUF | dwMode); | |
610fc08e | 604 | HeapFree(GetProcessHeap(), 0, szFileName); |
645a36ce MG |
605 | if (This->hmmio == NULL) |
606 | return AVIERR_FILEOPEN; | |
607 | } | |
4c04e1fd MG |
608 | |
609 | memset(& This->fInfo, 0, sizeof(This->fInfo)); | |
610 | memset(& This->sInfo, 0, sizeof(This->sInfo)); | |
611 | ||
612 | LoadStringW(AVIFILE_hModule, IDS_WAVEFILETYPE, This->fInfo.szFileType, | |
89a2eab3 | 613 | sizeof(This->fInfo.szFileType)/sizeof(This->fInfo.szFileType[0])); |
4c04e1fd | 614 | if (LoadStringW(AVIFILE_hModule, IDS_WAVESTREAMFORMAT, |
89a2eab3 | 615 | wszStreamFmt, sizeof(wszStreamFmt)/sizeof(wszStreamFmt[0])) > 0) { |
4c04e1fd MG |
616 | wsprintfW(This->sInfo.szName, wszStreamFmt, |
617 | AVIFILE_BasenameW(This->szFileName)); | |
618 | } | |
619 | ||
620 | /* should we create a new file? */ | |
621 | if (dwMode & OF_CREATE) { | |
622 | /* nothing more to do */ | |
623 | return AVIERR_OK; | |
624 | } else | |
625 | return AVIFILE_LoadFile(This); | |
626 | } | |
627 | ||
628 | static HRESULT WINAPI IPersistFile_fnSave(IPersistFile *iface, | |
629 | LPCOLESTR pszFileName,BOOL fRemember) | |
630 | { | |
631 | TRACE("(%p,%s,%d)\n", iface, debugstr_w(pszFileName), fRemember); | |
632 | ||
633 | /* We write directly to disk, so nothing to do. */ | |
634 | ||
635 | return AVIERR_OK; | |
636 | } | |
637 | ||
638 | static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile *iface, | |
639 | LPCOLESTR pszFileName) | |
640 | { | |
641 | TRACE("(%p,%s)\n", iface, debugstr_w(pszFileName)); | |
642 | ||
643 | /* We write directly to disk, so nothing to do. */ | |
644 | ||
645 | return AVIERR_OK; | |
646 | } | |
647 | ||
648 | static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile *iface, | |
649 | LPOLESTR *ppszFileName) | |
650 | { | |
39a696a1 | 651 | IPersistFileImpl *This = (IPersistFileImpl *)iface; |
4c04e1fd MG |
652 | |
653 | TRACE("(%p,%p)\n", iface, ppszFileName); | |
654 | ||
655 | if (ppszFileName == NULL) | |
656 | return AVIERR_BADPARAM; | |
657 | ||
658 | *ppszFileName = NULL; | |
659 | ||
660 | assert(This->paf != NULL); | |
661 | ||
662 | if (This->paf->szFileName != NULL) { | |
87bacf46 | 663 | int len = lstrlenW(This->paf->szFileName) + 1; |
4c04e1fd | 664 | |
29212d8a | 665 | *ppszFileName = CoTaskMemAlloc(len * sizeof(WCHAR)); |
4c04e1fd MG |
666 | if (*ppszFileName == NULL) |
667 | return AVIERR_MEMORY; | |
668 | ||
87bacf46 | 669 | strcpyW(*ppszFileName, This->paf->szFileName); |
4c04e1fd MG |
670 | } |
671 | ||
672 | return AVIERR_OK; | |
673 | } | |
674 | ||
675 | /***********************************************************************/ | |
676 | ||
677 | static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream *iface, | |
678 | REFIID refiid, LPVOID *obj) | |
679 | { | |
39a696a1 | 680 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd MG |
681 | |
682 | assert(This->paf != NULL); | |
683 | ||
684 | return IAVIFile_QueryInterface((PAVIFILE)This->paf, refiid, obj); | |
685 | } | |
686 | ||
687 | static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream *iface) | |
688 | { | |
39a696a1 | 689 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd MG |
690 | |
691 | assert(This->paf != NULL); | |
692 | ||
693 | return IAVIFile_AddRef((PAVIFILE)This->paf); | |
694 | } | |
695 | ||
696 | static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) | |
697 | { | |
39a696a1 | 698 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd MG |
699 | |
700 | assert(This->paf != NULL); | |
701 | ||
702 | return IAVIFile_Release((PAVIFILE)This->paf); | |
703 | } | |
704 | ||
705 | static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream *iface, LPARAM lParam1, | |
706 | LPARAM lParam2) | |
707 | { | |
708 | TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2); | |
709 | ||
710 | /* This IAVIStream interface needs an WAVFile */ | |
711 | return AVIERR_UNSUPPORTED; | |
712 | } | |
713 | ||
714 | static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi, | |
715 | LONG size) | |
716 | { | |
39a696a1 | 717 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd | 718 | |
f041a2b0 | 719 | TRACE("(%p,%p,%d)\n", iface, psi, size); |
4c04e1fd MG |
720 | |
721 | if (psi == NULL) | |
722 | return AVIERR_BADPARAM; | |
723 | if (size < 0) | |
724 | return AVIERR_BADSIZE; | |
725 | ||
9f67cfef | 726 | memcpy(psi, &This->paf->sInfo, min((DWORD)size, sizeof(This->paf->sInfo))); |
4c04e1fd | 727 | |
9f67cfef | 728 | if ((DWORD)size < sizeof(This->paf->sInfo)) |
4c04e1fd MG |
729 | return AVIERR_BUFFERTOOSMALL; |
730 | return AVIERR_OK; | |
731 | } | |
732 | ||
733 | static LONG WINAPI IAVIStream_fnFindSample(IAVIStream *iface, LONG pos, | |
734 | LONG flags) | |
735 | { | |
736 | IAVIFileImpl *This = ((IAVIStreamImpl*)iface)->paf; | |
737 | ||
f041a2b0 | 738 | TRACE("(%p,%d,0x%08X)\n",iface,pos,flags); |
4c04e1fd MG |
739 | |
740 | /* Do we have data? */ | |
741 | if (This->lpFormat == NULL) | |
742 | return -1; | |
743 | ||
744 | /* We don't have an index */ | |
745 | if (flags & FIND_INDEX) | |
746 | return -1; | |
747 | ||
748 | if (flags & FIND_FROM_START) { | |
749 | pos = This->sInfo.dwStart; | |
750 | flags &= ~(FIND_FROM_START|FIND_PREV); | |
751 | flags |= FIND_NEXT; | |
752 | } | |
753 | ||
754 | if (flags & FIND_FORMAT) { | |
755 | if ((flags & FIND_NEXT) && pos > 0) | |
756 | pos = -1; | |
757 | else | |
758 | pos = 0; | |
759 | } | |
760 | ||
edd8bc3a MG |
761 | if ((flags & FIND_RET) == FIND_LENGTH || |
762 | (flags & FIND_RET) == FIND_SIZE) | |
4c04e1fd | 763 | return This->sInfo.dwSampleSize; |
edd8bc3a | 764 | if ((flags & FIND_RET) == FIND_OFFSET) |
4c04e1fd MG |
765 | return This->ckData.dwDataOffset + pos * This->sInfo.dwSampleSize; |
766 | ||
767 | return pos; | |
768 | } | |
769 | ||
770 | static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream *iface, LONG pos, | |
771 | LPVOID format, LONG *formatsize) | |
772 | { | |
39a696a1 | 773 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd | 774 | |
f041a2b0 | 775 | TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize); |
4c04e1fd MG |
776 | |
777 | if (formatsize == NULL) | |
778 | return AVIERR_BADPARAM; | |
779 | ||
780 | /* only interested in needed buffersize? */ | |
781 | if (format == NULL || *formatsize <= 0) { | |
782 | *formatsize = This->paf->cbFormat; | |
783 | ||
784 | return AVIERR_OK; | |
785 | } | |
786 | ||
787 | /* copy initial format (only as much as will fit) */ | |
788 | memcpy(format, This->paf->lpFormat, min(*formatsize, This->paf->cbFormat)); | |
789 | if (*formatsize < This->paf->cbFormat) { | |
790 | *formatsize = This->paf->cbFormat; | |
791 | return AVIERR_BUFFERTOOSMALL; | |
792 | } | |
793 | ||
794 | *formatsize = This->paf->cbFormat; | |
795 | return AVIERR_OK; | |
796 | } | |
797 | ||
798 | static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream *iface, LONG pos, | |
799 | LPVOID format, LONG formatsize) | |
800 | { | |
801 | IAVIFileImpl *This = ((IAVIStreamImpl*)iface)->paf; | |
802 | ||
f041a2b0 | 803 | TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize); |
4c04e1fd MG |
804 | |
805 | /* check parameters */ | |
806 | if (format == NULL || formatsize <= sizeof(PCMWAVEFORMAT)) | |
807 | return AVIERR_BADPARAM; | |
808 | ||
809 | /* We can only do this to an empty wave file, but ignore call | |
810 | * if still same format */ | |
811 | if (This->lpFormat != NULL) { | |
812 | if (formatsize != This->cbFormat || | |
813 | memcmp(format, This->lpFormat, formatsize) != 0) | |
814 | return AVIERR_UNSUPPORTED; | |
815 | ||
816 | return AVIERR_OK; | |
817 | } | |
818 | ||
819 | /* only support start at position 0 */ | |
820 | if (pos != 0) | |
821 | return AVIERR_UNSUPPORTED; | |
822 | ||
823 | /* Do we have write permission? */ | |
824 | if ((This->uMode & MMIO_RWMODE) == 0) | |
825 | return AVIERR_READONLY; | |
826 | ||
827 | /* get memory for format and copy it */ | |
610fc08e | 828 | This->lpFormat = HeapAlloc(GetProcessHeap(), 0, formatsize); |
4c04e1fd MG |
829 | if (This->lpFormat == NULL) |
830 | return AVIERR_MEMORY; | |
831 | ||
832 | This->cbFormat = formatsize; | |
833 | memcpy(This->lpFormat, format, formatsize); | |
834 | ||
835 | /* update info's about 'data' chunk */ | |
836 | This->ckData.dwDataOffset = formatsize + 7 * sizeof(DWORD); | |
837 | This->ckData.cksize = 0; | |
838 | ||
839 | /* for non-pcm format we need also a 'fact' chunk */ | |
840 | if (This->lpFormat->wFormatTag != WAVE_FORMAT_PCM) | |
841 | This->ckData.dwDataOffset += 3 * sizeof(DWORD); | |
842 | ||
843 | /* update stream and file info */ | |
844 | This->sInfo.dwSampleSize = This->lpFormat->nBlockAlign; | |
845 | This->sInfo.dwScale = This->lpFormat->nBlockAlign; | |
846 | This->sInfo.dwRate = This->lpFormat->nAvgBytesPerSec; | |
847 | This->sInfo.dwLength = 0; | |
848 | This->sInfo.dwSuggestedBufferSize = 0; | |
849 | ||
850 | return AVIERR_OK; | |
851 | } | |
852 | ||
853 | static HRESULT WINAPI IAVIStream_fnRead(IAVIStream *iface, LONG start, | |
854 | LONG samples, LPVOID buffer, | |
855 | LONG buffersize, LPLONG bytesread, | |
856 | LPLONG samplesread) | |
857 | { | |
858 | IAVIFileImpl *This = ((IAVIStreamImpl*)iface)->paf; | |
859 | ||
f041a2b0 | 860 | TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer, |
4c04e1fd MG |
861 | buffersize, bytesread, samplesread); |
862 | ||
863 | /* clear return parameters if given */ | |
864 | if (bytesread != NULL) | |
865 | *bytesread = 0; | |
866 | if (samplesread != NULL) | |
867 | *samplesread = 0; | |
868 | ||
869 | /* positions without data */ | |
9f67cfef | 870 | if (start < 0 || (DWORD)start > This->sInfo.dwLength) |
4c04e1fd MG |
871 | return AVIERR_OK; |
872 | ||
873 | /* check samples */ | |
874 | if (samples < 0) | |
875 | samples = 0; | |
876 | if (buffersize > 0) { | |
877 | if (samples > 0) | |
9f67cfef | 878 | samples = min((DWORD)samples, buffersize / This->sInfo.dwSampleSize); |
4c04e1fd MG |
879 | else |
880 | samples = buffersize / This->sInfo.dwSampleSize; | |
881 | } | |
882 | ||
883 | /* limit to end of stream */ | |
9f67cfef | 884 | if ((DWORD)(start + samples) > This->sInfo.dwLength) |
4c04e1fd MG |
885 | samples = This->sInfo.dwLength - start; |
886 | ||
887 | /* request only the sizes? */ | |
888 | if (buffer == NULL || buffersize <= 0) { | |
6fb1a200 | 889 | /* then I need at least one parameter for it */ |
4c04e1fd MG |
890 | if (bytesread == NULL && samplesread == NULL) |
891 | return AVIERR_BADPARAM; | |
892 | ||
893 | if (bytesread != NULL) | |
894 | *bytesread = samples * This->sInfo.dwSampleSize; | |
895 | if (samplesread != NULL) | |
896 | *samplesread = samples; | |
897 | ||
898 | return AVIERR_OK; | |
899 | } | |
900 | ||
901 | /* nothing to read? */ | |
902 | if (samples == 0) | |
903 | return AVIERR_OK; | |
904 | ||
6fb1a200 | 905 | /* Can I read at least one sample? */ |
9f67cfef | 906 | if ((DWORD)buffersize < This->sInfo.dwSampleSize) |
4c04e1fd MG |
907 | return AVIERR_BUFFERTOOSMALL; |
908 | ||
909 | buffersize = samples * This->sInfo.dwSampleSize; | |
910 | ||
911 | if (mmioSeek(This->hmmio, This->ckData.dwDataOffset | |
912 | + start * This->sInfo.dwSampleSize, SEEK_SET) == -1) | |
913 | return AVIERR_FILEREAD; | |
905ff8fd | 914 | if (mmioRead(This->hmmio, buffer, buffersize) != buffersize) |
4c04e1fd MG |
915 | return AVIERR_FILEREAD; |
916 | ||
917 | /* fill out return parameters if given */ | |
918 | if (bytesread != NULL) | |
919 | *bytesread = buffersize; | |
920 | if (samplesread != NULL) | |
921 | *samplesread = samples; | |
922 | ||
923 | return AVIERR_OK; | |
924 | } | |
925 | ||
926 | static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream *iface, LONG start, | |
927 | LONG samples, LPVOID buffer, | |
928 | LONG buffersize, DWORD flags, | |
929 | LPLONG sampwritten, | |
930 | LPLONG byteswritten) | |
931 | { | |
932 | IAVIFileImpl *This = ((IAVIStreamImpl*)iface)->paf; | |
933 | ||
f041a2b0 | 934 | TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples, |
4c04e1fd MG |
935 | buffer, buffersize, flags, sampwritten, byteswritten); |
936 | ||
937 | /* clear return parameters if given */ | |
938 | if (sampwritten != NULL) | |
939 | *sampwritten = 0; | |
940 | if (byteswritten != NULL) | |
941 | *byteswritten = 0; | |
942 | ||
943 | /* check parameters */ | |
944 | if (buffer == NULL && (buffersize > 0 || samples > 0)) | |
945 | return AVIERR_BADPARAM; | |
946 | ||
6fb1a200 | 947 | /* Do we have write permission? */ |
4c04e1fd MG |
948 | if ((This->uMode & MMIO_RWMODE) == 0) |
949 | return AVIERR_READONLY; | |
950 | ||
951 | /* < 0 means "append" */ | |
952 | if (start < 0) | |
953 | start = This->sInfo.dwStart + This->sInfo.dwLength; | |
954 | ||
955 | /* check buffersize -- must multiple of samplesize */ | |
956 | if (buffersize & ~(This->sInfo.dwSampleSize - 1)) | |
957 | return AVIERR_BADSIZE; | |
958 | ||
6fb1a200 | 959 | /* do we have anything to write? */ |
4c04e1fd MG |
960 | if (buffer != NULL && buffersize > 0) { |
961 | This->fDirty = 1; | |
962 | ||
963 | if (mmioSeek(This->hmmio, This->ckData.dwDataOffset + | |
964 | start * This->sInfo.dwSampleSize, SEEK_SET) == -1) | |
965 | return AVIERR_FILEWRITE; | |
905ff8fd | 966 | if (mmioWrite(This->hmmio, buffer, buffersize) != buffersize) |
4c04e1fd MG |
967 | return AVIERR_FILEWRITE; |
968 | ||
9f67cfef | 969 | This->sInfo.dwLength = max(This->sInfo.dwLength, (DWORD)start + samples); |
4c04e1fd MG |
970 | This->ckData.cksize = max(This->ckData.cksize, |
971 | start * This->sInfo.dwSampleSize + buffersize); | |
972 | ||
973 | /* fill out return parameters if given */ | |
974 | if (sampwritten != NULL) | |
975 | *sampwritten = samples; | |
976 | if (byteswritten != NULL) | |
977 | *byteswritten = buffersize; | |
978 | } | |
979 | ||
980 | return AVIERR_OK; | |
981 | } | |
982 | ||
983 | static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream *iface, LONG start, | |
984 | LONG samples) | |
985 | { | |
986 | IAVIFileImpl *This = ((IAVIStreamImpl*)iface)->paf; | |
987 | ||
f041a2b0 | 988 | TRACE("(%p,%d,%d)\n", iface, start, samples); |
4c04e1fd MG |
989 | |
990 | /* check parameters */ | |
991 | if (start < 0 || samples < 0) | |
992 | return AVIERR_BADPARAM; | |
993 | ||
994 | /* Delete before start of stream? */ | |
9f67cfef | 995 | if ((DWORD)(start + samples) < This->sInfo.dwStart) |
4c04e1fd MG |
996 | return AVIERR_OK; |
997 | ||
998 | /* Delete after end of stream? */ | |
9f67cfef | 999 | if ((DWORD)start > This->sInfo.dwLength) |
4c04e1fd MG |
1000 | return AVIERR_OK; |
1001 | ||
1002 | /* For the rest we need write permissions */ | |
1003 | if ((This->uMode & MMIO_RWMODE) == 0) | |
1004 | return AVIERR_READONLY; | |
1005 | ||
9f67cfef | 1006 | if ((DWORD)(start + samples) >= This->sInfo.dwLength) { |
4c04e1fd MG |
1007 | /* deletion at end */ |
1008 | samples = This->sInfo.dwLength - start; | |
1009 | This->sInfo.dwLength -= samples; | |
1010 | This->ckData.cksize -= samples * This->sInfo.dwSampleSize; | |
9f67cfef | 1011 | } else if ((DWORD)start <= This->sInfo.dwStart) { |
4c04e1fd MG |
1012 | /* deletion at start */ |
1013 | samples = This->sInfo.dwStart - start; | |
1014 | start = This->sInfo.dwStart; | |
1015 | This->ckData.dwDataOffset += samples * This->sInfo.dwSampleSize; | |
1016 | This->ckData.cksize -= samples * This->sInfo.dwSampleSize; | |
1017 | } else { | |
1018 | /* deletion inside stream -- needs playlist and cue's */ | |
1019 | FIXME(": deletion inside of stream not supported!\n"); | |
1020 | ||
1021 | return AVIERR_UNSUPPORTED; | |
1022 | } | |
1023 | ||
1024 | This->fDirty = 1; | |
1025 | ||
1026 | return AVIERR_OK; | |
1027 | } | |
1028 | ||
1029 | static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream *iface, DWORD fcc, | |
1030 | LPVOID lp, LPLONG lpread) | |
1031 | { | |
39a696a1 | 1032 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd MG |
1033 | |
1034 | assert(This->paf != NULL); | |
1035 | ||
1036 | return IAVIFile_ReadData((PAVIFILE)This->paf, fcc, lp, lpread); | |
1037 | } | |
1038 | ||
1039 | static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream *iface, DWORD fcc, | |
1040 | LPVOID lp, LONG size) | |
1041 | { | |
39a696a1 | 1042 | IAVIStreamImpl *This = (IAVIStreamImpl *)iface; |
4c04e1fd MG |
1043 | |
1044 | return IAVIFile_WriteData((PAVIFILE)This->paf, fcc, lp, size); | |
1045 | } | |
1046 | ||
1047 | static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream *iface, | |
1048 | LPAVISTREAMINFOW info, LONG infolen) | |
1049 | { | |
f041a2b0 | 1050 | FIXME("(%p,%p,%d): stub\n", iface, info, infolen); |
4c04e1fd MG |
1051 | |
1052 | return E_FAIL; | |
1053 | } | |
1054 | ||
1055 | /***********************************************************************/ | |
1056 | ||
1057 | static HRESULT AVIFILE_LoadFile(IAVIFileImpl *This) | |
1058 | { | |
1059 | MMCKINFO ckRIFF; | |
1060 | MMCKINFO ck; | |
1061 | ||
1062 | This->sInfo.dwLength = 0; /* just to be sure */ | |
1063 | This->fDirty = FALSE; | |
1064 | ||
1065 | /* search for RIFF chunk */ | |
45af4922 | 1066 | ckRIFF.fccType = 0; /* find any */ |
4c04e1fd MG |
1067 | if (mmioDescend(This->hmmio, &ckRIFF, NULL, MMIO_FINDRIFF) != S_OK) { |
1068 | return AVIFILE_LoadSunFile(This); | |
1069 | } | |
1070 | ||
1071 | if (ckRIFF.fccType != formtypeWAVE) | |
1072 | return AVIERR_BADFORMAT; | |
1073 | ||
1074 | /* search WAVE format chunk */ | |
1075 | ck.ckid = ckidWAVEFORMAT; | |
1076 | if (FindChunkAndKeepExtras(&This->extra, This->hmmio, &ck, | |
45af4922 | 1077 | &ckRIFF, MMIO_FINDCHUNK) != S_OK) |
4c04e1fd MG |
1078 | return AVIERR_FILEREAD; |
1079 | ||
1080 | /* get memory for format and read it */ | |
610fc08e | 1081 | This->lpFormat = HeapAlloc(GetProcessHeap(), 0, ck.cksize); |
4c04e1fd MG |
1082 | if (This->lpFormat == NULL) |
1083 | return AVIERR_FILEREAD; | |
1084 | This->cbFormat = ck.cksize; | |
1085 | ||
1086 | if (mmioRead(This->hmmio, (HPSTR)This->lpFormat, ck.cksize) != ck.cksize) | |
1087 | return AVIERR_FILEREAD; | |
1088 | if (mmioAscend(This->hmmio, &ck, 0) != S_OK) | |
1089 | return AVIERR_FILEREAD; | |
1090 | ||
45af4922 MG |
1091 | /* Non-pcm formats have a fact chunk. |
1092 | * We don't need it, so simply add it to the extra chunks. | |
1093 | */ | |
4c04e1fd MG |
1094 | |
1095 | /* find the big data chunk */ | |
1096 | This->ckData.ckid = ckidWAVEDATA; | |
1097 | if (FindChunkAndKeepExtras(&This->extra, This->hmmio, &This->ckData, | |
1098 | &ckRIFF, MMIO_FINDCHUNK) != S_OK) | |
1099 | return AVIERR_FILEREAD; | |
1100 | ||
1101 | memset(&This->sInfo, 0, sizeof(This->sInfo)); | |
1102 | This->sInfo.fccType = streamtypeAUDIO; | |
1103 | This->sInfo.dwRate = This->lpFormat->nAvgBytesPerSec; | |
1104 | This->sInfo.dwSampleSize = | |
1105 | This->sInfo.dwScale = This->lpFormat->nBlockAlign; | |
1106 | This->sInfo.dwLength = This->ckData.cksize / This->lpFormat->nBlockAlign; | |
1107 | This->sInfo.dwSuggestedBufferSize = This->ckData.cksize; | |
1108 | ||
45af4922 MG |
1109 | This->fInfo.dwStreams = 1; |
1110 | ||
4c04e1fd MG |
1111 | if (mmioAscend(This->hmmio, &This->ckData, 0) != S_OK) { |
1112 | /* seems to be truncated */ | |
1113 | WARN(": file seems to be truncated!\n"); | |
1114 | This->ckData.cksize = mmioSeek(This->hmmio, 0, SEEK_END) - | |
1115 | This->ckData.dwDataOffset; | |
1116 | This->sInfo.dwLength = This->ckData.cksize / This->lpFormat->nBlockAlign; | |
1117 | This->sInfo.dwSuggestedBufferSize = This->ckData.cksize; | |
1118 | } | |
1119 | ||
1120 | /* ignore errors */ | |
1121 | FindChunkAndKeepExtras(&This->extra, This->hmmio, &ck, &ckRIFF, 0); | |
1122 | ||
1123 | return AVIERR_OK; | |
1124 | } | |
1125 | ||
1126 | static HRESULT AVIFILE_LoadSunFile(IAVIFileImpl *This) | |
1127 | { | |
645a36ce | 1128 | SUNAUDIOHEADER auhdr; |
4c04e1fd | 1129 | |
645a36ce MG |
1130 | mmioSeek(This->hmmio, 0, SEEK_SET); |
1131 | if (mmioRead(This->hmmio, (HPSTR)&auhdr, sizeof(auhdr)) != sizeof(auhdr)) | |
1132 | return AVIERR_FILEREAD; | |
1133 | ||
1134 | if (auhdr.fccType == 0x0064732E) { | |
1135 | /* header in little endian */ | |
1136 | This->ckData.dwDataOffset = LE2H_DWORD(auhdr.offset); | |
1137 | This->ckData.cksize = LE2H_DWORD(auhdr.size); | |
1138 | ||
1139 | auhdr.encoding = LE2H_DWORD(auhdr.encoding); | |
1140 | auhdr.sampleRate = LE2H_DWORD(auhdr.sampleRate); | |
1141 | auhdr.channels = LE2H_DWORD(auhdr.channels); | |
1142 | } else if (auhdr.fccType == mmioFOURCC('.','s','n','d')) { | |
1143 | /* header in big endian */ | |
1144 | This->ckData.dwDataOffset = BE2H_DWORD(auhdr.offset); | |
1145 | This->ckData.cksize = BE2H_DWORD(auhdr.size); | |
1146 | ||
1147 | auhdr.encoding = BE2H_DWORD(auhdr.encoding); | |
1148 | auhdr.sampleRate = BE2H_DWORD(auhdr.sampleRate); | |
1149 | auhdr.channels = BE2H_DWORD(auhdr.channels); | |
1150 | } else | |
1151 | return AVIERR_FILEREAD; | |
1152 | ||
1153 | if (auhdr.channels < 1) | |
1154 | return AVIERR_BADFORMAT; | |
1155 | ||
1156 | /* get size of header */ | |
1157 | switch(auhdr.encoding) { | |
1158 | case AU_ENCODING_ADPCM_G721_32: | |
1159 | This->cbFormat = sizeof(G721_ADPCMWAVEFORMAT); break; | |
1160 | case AU_ENCODING_ADPCM_G723_24: | |
1161 | This->cbFormat = sizeof(G723_ADPCMWAVEFORMAT); break; | |
1162 | case AU_ENCODING_ADPCM_G722: | |
1163 | case AU_ENCODING_ADPCM_G723_5: | |
1164 | WARN("unsupported Sun audio format %d\n", auhdr.encoding); | |
1165 | return AVIERR_UNSUPPORTED; /* FIXME */ | |
1166 | default: | |
1167 | This->cbFormat = sizeof(WAVEFORMATEX); break; | |
1168 | }; | |
1169 | ||
610fc08e | 1170 | This->lpFormat = HeapAlloc(GetProcessHeap(), 0, This->cbFormat); |
645a36ce MG |
1171 | if (This->lpFormat == NULL) |
1172 | return AVIERR_MEMORY; | |
1173 | ||
1174 | This->lpFormat->nChannels = auhdr.channels; | |
1175 | This->lpFormat->nSamplesPerSec = auhdr.sampleRate; | |
1176 | switch(auhdr.encoding) { | |
1177 | case AU_ENCODING_ULAW_8: | |
1178 | This->lpFormat->wFormatTag = WAVE_FORMAT_MULAW; | |
1179 | This->lpFormat->wBitsPerSample = 8; | |
1180 | break; | |
1181 | case AU_ENCODING_PCM_8: | |
1182 | This->lpFormat->wFormatTag = WAVE_FORMAT_PCM; | |
1183 | This->lpFormat->wBitsPerSample = 8; | |
1184 | break; | |
1185 | case AU_ENCODING_PCM_16: | |
1186 | This->lpFormat->wFormatTag = WAVE_FORMAT_PCM; | |
1187 | This->lpFormat->wBitsPerSample = 16; | |
1188 | break; | |
1189 | case AU_ENCODING_PCM_24: | |
1190 | This->lpFormat->wFormatTag = WAVE_FORMAT_PCM; | |
1191 | This->lpFormat->wBitsPerSample = 24; | |
1192 | break; | |
1193 | case AU_ENCODING_PCM_32: | |
1194 | This->lpFormat->wFormatTag = WAVE_FORMAT_PCM; | |
1195 | This->lpFormat->wBitsPerSample = 32; | |
1196 | break; | |
1197 | case AU_ENCODING_ALAW_8: | |
1198 | This->lpFormat->wFormatTag = WAVE_FORMAT_ALAW; | |
1199 | This->lpFormat->wBitsPerSample = 8; | |
1200 | break; | |
1201 | case AU_ENCODING_ADPCM_G721_32: | |
1202 | This->lpFormat->wFormatTag = WAVE_FORMAT_G721_ADPCM; | |
1203 | This->lpFormat->wBitsPerSample = (3*5*8); | |
1204 | This->lpFormat->nBlockAlign = 15*15*8; | |
1205 | This->lpFormat->cbSize = sizeof(WORD); | |
1206 | ((LPG721_ADPCMWAVEFORMAT)This->lpFormat)->nAuxBlockSize = 0; | |
1207 | break; | |
1208 | case AU_ENCODING_ADPCM_G723_24: | |
1209 | This->lpFormat->wFormatTag = WAVE_FORMAT_G723_ADPCM; | |
1210 | This->lpFormat->wBitsPerSample = (3*5*8); | |
1211 | This->lpFormat->nBlockAlign = 15*15*8; | |
1212 | This->lpFormat->cbSize = 2*sizeof(WORD); | |
1213 | ((LPG723_ADPCMWAVEFORMAT)This->lpFormat)->cbExtraSize = 0; | |
1214 | ((LPG723_ADPCMWAVEFORMAT)This->lpFormat)->nAuxBlockSize = 0; | |
1215 | break; | |
1216 | default: | |
1217 | WARN("unsupported Sun audio format %d\n", auhdr.encoding); | |
1218 | return AVIERR_UNSUPPORTED; | |
1219 | }; | |
1220 | ||
1221 | This->lpFormat->nBlockAlign = | |
1222 | (This->lpFormat->nChannels * This->lpFormat->wBitsPerSample) / 8; | |
1223 | if (This->lpFormat->nBlockAlign == 0 && This->lpFormat->wBitsPerSample < 8) | |
1224 | This->lpFormat->nBlockAlign++; | |
1225 | This->lpFormat->nAvgBytesPerSec = | |
1226 | This->lpFormat->nBlockAlign * This->lpFormat->nSamplesPerSec; | |
1227 | ||
1228 | This->fDirty = 0; | |
1229 | ||
1230 | This->sInfo.fccType = streamtypeAUDIO; | |
1231 | This->sInfo.fccHandler = 0; | |
1232 | This->sInfo.dwFlags = 0; | |
1233 | This->sInfo.wPriority = 0; | |
1234 | This->sInfo.wLanguage = 0; | |
1235 | This->sInfo.dwInitialFrames = 0; | |
1236 | This->sInfo.dwScale = This->lpFormat->nBlockAlign; | |
1237 | This->sInfo.dwRate = This->lpFormat->nAvgBytesPerSec; | |
1238 | This->sInfo.dwStart = 0; | |
1239 | This->sInfo.dwLength = | |
1240 | This->ckData.cksize / This->lpFormat->nBlockAlign; | |
1241 | This->sInfo.dwSuggestedBufferSize = This->sInfo.dwLength; | |
1242 | This->sInfo.dwSampleSize = This->lpFormat->nBlockAlign; | |
1243 | ||
1244 | This->fInfo.dwStreams = 1; | |
1245 | This->fInfo.dwScale = 1; | |
1246 | This->fInfo.dwRate = This->lpFormat->nSamplesPerSec; | |
1247 | This->fInfo.dwLength = | |
1248 | MulDiv(This->ckData.cksize, This->lpFormat->nSamplesPerSec, | |
1249 | This->lpFormat->nAvgBytesPerSec); | |
1250 | ||
1251 | return AVIERR_OK; | |
4c04e1fd MG |
1252 | } |
1253 | ||
b01c2c8a | 1254 | static HRESULT AVIFILE_SaveFile(const IAVIFileImpl *This) |
4c04e1fd | 1255 | { |
45af4922 MG |
1256 | MMCKINFO ckRIFF; |
1257 | MMCKINFO ck; | |
1258 | ||
1259 | mmioSeek(This->hmmio, 0, SEEK_SET); | |
1260 | ||
1261 | /* create the RIFF chunk with formtype WAVE */ | |
1262 | ckRIFF.fccType = formtypeWAVE; | |
1263 | ckRIFF.cksize = 0; | |
1264 | if (mmioCreateChunk(This->hmmio, &ckRIFF, MMIO_CREATERIFF) != S_OK) | |
1265 | return AVIERR_FILEWRITE; | |
1266 | ||
1267 | /* the next chunk is the format */ | |
1268 | ck.ckid = ckidWAVEFORMAT; | |
1269 | ck.cksize = This->cbFormat; | |
1270 | if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK) | |
1271 | return AVIERR_FILEWRITE; | |
1272 | if (This->lpFormat != NULL && This->cbFormat > 0) { | |
1273 | if (mmioWrite(This->hmmio, (HPSTR)This->lpFormat, ck.cksize) != ck.cksize) | |
1274 | return AVIERR_FILEWRITE; | |
1275 | } | |
1276 | if (mmioAscend(This->hmmio, &ck, 0) != S_OK) | |
1277 | return AVIERR_FILEWRITE; | |
1278 | ||
1279 | /* fact chunk is needed for non-pcm waveforms */ | |
1280 | if (This->lpFormat != NULL && This->cbFormat > sizeof(PCMWAVEFORMAT) && | |
1281 | This->lpFormat->wFormatTag != WAVE_FORMAT_PCM) { | |
1282 | WAVEFORMATEX wfx; | |
1283 | DWORD dwFactLength; | |
1284 | HACMSTREAM has; | |
1285 | ||
1286 | /* try to open an appropriate audio codec to figure out | |
1287 | * data for fact-chunk */ | |
1288 | wfx.wFormatTag = WAVE_FORMAT_PCM; | |
d2667a4c | 1289 | if (acmFormatSuggest(NULL, This->lpFormat, &wfx, |
45af4922 | 1290 | sizeof(wfx), ACM_FORMATSUGGESTF_WFORMATTAG)) { |
d2667a4c | 1291 | acmStreamOpen(&has, NULL, This->lpFormat, &wfx, NULL, |
45af4922 MG |
1292 | 0, 0, ACM_STREAMOPENF_NONREALTIME); |
1293 | acmStreamSize(has, This->ckData.cksize, &dwFactLength, | |
1294 | ACM_STREAMSIZEF_SOURCE); | |
1295 | dwFactLength /= wfx.nBlockAlign; | |
1296 | acmStreamClose(has, 0); | |
1297 | ||
6fb1a200 | 1298 | /* create the fact chunk */ |
45af4922 MG |
1299 | ck.ckid = ckidWAVEFACT; |
1300 | ck.cksize = sizeof(dwFactLength); | |
1301 | ||
1302 | /* test for enough space before data chunk */ | |
1303 | if (mmioSeek(This->hmmio, 0, SEEK_CUR) > This->ckData.dwDataOffset | |
1304 | - ck.cksize - 4 * sizeof(DWORD)) | |
1305 | return AVIERR_FILEWRITE; | |
1306 | if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK) | |
1307 | return AVIERR_FILEWRITE; | |
1308 | if (mmioWrite(This->hmmio, (HPSTR)&dwFactLength, ck.cksize) != ck.cksize) | |
1309 | return AVIERR_FILEWRITE; | |
1310 | if (mmioAscend(This->hmmio, &ck, 0) != S_OK) | |
1311 | return AVIERR_FILEWRITE; | |
1312 | } else | |
1313 | ERR(": fact chunk is needed for non-pcm files -- currently no codec found, so skipped!\n"); | |
1314 | } | |
1315 | ||
6fb1a200 | 1316 | /* if there was extra stuff, we need to fill it with JUNK */ |
45af4922 MG |
1317 | if (mmioSeek(This->hmmio, 0, SEEK_CUR) + 2 * sizeof(DWORD) < This->ckData.dwDataOffset) { |
1318 | ck.ckid = ckidAVIPADDING; | |
1319 | ck.cksize = 0; | |
1320 | if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK) | |
1321 | return AVIERR_FILEWRITE; | |
1322 | ||
1323 | if (mmioSeek(This->hmmio, This->ckData.dwDataOffset | |
1324 | - 2 * sizeof(DWORD), SEEK_SET) == -1) | |
1325 | return AVIERR_FILEWRITE; | |
1326 | if (mmioAscend(This->hmmio, &ck, 0) != S_OK) | |
1327 | return AVIERR_FILEWRITE; | |
1328 | } | |
1329 | ||
6fb1a200 | 1330 | /* create the data chunk */ |
45af4922 MG |
1331 | ck.ckid = ckidWAVEDATA; |
1332 | ck.cksize = This->ckData.cksize; | |
1333 | if (mmioCreateChunk(This->hmmio, &ck, 0) != S_OK) | |
1334 | return AVIERR_FILEWRITE; | |
1335 | if (mmioSeek(This->hmmio, This->ckData.cksize, SEEK_CUR) == -1) | |
1336 | return AVIERR_FILEWRITE; | |
1337 | if (mmioAscend(This->hmmio, &ck, 0) != S_OK) | |
1338 | return AVIERR_FILEWRITE; | |
1339 | ||
1340 | /* some optional extra chunks? */ | |
1341 | if (This->extra.lp != NULL && This->extra.cb > 0) { | |
1342 | /* chunk headers are already in structure */ | |
1343 | if (mmioWrite(This->hmmio, This->extra.lp, This->extra.cb) != This->extra.cb) | |
1344 | return AVIERR_FILEWRITE; | |
1345 | } | |
1346 | ||
1347 | /* close RIFF chunk */ | |
1348 | if (mmioAscend(This->hmmio, &ckRIFF, 0) != S_OK) | |
1349 | return AVIERR_FILEWRITE; | |
1350 | if (mmioFlush(This->hmmio, 0) != S_OK) | |
1351 | return AVIERR_FILEWRITE; | |
1352 | ||
1353 | return AVIERR_OK; | |
4c04e1fd | 1354 | } |