ReactOS 0.4.15-dev-7942-gd23573b
editstream.c File Reference
#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "wingdi.h"
#include "winerror.h"
#include "mmsystem.h"
#include "vfw.h"
#include "avifile_private.h"
#include "extrachunk.h"
#include "wine/debug.h"
#include "initguid.h"
Include dependency graph for editstream.c:

Go to the source code of this file.

Classes

struct  _EditStreamTable
 
struct  _IAVIEditStreamImpl
 

Macros

#define EditStreamEnd(This, streamNr)
 

Typedefs

typedef struct _EditStreamTable EditStreamTable
 
typedef struct _IAVIEditStreamImpl IAVIEditStreamImpl
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (avifile)
 
 DEFINE_AVIGUID (IID_IEditStreamInternal, 0x0002000A, 0, 0)
 
static IAVIEditStreamImplAVIFILE_CreateEditStream (IAVIStream *stream)
 
static IAVIEditStreamImplimpl_from_IAVIEditStream (IAVIEditStream *iface)
 
static IAVIEditStreamImplimpl_from_IAVIStream (IAVIStream *iface)
 
static HRESULT AVIFILE_FindStreamInTable (IAVIEditStreamImpl *const This, DWORD pos, PAVISTREAM *ppStream, DWORD *streamPos, DWORD *streamNr, BOOL bFindSample)
 
static LPVOID AVIFILE_ReadFrame (IAVIEditStreamImpl *const This, PAVISTREAM pstream, LONG pos)
 
static HRESULT AVIFILE_RemoveStream (IAVIEditStreamImpl *const This, DWORD nr)
 
static BOOL AVIFILE_FormatsEqual (PAVISTREAM avi1, PAVISTREAM avi2)
 
static HRESULT WINAPI IAVIEditStream_fnQueryInterface (IAVIEditStream *iface, REFIID refiid, LPVOID *obj)
 
static ULONG WINAPI IAVIEditStream_fnAddRef (IAVIEditStream *iface)
 
static ULONG WINAPI IAVIEditStream_fnRelease (IAVIEditStream *iface)
 
static HRESULT WINAPI IAVIEditStream_fnCut (IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult)
 
static HRESULT WINAPI IAVIEditStream_fnCopy (IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult)
 
static HRESULT WINAPI IAVIEditStream_fnPaste (IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM pSource, LONG lStart, LONG lLength)
 
static HRESULT WINAPI IAVIEditStream_fnClone (IAVIEditStream *iface, PAVISTREAM *ppResult)
 
static HRESULT WINAPI IAVIEditStream_fnSetInfo (IAVIEditStream *iface, LPAVISTREAMINFOW asi, LONG size)
 
static HRESULT WINAPI IEditAVIStream_fnQueryInterface (IAVIStream *iface, REFIID refiid, LPVOID *obj)
 
static ULONG WINAPI IEditAVIStream_fnAddRef (IAVIStream *iface)
 
static ULONG WINAPI IEditAVIStream_fnRelease (IAVIStream *iface)
 
static HRESULT WINAPI IEditAVIStream_fnCreate (IAVIStream *iface, LPARAM lParam1, LPARAM lParam2)
 
static HRESULT WINAPI IEditAVIStream_fnInfo (IAVIStream *iface, AVISTREAMINFOW *psi, LONG size)
 
static LONG WINAPI IEditAVIStream_fnFindSample (IAVIStream *iface, LONG pos, LONG flags)
 
static HRESULT WINAPI IEditAVIStream_fnReadFormat (IAVIStream *iface, LONG pos, LPVOID format, LONG *fmtsize)
 
static HRESULT WINAPI IEditAVIStream_fnSetFormat (IAVIStream *iface, LONG pos, LPVOID format, LONG formatsize)
 
static HRESULT WINAPI IEditAVIStream_fnRead (IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, LONG *bytesread, LONG *samplesread)
 
static HRESULT WINAPI IEditAVIStream_fnWrite (IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, DWORD flags, LONG *sampwritten, LONG *byteswritten)
 
static HRESULT WINAPI IEditAVIStream_fnDelete (IAVIStream *iface, LONG start, LONG samples)
 
static HRESULT WINAPI IEditAVIStream_fnReadData (IAVIStream *iface, DWORD fcc, LPVOID lp, LONG *lpread)
 
static HRESULT WINAPI IEditAVIStream_fnWriteData (IAVIStream *iface, DWORD fcc, LPVOID lp, LONG size)
 
static HRESULT WINAPI IEditAVIStream_fnSetInfo (IAVIStream *iface, AVISTREAMINFOW *info, LONG len)
 
HRESULT WINAPI CreateEditableStream (IAVIStream **editable, IAVIStream *src)
 

Variables

static const struct IAVIEditStreamVtbl ieditstream
 
static const struct IAVIStreamVtbl ieditstast
 

Macro Definition Documentation

◆ EditStreamEnd

#define EditStreamEnd (   This,
  streamNr 
)
Value:
((This)->pStreams[streamNr].dwStart + \
(This)->pStreams[streamNr].dwLength)

Definition at line 50 of file editstream.c.

Typedef Documentation

◆ EditStreamTable

◆ IAVIEditStreamImpl

Definition at line 53 of file editstream.c.

Function Documentation

◆ AVIFILE_CreateEditStream()

static IAVIEditStreamImpl * AVIFILE_CreateEditStream ( IAVIStream stream)
static

Definition at line 1009 of file editstream.c.

1010{
1011 IAVIEditStreamImpl *pedit = NULL;
1012
1014 if (pedit == NULL)
1015 return NULL;
1016
1017 pedit->IAVIEditStream_iface.lpVtbl = &ieditstream;
1018 pedit->IAVIStream_iface.lpVtbl = &ieditstast;
1019 pedit->ref = 1;
1020
1021 IAVIStream_Create(&pedit->IAVIStream_iface, (LPARAM)pstream, 0);
1022
1023 return pedit;
1024}
#define NULL
Definition: types.h:112
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
static const struct IAVIEditStreamVtbl ieditstream
Definition: editstream.c:666
static const struct IAVIStreamVtbl ieditstast
Definition: editstream.c:992
IAVIStream IAVIStream_iface
Definition: editstream.c:57
IAVIEditStream IAVIEditStream_iface
Definition: editstream.c:56
#define IAVIStream_Create(p, a, b)
Definition: vfw.h:1179
LONG_PTR LPARAM
Definition: windef.h:208

Referenced by CreateEditableStream(), IAVIEditStream_fnClone(), and IAVIEditStream_fnCopy().

◆ AVIFILE_FindStreamInTable()

static HRESULT AVIFILE_FindStreamInTable ( IAVIEditStreamImpl *const  This,
DWORD  pos,
PAVISTREAM ppStream,
DWORD streamPos,
DWORD streamNr,
BOOL  bFindSample 
)
static

Definition at line 87 of file editstream.c.

91{
92 DWORD n;
93
94 TRACE("(%p,%u,%p,%p,%p,%d)\n",This,pos,ppStream,streamPos,
95 streamNr,bFindSample);
96
97 if (pos < This->sInfo.dwStart)
98 return AVIERR_BADPARAM;
99
100 pos -= This->sInfo.dwStart;
101 for (n = 0; n < This->nStreams; n++) {
102 if (pos < This->pStreams[n].dwLength) {
103 *ppStream = This->pStreams[n].pStream;
104 *streamPos = This->pStreams[n].dwStart + pos;
105 if (streamNr != NULL)
106 *streamNr = n;
107
108 return AVIERR_OK;
109 }
110 pos -= This->pStreams[n].dwLength;
111 }
112 if (pos == 0 && bFindSample) {
113 *ppStream = This->pStreams[--n].pStream;
114 *streamPos = EditStreamEnd(This, n);
115 if (streamNr != NULL)
116 *streamNr = n;
117
118 TRACE(" -- pos=0 && b=1 -> (%p,%u,%u)\n",*ppStream, *streamPos, n);
119 return AVIERR_OK;
120 } else {
121 *ppStream = NULL;
122 *streamPos = 0;
123 if (streamNr != NULL)
124 *streamNr = 0;
125
126 TRACE(" -> ERROR (NULL,0,0)\n");
127 return AVIERR_BADPARAM;
128 }
129}
static DWORD DWORD * dwLength
Definition: fusion.c:86
#define EditStreamEnd(This, streamNr)
Definition: editstream.c:50
unsigned long DWORD
Definition: ntddk_ex.h:95
GLdouble n
Definition: glext.h:7729
#define TRACE(s)
Definition: solgame.cpp:4
#define AVIERR_OK
Definition: vfw.h:1740
#define AVIERR_BADPARAM
Definition: vfw.h:1748

Referenced by IAVIEditStream_fnCut(), IAVIEditStream_fnPaste(), IEditAVIStream_fnFindSample(), IEditAVIStream_fnRead(), and IEditAVIStream_fnReadFormat().

◆ AVIFILE_FormatsEqual()

static BOOL AVIFILE_FormatsEqual ( PAVISTREAM  avi1,
PAVISTREAM  avi2 
)
static

Definition at line 193 of file editstream.c.

194{
195 LPVOID fmt1 = NULL, fmt2 = NULL;
196 LONG size1, size2, start1, start2;
197 BOOL status = FALSE;
198
199 assert(avi1 != NULL && avi2 != NULL);
200
201 /* get stream starts and check format sizes */
202 start1 = AVIStreamStart(avi1);
203 start2 = AVIStreamStart(avi2);
204 if (FAILED(AVIStreamFormatSize(avi1, start1, &size1)))
205 return FALSE;
206 if (FAILED(AVIStreamFormatSize(avi2, start2, &size2)))
207 return FALSE;
208 if (size1 != size2)
209 return FALSE;
210
211 /* sizes match, now get formats and compare them */
212 fmt1 = HeapAlloc(GetProcessHeap(), 0, size1);
213 if (fmt1 == NULL)
214 return FALSE;
215 if (SUCCEEDED(AVIStreamReadFormat(avi1, start1, fmt1, &size1))) {
216 fmt2 = HeapAlloc(GetProcessHeap(), 0, size1);
217 if (fmt2 != NULL) {
218 if (SUCCEEDED(AVIStreamReadFormat(avi2, start2, fmt2, &size1)))
219 status = (memcmp(fmt1, fmt2, size1) == 0);
220 }
221 }
222
223 HeapFree(GetProcessHeap(), 0, fmt2);
224 HeapFree(GetProcessHeap(), 0, fmt1);
225
226 return status;
227}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define FALSE
Definition: types.h:117
LONG WINAPI AVIStreamStart(PAVISTREAM pstream)
Definition: api.c:858
HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pstream, LONG pos, LPVOID format, LPLONG formatsize)
Definition: api.c:549
#define HeapFree(x, y, z)
Definition: compat.h:735
#define assert(x)
Definition: debug.h:53
unsigned int BOOL
Definition: ntddk_ex.h:94
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
long LONG
Definition: pedump.c:60
Definition: ps.c:97
#define AVIStreamFormatSize(pavi, lPos, plSize)
Definition: vfw.h:1436

Referenced by IAVIEditStream_fnPaste().

◆ AVIFILE_ReadFrame()

static LPVOID AVIFILE_ReadFrame ( IAVIEditStreamImpl *const  This,
PAVISTREAM  pstream,
LONG  pos 
)
static

Definition at line 131 of file editstream.c.

133{
134 PGETFRAME pg;
135
136 TRACE("(%p,%p,%d)\n",This,pstream,pos);
137
138 if (pstream == NULL)
139 return NULL;
140
141 /* if stream changes make sure that only palette changes */
142 if (This->pCurStream != pstream) {
143 pg = AVIStreamGetFrameOpen(pstream, NULL);
144 if (pg == NULL)
145 return NULL;
146 if (This->pg != NULL) {
147 if (IGetFrame_SetFormat(pg, This->lpFrame, NULL, 0, 0, -1, -1) != S_OK) {
149 ERR(": IGetFrame_SetFormat failed\n");
150 return NULL;
151 }
153 }
154 This->pg = pg;
155 This->pCurStream = pstream;
156 }
157
158 /* now get the decompressed frame */
159 This->lpFrame = AVIStreamGetFrame(This->pg, pos);
160 if (This->lpFrame != NULL)
161 This->sInfo.dwSuggestedBufferSize = This->lpFrame->biSizeImage;
162
163 return This->lpFrame;
164}
#define ERR(fmt,...)
Definition: debug.h:110
PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pstream, LPBITMAPINFOHEADER lpbiWanted)
Definition: api.c:639
HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pg)
Definition: api.c:677
LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pg, LONG pos)
Definition: api.c:664
#define S_OK
Definition: intsafe.h:52
#define IGetFrame_SetFormat(p, a, b, c, d, e, f)
Definition: vfw.h:1724
struct IGetFrame * PGETFRAME
Definition: vfw.h:40

Referenced by IAVIEditStream_fnPaste(), IEditAVIStream_fnRead(), and IEditAVIStream_fnReadFormat().

◆ AVIFILE_RemoveStream()

static HRESULT AVIFILE_RemoveStream ( IAVIEditStreamImpl *const  This,
DWORD  nr 
)
static

Definition at line 166 of file editstream.c.

167{
168 assert(This != NULL);
169 assert(nr < This->nStreams);
170
171 /* remove part nr */
172 IAVIStream_Release(This->pStreams[nr].pStream);
173 This->nStreams--;
174 if (nr < This->nStreams)
175 memmove(&This->pStreams[nr], &This->pStreams[nr + 1],
176 (This->nStreams - nr) * sizeof(This->pStreams[0]));
177 This->pStreams[This->nStreams].pStream = NULL;
178 This->pStreams[This->nStreams].dwStart = 0;
179 This->pStreams[This->nStreams].dwLength = 0;
180
181 /* try to merge the part before the deleted one and the one after it */
182 if (0 < nr && 0 < This->nStreams &&
183 This->pStreams[nr - 1].pStream == This->pStreams[nr].pStream) {
184 if (EditStreamEnd(This, nr - 1) == This->pStreams[nr].dwStart) {
185 This->pStreams[nr - 1].dwLength += This->pStreams[nr].dwLength;
187 }
188 }
189
190 return AVIERR_OK;
191}
INT nStreams
Definition: api.c:60
static HRESULT AVIFILE_RemoveStream(IAVIEditStreamImpl *const This, DWORD nr)
Definition: editstream.c:166
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
ULONG nr
Definition: thread.c:7
#define IAVIStream_Release(p)
Definition: vfw.h:1177

Referenced by AVIFILE_RemoveStream(), and IAVIEditStream_fnCut().

◆ CreateEditableStream()

HRESULT WINAPI CreateEditableStream ( IAVIStream **  editable,
IAVIStream src 
)

Definition at line 1029 of file editstream.c.

1030{
1031 IAVIEditStream *edit = NULL;
1032 IAVIEditStreamImpl *editobj;
1033 HRESULT hr;
1034
1035 TRACE("(%p,%p)\n", editable, src);
1036
1037 if (!editable)
1038 return AVIERR_BADPARAM;
1039 *editable = NULL;
1040
1041 if (src) {
1042 hr = IAVIStream_QueryInterface(src, &IID_IAVIEditStream, (void**)&edit);
1043 if (SUCCEEDED(hr) && edit) {
1044 hr = IAVIEditStream_Clone(edit, editable);
1046
1047 return hr;
1048 }
1049 }
1050
1051 /* Need own implementation of IAVIEditStream */
1052 editobj = AVIFILE_CreateEditStream(src);
1053 if (!editobj)
1054 return AVIERR_MEMORY;
1055 *editable = &editobj->IAVIStream_iface;
1056
1057 return S_OK;
1058}
static IAVIEditStreamImpl * AVIFILE_CreateEditStream(IAVIStream *stream)
Definition: editstream.c:1009
GLenum src
Definition: glext.h:6340
HRESULT hr
Definition: shlfolder.c:183
#define IAVIStream_QueryInterface(p, a, b)
Definition: vfw.h:1175
#define IAVIEditStream_Clone(p, a)
Definition: vfw.h:1516
#define AVIERR_MEMORY
Definition: vfw.h:1745
#define IAVIEditStream_Release(p)
Definition: vfw.h:1511

Referenced by test_AVISaveOptions(), test_COM_editstream(), and test_EditStreamSetInfo().

◆ DEFINE_AVIGUID()

DEFINE_AVIGUID ( IID_IEditStreamInternal  ,
0x0002000A  ,
,
 
)

◆ IAVIEditStream_fnAddRef()

static ULONG WINAPI IAVIEditStream_fnAddRef ( IAVIEditStream *  iface)
static

Definition at line 254 of file editstream.c.

255{
258
259 TRACE("(%p) -> %d\n", iface, ref);
260
261 return ref;
262}
#define InterlockedIncrement
Definition: armddk.h:53
static IAVIEditStreamImpl * impl_from_IAVIEditStream(IAVIEditStream *iface)
Definition: editstream.c:75
Definition: send.c:48
uint32_t ULONG
Definition: typedefs.h:59

◆ IAVIEditStream_fnClone()

static HRESULT WINAPI IAVIEditStream_fnClone ( IAVIEditStream *  iface,
PAVISTREAM ppResult 
)
static

Definition at line 605 of file editstream.c.

607{
609 IAVIEditStreamImpl* pEdit;
610 DWORD i;
611
612 TRACE("(%p,%p)\n",iface,ppResult);
613
614 if (ppResult == NULL)
615 return AVIERR_BADPARAM;
616 *ppResult = NULL;
617
619 if (pEdit == NULL)
620 return AVIERR_MEMORY;
621 if (This->nStreams > pEdit->nTableSize) {
623 This->nStreams * sizeof(EditStreamTable));
624 if (pEdit->pStreams == NULL)
625 return AVIERR_MEMORY;
626 pEdit->nTableSize = This->nStreams;
627 }
628 pEdit->nStreams = This->nStreams;
629 memcpy(pEdit->pStreams, This->pStreams,
630 This->nStreams * sizeof(EditStreamTable));
631 memcpy(&pEdit->sInfo,&This->sInfo,sizeof(This->sInfo));
632 for (i = 0; i < This->nStreams; i++) {
633 if (pEdit->pStreams[i].pStream != NULL)
635 }
636
637 *ppResult = &This->IAVIStream_iface;
638
639 return AVIERR_OK;
640}
#define HeapReAlloc
Definition: compat.h:734
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
enum _tagppResult ppResult
PAVISTREAM pStream
Definition: editstream.c:45
EditStreamTable * pStreams
Definition: editstream.c:63
AVISTREAMINFOW sInfo
Definition: editstream.c:61
#define IAVIStream_AddRef(p)
Definition: vfw.h:1176

◆ IAVIEditStream_fnCopy()

static HRESULT WINAPI IAVIEditStream_fnCopy ( IAVIEditStream *  iface,
LONG plStart,
LONG plLength,
PAVISTREAM ppResult 
)
static

Definition at line 373 of file editstream.c.

375{
377 IAVIEditStreamImpl* pEdit;
378 HRESULT hr;
379 LONG start = 0;
380
381 TRACE("(%p,%p,%p,%p)\n",iface,plStart,plLength,ppResult);
382
383 if (ppResult == NULL)
384 return AVIERR_BADPARAM;
385 *ppResult = NULL;
386 if (plStart == NULL || plLength == NULL || *plStart < 0 || *plLength < 0)
387 return AVIERR_BADPARAM;
388
389 /* check bounds */
390 if (*(LPDWORD)plLength > This->sInfo.dwLength)
391 *(LPDWORD)plLength = This->sInfo.dwLength;
392 if (*(LPDWORD)plStart < This->sInfo.dwStart) {
393 *(LPDWORD)plLength -= This->sInfo.dwStart - *(LPDWORD)plStart;
394 *(LPDWORD)plStart = This->sInfo.dwStart;
395 if (*plLength < 0)
396 return AVIERR_BADPARAM;
397 }
398 if (*(LPDWORD)plStart + *(LPDWORD)plLength > This->sInfo.dwStart + This->sInfo.dwLength)
399 *(LPDWORD)plLength = This->sInfo.dwStart + This->sInfo.dwLength -
400 *(LPDWORD)plStart;
401
403 if (pEdit == NULL)
404 return AVIERR_MEMORY;
405
406 hr = IAVIEditStream_Paste(&pEdit->IAVIEditStream_iface, &start, plLength, &This->IAVIStream_iface,
407 *plStart, *plStart + *plLength);
408 *plStart = start;
409 if (FAILED(hr))
411 else
412 *ppResult = &This->IAVIStream_iface;
413
414 return hr;
415}
GLuint start
Definition: gl.h:1545
if(dx< 0)
Definition: linetemp.h:194
#define LPDWORD
Definition: nt_native.h:46
uint32_t * LPDWORD
Definition: typedefs.h:59
#define IAVIEditStream_Paste(p, a, b, c, d, e)
Definition: vfw.h:1515

◆ IAVIEditStream_fnCut()

static HRESULT WINAPI IAVIEditStream_fnCut ( IAVIEditStream *  iface,
LONG plStart,
LONG plLength,
PAVISTREAM ppResult 
)
static

Definition at line 289 of file editstream.c.

291{
294 DWORD start, len, streamPos, streamNr;
295 HRESULT hr;
296
297 TRACE("(%p,%p,%p,%p)\n",iface,plStart,plLength,ppResult);
298
299 if (ppResult != NULL)
300 *ppResult = NULL;
301 if (plStart == NULL || plLength == NULL || *plStart < 0)
302 return AVIERR_BADPARAM;
303
304 /* if asked for cut part copy it before deleting */
305 if (ppResult != NULL) {
306 hr = IAVIEditStream_Copy(iface, plStart, plLength, ppResult);
307 if (FAILED(hr))
308 return hr;
309 }
310
311 start = *plStart;
312 len = *plLength;
313
314 /* now delete the requested part */
315 while (len > 0) {
317 &streamPos, &streamNr, FALSE);
318 if (FAILED(hr))
319 return hr;
320 if (This->pStreams[streamNr].dwStart == streamPos) {
321 /* deleting from start of part */
322 if (len < This->pStreams[streamNr].dwLength) {
323 start += len;
324 This->pStreams[streamNr].dwStart += len;
325 This->pStreams[streamNr].dwLength -= len;
326 This->sInfo.dwLength -= len;
327 len = 0;
328
329 /* we must return decompressed data now */
330 This->bDecompress = TRUE;
331 } else {
332 /* deleting hole part */
333 len -= This->pStreams[streamNr].dwLength;
334 AVIFILE_RemoveStream(This,streamNr);
335 }
336 } else if (EditStreamEnd(This, streamNr) <= streamPos + len) {
337 /* deleting at end of a part */
338 DWORD count = EditStreamEnd(This, streamNr) - streamPos;
339 This->sInfo.dwLength -= count;
340 len -= count;
341 This->pStreams[streamNr].dwLength =
342 streamPos - This->pStreams[streamNr].dwStart;
343 } else {
344 /* splitting */
345 if (This->nStreams + 1 >= This->nTableSize) {
346 This->pStreams = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pStreams,
347 (This->nTableSize + 32) * sizeof(EditStreamTable));
348 if (This->pStreams == NULL)
349 return AVIERR_MEMORY;
350 This->nTableSize += 32;
351 }
352 memmove(This->pStreams + streamNr + 1, This->pStreams + streamNr,
353 (This->nStreams - streamNr) * sizeof(EditStreamTable));
354 This->nStreams++;
355
356 IAVIStream_AddRef(This->pStreams[streamNr + 1].pStream);
357 This->pStreams[streamNr + 1].dwStart = streamPos + len;
358 This->pStreams[streamNr + 1].dwLength =
359 EditStreamEnd(This, streamNr) - This->pStreams[streamNr + 1].dwStart;
360
361 This->pStreams[streamNr].dwLength =
362 streamPos - This->pStreams[streamNr].dwStart;
363 This->sInfo.dwLength -= len;
364 len = 0;
365 }
366 }
367
368 This->sInfo.dwEditCount++;
369
370 return AVIERR_OK;
371}
#define TRUE
Definition: types.h:120
static HRESULT AVIFILE_FindStreamInTable(IAVIEditStreamImpl *const This, DWORD pos, PAVISTREAM *ppStream, DWORD *streamPos, DWORD *streamNr, BOOL bFindSample)
Definition: editstream.c:87
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLenum GLsizei len
Definition: glext.h:6722
Definition: parse.h:23
#define IAVIEditStream_Copy(p, a, b, c)
Definition: vfw.h:1514

◆ IAVIEditStream_fnPaste()

static HRESULT WINAPI IAVIEditStream_fnPaste ( IAVIEditStream *  iface,
LONG plStart,
LONG plLength,
PAVISTREAM  pSource,
LONG  lStart,
LONG  lLength 
)
static

Definition at line 417 of file editstream.c.

420{
422 AVISTREAMINFOW srcInfo;
423 IAVIEditStreamImpl *pEdit = NULL;
424 PAVISTREAM pStream;
425 DWORD startPos, endPos, streamNr, nStreams;
426 ULONG n;
427
428 TRACE("(%p,%p,%p,%p,%d,%d)\n",iface,plStart,plLength,
429 pSource,lStart,lLength);
430
431 if (pSource == NULL)
432 return AVIERR_BADHANDLE;
433 if (plStart == NULL || *plStart < 0)
434 return AVIERR_BADPARAM;
435 if (This->sInfo.dwStart + This->sInfo.dwLength < *plStart)
436 return AVIERR_BADPARAM; /* Can't paste with holes */
437 if (FAILED(IAVIStream_Info(pSource, &srcInfo, sizeof(srcInfo))))
438 return AVIERR_ERROR;
439 if (lStart < srcInfo.dwStart || lStart >= srcInfo.dwStart + srcInfo.dwLength)
440 return AVIERR_BADPARAM;
441 if (This->sInfo.fccType == 0) {
442 /* This stream is empty */
443 IAVIStream_Info(pSource, &This->sInfo, sizeof(This->sInfo));
444 This->sInfo.dwStart = *plStart;
445 This->sInfo.dwLength = 0;
446 }
447 if (This->sInfo.fccType != srcInfo.fccType)
448 return AVIERR_UNSUPPORTED; /* different stream types */
449 if (lLength == -1) /* Copy the hole stream */
450 lLength = srcInfo.dwLength;
451 if (lStart + lLength > srcInfo.dwStart + srcInfo.dwLength)
452 lLength = srcInfo.dwStart + srcInfo.dwLength - lStart;
453 if (lLength + *plStart >= 0x80000000)
454 return AVIERR_MEMORY;
455
456 /* streamtype specific tests */
457 if (srcInfo.fccType == streamtypeVIDEO) {
458 LONG size;
459
460 size = srcInfo.rcFrame.right - srcInfo.rcFrame.left;
461 if (size != This->sInfo.rcFrame.right - This->sInfo.rcFrame.left)
462 return AVIERR_UNSUPPORTED; /* FIXME: Can't GetFrame convert it? */
463 size = srcInfo.rcFrame.bottom - srcInfo.rcFrame.top;
464 if (size != This->sInfo.rcFrame.bottom - This->sInfo.rcFrame.top)
465 return AVIERR_UNSUPPORTED; /* FIXME: Can't GetFrame convert it? */
466 } else if (srcInfo.fccType == streamtypeAUDIO) {
467 if (!AVIFILE_FormatsEqual(&This->IAVIStream_iface, pSource))
468 return AVIERR_UNSUPPORTED;
469 } else {
470 /* FIXME: streamtypeMIDI and streamtypeTEXT */
471 return AVIERR_UNSUPPORTED;
472 }
473
474 /* try to get an IEditStreamInternal interface */
475 if (SUCCEEDED(IAVIStream_QueryInterface(pSource, &IID_IEditStreamInternal, (LPVOID*)&pEdit)))
476 IAVIEditStream_Release(&pEdit->IAVIEditStream_iface); /* pSource holds a reference */
477
478 /* for video must check for change of format */
479 if (This->sInfo.fccType == streamtypeVIDEO) {
480 if (! This->bDecompress) {
481 /* Need to decompress if any of the following conditions matches:
482 * - pSource is an editable stream which decompresses
483 * - the nearest keyframe of pSource isn't lStart
484 * - the nearest keyframe of this stream isn't *plStart
485 * - the format of pSource doesn't match this one
486 */
487 if ((pEdit != NULL && pEdit->bDecompress) ||
488 AVIStreamNearestKeyFrame(pSource, lStart) != lStart ||
489 AVIStreamNearestKeyFrame(&This->IAVIStream_iface, *plStart) != *plStart ||
490 (This->nStreams > 0 && !AVIFILE_FormatsEqual(&This->IAVIStream_iface, pSource))) {
491 /* Use first stream part to get format to convert everything to */
492 AVIFILE_ReadFrame(This, This->pStreams[0].pStream,
493 This->pStreams[0].dwStart);
494
495 /* Check if we could convert the source streams to the desired format... */
496 if (pEdit != NULL) {
497 if (FAILED(AVIFILE_FindStreamInTable(pEdit, lStart, &pStream,
498 &startPos, &streamNr, TRUE)))
499 return AVIERR_INTERNAL;
500 for (n = lStart; n < lStart + lLength; streamNr++) {
501 if (AVIFILE_ReadFrame(This, pEdit->pStreams[streamNr].pStream, startPos) == NULL)
502 return AVIERR_BADFORMAT;
503 startPos = pEdit->pStreams[streamNr].dwStart;
504 n += pEdit->pStreams[streamNr].dwLength;
505 }
506 } else if (AVIFILE_ReadFrame(This, pSource, lStart) == NULL)
507 return AVIERR_BADFORMAT;
508
509 This->bDecompress = TRUE;
510 This->sInfo.fccHandler = 0;
511 }
512 } else if (AVIFILE_ReadFrame(This, pSource, lStart) == NULL)
513 return AVIERR_BADFORMAT; /* Can't convert source to own format */
514 } /* FIXME: something special for the other formats? */
515
516 /* Make sure we have enough memory for parts */
517 if (pEdit != NULL) {
518 DWORD nLastStream;
519
520 AVIFILE_FindStreamInTable(pEdit, lStart + lLength, &pStream,
521 &endPos, &nLastStream, TRUE);
522 AVIFILE_FindStreamInTable(pEdit, lStart, &pStream,
523 &startPos, &streamNr, FALSE);
524 if (nLastStream == streamNr)
525 nLastStream++;
526
527 nStreams = nLastStream - streamNr;
528 } else
529 nStreams = 1;
530 if (This->nStreams + nStreams + 1 > This->nTableSize) {
531 n = This->nStreams + nStreams + 33;
532
533 This->pStreams = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pStreams, n * sizeof(EditStreamTable));
534 if (This->pStreams == NULL)
535 return AVIERR_MEMORY;
536 This->nTableSize = n;
537 }
538
539 if (plLength != NULL)
540 *plLength = lLength;
541
542 /* now do the real work */
543 if (This->sInfo.dwStart + This->sInfo.dwLength > *plStart) {
544 AVIFILE_FindStreamInTable(This, *plStart, &pStream,
545 &startPos, &streamNr, FALSE);
546 if (startPos != This->pStreams[streamNr].dwStart) {
547 /* split stream streamNr at startPos */
548 memmove(This->pStreams + streamNr + nStreams + 1,
549 This->pStreams + streamNr,
550 (This->nStreams + nStreams - streamNr + 1) * sizeof(EditStreamTable));
551
552 This->pStreams[streamNr + 2].dwLength =
553 EditStreamEnd(This, streamNr + 2) - startPos;
554 This->pStreams[streamNr + 2].dwStart = startPos;
555 This->pStreams[streamNr].dwLength =
556 startPos - This->pStreams[streamNr].dwStart;
557 IAVIStream_AddRef(This->pStreams[streamNr].pStream);
558 streamNr++;
559 } else {
560 /* insert before stream at streamNr */
561 memmove(This->pStreams + streamNr + nStreams, This->pStreams + streamNr,
562 (This->nStreams + nStreams - streamNr) * sizeof(EditStreamTable));
563 }
564 } else /* append the streams */
565 streamNr = This->nStreams;
566
567 if (pEdit != NULL) {
568 /* insert the parts of the editable stream instead of itself */
569 AVIFILE_FindStreamInTable(pEdit, lStart + lLength, &pStream,
570 &endPos, NULL, FALSE);
571 AVIFILE_FindStreamInTable(pEdit, lStart, &pStream, &startPos, &n, FALSE);
572
573 memcpy(This->pStreams + streamNr, pEdit->pStreams + n,
574 nStreams * sizeof(EditStreamTable));
575 if (This->pStreams[streamNr].dwStart < startPos) {
576 This->pStreams[streamNr].dwLength =
577 EditStreamEnd(This, streamNr) - startPos;
578 This->pStreams[streamNr].dwStart = startPos;
579 }
580 if (endPos < EditStreamEnd(This, streamNr + nStreams))
581 This->pStreams[streamNr + nStreams].dwLength =
582 endPos - This->pStreams[streamNr + nStreams].dwStart;
583 } else {
584 /* a simple stream */
585 This->pStreams[streamNr].pStream = pSource;
586 This->pStreams[streamNr].dwStart = lStart;
587 This->pStreams[streamNr].dwLength = lLength;
588 }
589
590 for (n = 0; n < nStreams; n++) {
591 IAVIStream_AddRef(This->pStreams[streamNr + n].pStream);
592 if (0 < streamNr + n &&
593 This->pStreams[streamNr + n - 1].pStream != This->pStreams[streamNr + n].pStream) {
594 This->sInfo.dwFlags |= AVISTREAMINFO_FORMATCHANGES;
595 This->sInfo.dwFormatChangeCount++;
596 }
597 }
598 This->sInfo.dwEditCount++;
599 This->sInfo.dwLength += lLength;
600 This->nStreams += nStreams;
601
602 return AVIERR_OK;
603}
#define streamtypeAUDIO
Definition: aviriff.h:93
#define streamtypeVIDEO
Definition: aviriff.h:92
static BOOL AVIFILE_FormatsEqual(PAVISTREAM avi1, PAVISTREAM avi2)
Definition: editstream.c:193
static LPVOID AVIFILE_ReadFrame(IAVIEditStreamImpl *const This, PAVISTREAM pstream, LONG pos)
Definition: editstream.c:131
GLsizeiptr size
Definition: glext.h:5919
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define AVISTREAMINFO_FORMATCHANGES
Definition: vfw.h:1049
#define AVIERR_UNSUPPORTED
Definition: vfw.h:1743
#define AVIERR_BADHANDLE
Definition: vfw.h:1750
#define AVIERR_ERROR
Definition: vfw.h:1761
#define AVIERR_INTERNAL
Definition: vfw.h:1746
#define AVIERR_BADFORMAT
Definition: vfw.h:1744
#define AVIStreamNearestKeyFrame(pavi, pos)
Definition: vfw.h:1457
#define IAVIStream_Info(p, a, b)
Definition: vfw.h:1180

◆ IAVIEditStream_fnQueryInterface()

static HRESULT WINAPI IAVIEditStream_fnQueryInterface ( IAVIEditStream *  iface,
REFIID  refiid,
LPVOID obj 
)
static

Definition at line 231 of file editstream.c.

232{
234
235 TRACE("(%p,%s,%p)\n", This, debugstr_guid(refiid), obj);
236
237 if (IsEqualGUID(&IID_IUnknown, refiid) ||
238 IsEqualGUID(&IID_IAVIEditStream, refiid) ||
239 IsEqualGUID(&IID_IEditStreamInternal, refiid)) {
240 *obj = iface;
242
243 return S_OK;
244 } else if (IsEqualGUID(&IID_IAVIStream, refiid)) {
245 *obj = &This->IAVIStream_iface;
247
248 return S_OK;
249 }
250
251 return E_NOINTERFACE;
252}
const GUID IID_IUnknown
#define debugstr_guid
Definition: kernel32.h:35
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define IAVIEditStream_AddRef(p)
Definition: vfw.h:1510
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ IAVIEditStream_fnRelease()

static ULONG WINAPI IAVIEditStream_fnRelease ( IAVIEditStream *  iface)
static

Definition at line 264 of file editstream.c.

265{
267 DWORD i;
269
270 TRACE("(%p) -> %d\n", iface, ref);
271
272 if (!ref) {
273 /* release memory */
274 if (This->pg != NULL)
276 if (This->pStreams != NULL) {
277 for (i = 0; i < This->nStreams; i++) {
278 if (This->pStreams[i].pStream != NULL)
279 IAVIStream_Release(This->pStreams[i].pStream);
280 }
281 HeapFree(GetProcessHeap(), 0, This->pStreams);
282 }
283
285 }
286 return ref;
287}
#define InterlockedDecrement
Definition: armddk.h:52

◆ IAVIEditStream_fnSetInfo()

static HRESULT WINAPI IAVIEditStream_fnSetInfo ( IAVIEditStream *  iface,
LPAVISTREAMINFOW  asi,
LONG  size 
)
static

Definition at line 642 of file editstream.c.

644{
646
647 TRACE("(%p,%p,%d)\n",iface,asi,size);
648
649 /* check parameters */
650 if (size >= 0 && size < sizeof(AVISTREAMINFOW))
651 return AVIERR_BADSIZE;
652
653 This->sInfo.wLanguage = asi->wLanguage;
654 This->sInfo.wPriority = asi->wPriority;
655 This->sInfo.dwStart = asi->dwStart;
656 This->sInfo.dwRate = asi->dwRate;
657 This->sInfo.dwScale = asi->dwScale;
658 This->sInfo.dwQuality = asi->dwQuality;
659 This->sInfo.rcFrame = asi->rcFrame;
660 memcpy(This->sInfo.szName, asi->szName, sizeof(asi->szName));
661 This->sInfo.dwEditCount++;
662
663 return AVIERR_OK;
664}
WCHAR szName[64]
Definition: avifil32.idl:46
#define AVIERR_BADSIZE
Definition: vfw.h:1749

◆ IEditAVIStream_fnAddRef()

static ULONG WINAPI IEditAVIStream_fnAddRef ( IAVIStream iface)
static

Definition at line 684 of file editstream.c.

685{
687 return IAVIEditStream_AddRef(&This->IAVIEditStream_iface);
688}
static IAVIEditStreamImpl * impl_from_IAVIStream(IAVIStream *iface)
Definition: editstream.c:80

◆ IEditAVIStream_fnCreate()

static HRESULT WINAPI IEditAVIStream_fnCreate ( IAVIStream iface,
LPARAM  lParam1,
LPARAM  lParam2 
)
static

Definition at line 696 of file editstream.c.

698{
700
701 if (lParam2 != 0)
702 return AVIERR_ERROR;
703
704 if (This->pStreams == NULL) {
705 This->pStreams = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 256 * sizeof(EditStreamTable));
706 if (This->pStreams == NULL)
707 return AVIERR_MEMORY;
708 This->nTableSize = 256;
709 }
710
711 if (lParam1 != 0) {
712 IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
714 This->pStreams[0].pStream = (PAVISTREAM)lParam1;
715 This->pStreams[0].dwStart = This->sInfo.dwStart;
716 This->pStreams[0].dwLength = This->sInfo.dwLength;
717 This->nStreams = 1;
718 }
719 return AVIERR_OK;
720}
struct IAVIStream * PAVISTREAM
Definition: vfw.h:38

◆ IEditAVIStream_fnDelete()

static HRESULT WINAPI IEditAVIStream_fnDelete ( IAVIStream iface,
LONG  start,
LONG  samples 
)
static

Definition at line 940 of file editstream.c.

942{
944
945 TRACE("(%p,%d,%d)\n",iface,start,samples);
946
947 return IAVIEditStream_Cut(&This->IAVIEditStream_iface,&start,&samples,NULL);
948}
GLsizei samples
Definition: glext.h:7006
#define IAVIEditStream_Cut(p, a, b, c)
Definition: vfw.h:1513

◆ IEditAVIStream_fnFindSample()

static LONG WINAPI IEditAVIStream_fnFindSample ( IAVIStream iface,
LONG  pos,
LONG  flags 
)
static

Definition at line 744 of file editstream.c.

746{
749 DWORD streamPos, streamNr;
750
751 TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
752
754 pos = (LONG)This->sInfo.dwStart;
755
756 /* outside of stream? */
757 if (pos < (LONG)This->sInfo.dwStart ||
758 (LONG)This->sInfo.dwStart + (LONG)This->sInfo.dwLength <= pos)
759 return -1;
760
761 /* map our position to a stream and position in it */
762 if (AVIFILE_FindStreamInTable(This, pos, &stream, &streamPos,
763 &streamNr, TRUE) != S_OK)
764 return -1; /* doesn't exist */
765
766 if (This->bDecompress) {
767 /* only one stream -- format changes only at start */
768 if (flags & FIND_FORMAT)
769 return (flags & FIND_NEXT ? -1 : 0);
770
771 /* FIXME: map positions back to us */
772 return IAVIStream_FindSample(stream, streamPos, flags);
773 } else {
774 /* assume change of format every frame */
775 return pos;
776 }
777}
GLbitfield flags
Definition: glext.h:7161
#define FIND_NEXT
Definition: vfw.h:1118
#define FIND_FROM_START
Definition: vfw.h:1120
#define FIND_FORMAT
Definition: vfw.h:1125
#define IAVIStream_FindSample(p, a, b)
Definition: vfw.h:1181

◆ IEditAVIStream_fnInfo()

static HRESULT WINAPI IEditAVIStream_fnInfo ( IAVIStream iface,
AVISTREAMINFOW psi,
LONG  size 
)
static

Definition at line 722 of file editstream.c.

724{
726
727 TRACE("(%p,%p,%d)\n",iface,psi,size);
728
729 if (psi == NULL)
730 return AVIERR_BADPARAM;
731 if (size < 0)
732 return AVIERR_BADSIZE;
733
734 if (This->bDecompress)
735 This->sInfo.fccHandler = 0;
736
737 memcpy(psi, &This->sInfo, min((DWORD)size, sizeof(This->sInfo)));
738
739 if ((DWORD)size < sizeof(This->sInfo))
741 return AVIERR_OK;
742}
#define min(a, b)
Definition: monoChain.cc:55
#define AVIERR_BUFFERTOOSMALL
Definition: vfw.h:1758

◆ IEditAVIStream_fnQueryInterface()

static HRESULT WINAPI IEditAVIStream_fnQueryInterface ( IAVIStream iface,
REFIID  refiid,
LPVOID obj 
)
static

Definition at line 677 of file editstream.c.

679{
681 return IAVIEditStream_QueryInterface(&This->IAVIEditStream_iface,refiid,obj);
682}
#define IAVIEditStream_QueryInterface(p, a, b)
Definition: vfw.h:1509

◆ IEditAVIStream_fnRead()

static HRESULT WINAPI IEditAVIStream_fnRead ( IAVIStream iface,
LONG  start,
LONG  samples,
LPVOID  buffer,
LONG  buffersize,
LONG bytesread,
LONG samplesread 
)
static

Definition at line 827 of file editstream.c.

831{
834 DWORD streamPos, streamNr;
835 LONG readBytes, readSamples, count;
836 HRESULT hr;
837
838 TRACE("(%p,%d,%d,%p,%d,%p,%p) -- 0x%08X\n",iface,start,samples,
839 buffer,buffersize,bytesread,samplesread,This->sInfo.fccType);
840
841 /* check parameters */
842 if (bytesread != NULL)
843 *bytesread = 0;
844 if (samplesread != NULL)
845 *samplesread = 0;
846 if (buffersize < 0)
847 return AVIERR_BADSIZE;
848 if ((DWORD)start < This->sInfo.dwStart ||
849 This->sInfo.dwStart + This->sInfo.dwLength < (DWORD)start)
850 return AVIERR_BADPARAM;
851
852 if (! This->bDecompress) {
853 /* audio like data -- sample-based */
854 do {
855 if (samples == 0)
856 return AVIERR_OK; /* nothing at all or already done */
857
859 &streamPos, &streamNr, FALSE)))
860 return AVIERR_ERROR;
861
862 /* limit to end of the stream */
863 count = samples;
864 if (streamPos + count > EditStreamEnd(This, streamNr))
865 count = EditStreamEnd(This, streamNr) - streamPos;
866
867 hr = IAVIStream_Read(stream, streamPos, count, buffer, buffersize,
868 &readBytes, &readSamples);
869 if (FAILED(hr))
870 return hr;
871 if (readBytes == 0 && readSamples == 0 && count != 0)
872 return AVIERR_FILEREAD; /* for bad stream implementations */
873
874 if (samplesread != NULL)
875 *samplesread += readSamples;
876 if (bytesread != NULL)
877 *bytesread += readBytes;
878 if (buffer != NULL) {
879 buffer = ((LPBYTE)buffer)+readBytes;
880 buffersize -= readBytes;
881 }
882 start += count;
883 samples -= count;
884 } while (This->sInfo.dwStart + This->sInfo.dwLength > start);
885 } else {
886 /* video like data -- frame-based */
888
889 if (samples == 0)
890 return AVIERR_OK;
891
893 &streamPos, &streamNr, FALSE)))
894 return AVIERR_ERROR;
895
896 lp = AVIFILE_ReadFrame(This, stream, streamPos);
897 if (lp == NULL)
898 return AVIERR_ERROR;
899
900 if (buffer != NULL) {
901 /* need size of format to skip */
902 if (lp->biBitCount <= 8) {
903 count = lp->biClrUsed > 0 ? lp->biClrUsed : 1 << lp->biBitCount;
904 count *= sizeof(RGBQUAD);
905 } else
906 count = 0;
907 count += lp->biSize;
908
909 if (buffersize < lp->biSizeImage)
911 memcpy(buffer, (LPBYTE)lp + count, lp->biSizeImage);
912 }
913
914 if (bytesread != NULL)
915 *bytesread = lp->biSizeImage;
916 if (samplesread != NULL)
917 *samplesread = 1;
918 }
919
920 return AVIERR_OK;
921}
ULONG RGBQUAD
Definition: precomp.h:59
GLuint buffer
Definition: glext.h:5915
DWORD biSizeImage
Definition: amvideo.idl:36
unsigned char * LPBYTE
Definition: typedefs.h:53
#define AVIERR_FILEREAD
Definition: vfw.h:1751
#define IAVIStream_Read(p, a, b, c, d, e, f)
Definition: vfw.h:1184

◆ IEditAVIStream_fnReadData()

static HRESULT WINAPI IEditAVIStream_fnReadData ( IAVIStream iface,
DWORD  fcc,
LPVOID  lp,
LONG lpread 
)
static

Definition at line 950 of file editstream.c.

952{
954 DWORD n;
955
956 TRACE("(%p,0x%08X,%p,%p)\n",iface,fcc,lp,lpread);
957
958 /* check parameters */
959 if (lp == NULL || lpread == NULL)
960 return AVIERR_BADPARAM;
961
962 /* simply ask every stream and return the first block found */
963 for (n = 0; n < This->nStreams; n++) {
964 HRESULT hr = IAVIStream_ReadData(This->pStreams[n].pStream,fcc,lp,lpread);
965
966 if (SUCCEEDED(hr))
967 return hr;
968 }
969
970 *lpread = 0;
971 return AVIERR_NODATA;
972}
#define IAVIStream_ReadData(p, a, b, c)
Definition: vfw.h:1187
#define AVIERR_NODATA
Definition: vfw.h:1757

◆ IEditAVIStream_fnReadFormat()

static HRESULT WINAPI IEditAVIStream_fnReadFormat ( IAVIStream iface,
LONG  pos,
LPVOID  format,
LONG fmtsize 
)
static

Definition at line 779 of file editstream.c.

781{
785 DWORD n;
786 HRESULT hr;
787
788 TRACE("(%p,%d,%p,%p)\n",iface,pos,format,fmtsize);
789
790 if (fmtsize == NULL || pos < This->sInfo.dwStart ||
791 This->sInfo.dwStart + This->sInfo.dwLength <= pos)
792 return AVIERR_BADPARAM;
793
794 /* find stream corresponding to position */
796 if (FAILED(hr))
797 return hr;
798
799 if (! This->bDecompress)
800 return IAVIStream_ReadFormat(stream, n, format, fmtsize);
801
803 if (lp == NULL)
804 return AVIERR_ERROR;
805 if (lp->biBitCount <= 8) {
806 n = (lp->biClrUsed > 0 ? lp->biClrUsed : 1 << lp->biBitCount);
807 n *= sizeof(RGBQUAD);
808 } else
809 n = 0;
810 n += lp->biSize;
811
812 memcpy(format, lp, min((LONG)n, *fmtsize));
813 hr = ((LONG)n > *fmtsize ? AVIERR_BUFFERTOOSMALL : AVIERR_OK);
814 *fmtsize = n;
815
816 return hr;
817}
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define IAVIStream_ReadFormat(p, a, b, c)
Definition: vfw.h:1182

◆ IEditAVIStream_fnRelease()

static ULONG WINAPI IEditAVIStream_fnRelease ( IAVIStream iface)
static

Definition at line 690 of file editstream.c.

691{
693 return IAVIEditStream_Release(&This->IAVIEditStream_iface);
694}

◆ IEditAVIStream_fnSetFormat()

static HRESULT WINAPI IEditAVIStream_fnSetFormat ( IAVIStream iface,
LONG  pos,
LPVOID  format,
LONG  formatsize 
)
static

Definition at line 819 of file editstream.c.

821{
822 TRACE("(%p,%d,%p,%d)\n",iface,pos,format,formatsize);
823
824 return AVIERR_UNSUPPORTED;
825}

◆ IEditAVIStream_fnSetInfo()

static HRESULT WINAPI IEditAVIStream_fnSetInfo ( IAVIStream iface,
AVISTREAMINFOW info,
LONG  len 
)
static

Definition at line 982 of file editstream.c.

984{
986
987 TRACE("(%p,%p,%d)\n",iface,info,len);
988
989 return IAVIEditStream_SetInfo(&This->IAVIEditStream_iface,info,len);
990}
#define IAVIEditStream_SetInfo(p, a, b)
Definition: vfw.h:1517

◆ IEditAVIStream_fnWrite()

static HRESULT WINAPI IEditAVIStream_fnWrite ( IAVIStream iface,
LONG  start,
LONG  samples,
LPVOID  buffer,
LONG  buffersize,
DWORD  flags,
LONG sampwritten,
LONG byteswritten 
)
static

Definition at line 923 of file editstream.c.

927{
928 TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n",iface,start,samples,buffer,
929 buffersize,flags,sampwritten,byteswritten);
930
931 /* be sure return parameters have correct values */
932 if (sampwritten != NULL)
933 *sampwritten = 0;
934 if (byteswritten != NULL)
935 *byteswritten = 0;
936
937 return AVIERR_UNSUPPORTED;
938}

◆ IEditAVIStream_fnWriteData()

static HRESULT WINAPI IEditAVIStream_fnWriteData ( IAVIStream iface,
DWORD  fcc,
LPVOID  lp,
LONG  size 
)
static

Definition at line 974 of file editstream.c.

976{
977 TRACE("(%p,0x%08X,%p,%d)\n",iface,fcc,lp,size);
978
979 return AVIERR_UNSUPPORTED;
980}

◆ impl_from_IAVIEditStream()

static IAVIEditStreamImpl * impl_from_IAVIEditStream ( IAVIEditStream *  iface)
inlinestatic

◆ impl_from_IAVIStream()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( avifile  )

Variable Documentation

◆ ieditstast

const struct IAVIStreamVtbl ieditstast
static
Initial value:
= {
}
static HRESULT WINAPI IEditAVIStream_fnDelete(IAVIStream *iface, LONG start, LONG samples)
Definition: editstream.c:940
static HRESULT WINAPI IEditAVIStream_fnQueryInterface(IAVIStream *iface, REFIID refiid, LPVOID *obj)
Definition: editstream.c:677
static HRESULT WINAPI IEditAVIStream_fnRead(IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, LONG *bytesread, LONG *samplesread)
Definition: editstream.c:827
static HRESULT WINAPI IEditAVIStream_fnInfo(IAVIStream *iface, AVISTREAMINFOW *psi, LONG size)
Definition: editstream.c:722
static HRESULT WINAPI IEditAVIStream_fnWrite(IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, DWORD flags, LONG *sampwritten, LONG *byteswritten)
Definition: editstream.c:923
static HRESULT WINAPI IEditAVIStream_fnSetInfo(IAVIStream *iface, AVISTREAMINFOW *info, LONG len)
Definition: editstream.c:982
static HRESULT WINAPI IEditAVIStream_fnReadFormat(IAVIStream *iface, LONG pos, LPVOID format, LONG *fmtsize)
Definition: editstream.c:779
static ULONG WINAPI IEditAVIStream_fnRelease(IAVIStream *iface)
Definition: editstream.c:690
static HRESULT WINAPI IEditAVIStream_fnReadData(IAVIStream *iface, DWORD fcc, LPVOID lp, LONG *lpread)
Definition: editstream.c:950
static HRESULT WINAPI IEditAVIStream_fnWriteData(IAVIStream *iface, DWORD fcc, LPVOID lp, LONG size)
Definition: editstream.c:974
static LONG WINAPI IEditAVIStream_fnFindSample(IAVIStream *iface, LONG pos, LONG flags)
Definition: editstream.c:744
static HRESULT WINAPI IEditAVIStream_fnSetFormat(IAVIStream *iface, LONG pos, LPVOID format, LONG formatsize)
Definition: editstream.c:819
static ULONG WINAPI IEditAVIStream_fnAddRef(IAVIStream *iface)
Definition: editstream.c:684
static HRESULT WINAPI IEditAVIStream_fnCreate(IAVIStream *iface, LPARAM lParam1, LPARAM lParam2)
Definition: editstream.c:696

Definition at line 992 of file editstream.c.

Referenced by AVIFILE_CreateEditStream().

◆ ieditstream

const struct IAVIEditStreamVtbl ieditstream
static
Initial value:
= {
}
static HRESULT WINAPI IAVIEditStream_fnSetInfo(IAVIEditStream *iface, LPAVISTREAMINFOW asi, LONG size)
Definition: editstream.c:642
static HRESULT WINAPI IAVIEditStream_fnQueryInterface(IAVIEditStream *iface, REFIID refiid, LPVOID *obj)
Definition: editstream.c:231
static ULONG WINAPI IAVIEditStream_fnAddRef(IAVIEditStream *iface)
Definition: editstream.c:254
static HRESULT WINAPI IAVIEditStream_fnCut(IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult)
Definition: editstream.c:289
static ULONG WINAPI IAVIEditStream_fnRelease(IAVIEditStream *iface)
Definition: editstream.c:264
static HRESULT WINAPI IAVIEditStream_fnPaste(IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM pSource, LONG lStart, LONG lLength)
Definition: editstream.c:417
static HRESULT WINAPI IAVIEditStream_fnClone(IAVIEditStream *iface, PAVISTREAM *ppResult)
Definition: editstream.c:605
static HRESULT WINAPI IAVIEditStream_fnCopy(IAVIEditStream *iface, LONG *plStart, LONG *plLength, PAVISTREAM *ppResult)
Definition: editstream.c:373

Definition at line 666 of file editstream.c.

Referenced by AVIFILE_CreateEditStream().