1 #include "fixer.h"
2
3 #include "media.hpp"
4
GetWriteBuffer(unsigned * pSize,unsigned)5 void * MediaMedium::GetWriteBuffer(unsigned * pSize, unsigned /*nDesiredSize*/)
6 {
7 *pSize = 0;
8 m_fError |= MME_UNAVAIL;
9 return NULL;
10 }
11
GetReadBuffer(unsigned * pSize,unsigned)12 void const * MediaMedium::GetReadBuffer(unsigned * pSize, unsigned /*nDesiredSize*/)
13 {
14 *pSize = 0;
15 m_fError |= MME_UNAVAIL;
16 return NULL;
17 }
18
CloseWriteBuffer(unsigned)19 void MediaMedium::CloseWriteBuffer(unsigned /*nPosOffset*/)
20 {
21 m_fError |= MME_UNAVAIL;
22 }
23
CloseReadBuffer(unsigned)24 void MediaMedium::CloseReadBuffer(unsigned /*nPosOffset*/)
25 {
26 m_fError |= MME_UNAVAIL;
27 }
28
DoWriteBlock(void const *,unsigned)29 void MediaMedium::DoWriteBlock(void const * /*pData*/, unsigned /*nSize*/)
30 {
31 m_fError |= MME_UNAVAIL;
32 }
33
DoReadBlock(void *,unsigned)34 void MediaMedium::DoReadBlock(void * /*pData*/, unsigned /*nSize*/)
35 {
36 m_fError |= MME_UNAVAIL;
37 }
38
GetRemainingSize()39 unsigned MediaMedium::GetRemainingSize()
40 {
41 return UINT_MAX;
42 }
43
44 // MediaWinFileMedium
45
46 #ifdef _MEDIA_WIN_TARGET
47
GetRemainingSize()48 unsigned MediaWinFileMedium::GetRemainingSize()
49 {
50 if (INVALID_HANDLE_VALUE == m_hFile)
51 {
52 m_fError |= MME_UNAVAIL;
53 return 0;
54 }
55
56 unsigned nSize = GetFileSize(m_hFile, 0);
57
58 if (0xffffffff == nSize)
59 {
60 m_fError |= MME_UNAVAIL;
61 return 0;
62 }
63
64 return nSize - GetPos();
65 }
66
GetWriteBuffer(unsigned * pSize,unsigned nDesiredSize)67 void * MediaWinFileMedium::GetWriteBuffer(unsigned * pSize, unsigned nDesiredSize)
68 {
69 m_pBuffer = new char [nDesiredSize];
70 *pSize = nDesiredSize;
71 return m_pBuffer;
72 }
73
GetReadBuffer(unsigned * pSize,unsigned nDesiredSize)74 void const * MediaWinFileMedium::GetReadBuffer(unsigned * pSize, unsigned nDesiredSize)
75 {
76 if (INVALID_HANDLE_VALUE == m_hFile)
77 // the base/default implementation raises an error
78 return MediaMedium::GetReadBuffer(pSize,nDesiredSize);
79
80 m_pBuffer = new char [nDesiredSize];
81
82 DWORD nBytesRead = 0;
83
84 if (!ReadFile(m_hFile, m_pBuffer, nDesiredSize, &nBytesRead, 0))
85 m_fError |= MME_IOERROR;
86 else if (!nBytesRead)
87 m_fError |= MME_EOFMET;
88
89 *pSize = m_nReadBufLen = nBytesRead;
90
91 return m_pBuffer;
92 }
93
CloseWriteBuffer(unsigned nPosOffset)94 void MediaWinFileMedium::CloseWriteBuffer(unsigned nPosOffset)
95 {
96 if (INVALID_HANDLE_VALUE == m_hFile)
97 {
98 // the base/default implementation raises an error
99 MediaMedium::CloseWriteBuffer(nPosOffset);
100 return;
101 }
102
103 DWORD nBytesWritten = 0;
104
105 if (!WriteFile(m_hFile, m_pBuffer, nPosOffset, &nBytesWritten, 0))
106 m_fError |= MME_IOERROR;
107 else if (nBytesWritten < nPosOffset)
108 m_fError |= MME_EOFMET;
109
110 delete [] m_pBuffer;
111 }
112
CloseReadBuffer(unsigned nPosOffset)113 void MediaWinFileMedium::CloseReadBuffer(unsigned nPosOffset)
114 {
115 if (INVALID_HANDLE_VALUE == m_hFile)
116 {
117 // the base/default implementation raises an error
118 MediaMedium::CloseReadBuffer(nPosOffset);
119 return;
120 }
121
122 if (nPosOffset != m_nReadBufLen && 0xffffffff == SetFilePointer(m_hFile,nPosOffset - m_nReadBufLen,0,FILE_CURRENT))
123 m_fError |= MME_UNAVAIL;
124
125 m_nReadBufLen = 0;
126
127 delete [] m_pBuffer;
128 }
129
DoWriteBlock(void const * pData,unsigned nSize)130 void MediaWinFileMedium::DoWriteBlock(void const * pData, unsigned nSize)
131 {
132 if (INVALID_HANDLE_VALUE == m_hFile)
133 {
134 MediaMedium::DoWriteBlock(pData,nSize);
135 return;
136 }
137
138 DWORD nBytesWritten = 0;
139
140 if (!WriteFile(m_hFile, pData, nSize, &nBytesWritten, 0))
141 m_fError |= MME_IOERROR;
142 else if (nBytesWritten < nSize)
143 m_fError |= MME_EOFMET;
144 }
145
DoReadBlock(void * pData,unsigned nSize)146 void MediaWinFileMedium::DoReadBlock(void * pData, unsigned nSize)
147 {
148 if (INVALID_HANDLE_VALUE == m_hFile)
149 {
150 MediaMedium::DoReadBlock(pData,nSize);
151 return;
152 }
153
154 DWORD nBytesRead = 0;
155
156 if (!ReadFile(m_hFile, pData, nSize, &nBytesRead, 0))
157 m_fError |= MME_IOERROR;
158 else if (nBytesRead < nSize)
159 m_fError |= MME_EOFMET;
160 }
161
DoGetPos()162 unsigned MediaWinFileMedium::DoGetPos()
163 {
164 unsigned nFilePos = SetFilePointer(m_hFile,0,0,FILE_CURRENT);
165
166 if (0xffffffff == nFilePos)
167 {
168 m_fError |= MME_UNAVAIL;
169 return 0;
170 }
171
172 return nFilePos - m_nReadBufLen;
173 }
174
DoSetPos(unsigned nPos)175 void MediaWinFileMedium::DoSetPos(unsigned nPos)
176 {
177 if (0xffffffff == SetFilePointer(m_hFile,nPos,0,FILE_BEGIN))
178 m_fError |= MME_UNAVAIL;
179 }
180
181 #endif // _MEDIA_WIN_TARGET
182
183 // MediaStdFileMedium
184
GetRemainingSize()185 unsigned MediaStdFileMedium::GetRemainingSize()
186 {
187 if (!m_pFile)
188 {
189 m_fError |= MME_UNAVAIL;
190 return 0;
191 }
192
193 long nPos = ftell(m_pFile);
194
195 if (-1L == nPos || fseek(m_pFile,0,SEEK_END))
196 {
197 m_fError |= MME_UNAVAIL;
198 return 0;
199 }
200
201 long nSize = ftell(m_pFile);
202
203 fseek(m_pFile,nPos,SEEK_SET);
204
205 if (-1L == nSize)
206 {
207 m_fError |= MME_UNAVAIL;
208 return 0;
209 }
210
211 return nSize - GetPos();
212 }
213
GetWriteBuffer(unsigned * pSize,unsigned nDesiredSize)214 void * MediaStdFileMedium::GetWriteBuffer(unsigned * pSize, unsigned nDesiredSize)
215 {
216 m_pBuffer = new char [nDesiredSize];
217 *pSize = nDesiredSize;
218 return m_pBuffer;
219 }
220
GetReadBuffer(unsigned * pSize,unsigned nDesiredSize)221 void const * MediaStdFileMedium::GetReadBuffer(unsigned * pSize, unsigned nDesiredSize)
222 {
223 if (!m_pFile)
224 // the base/default implementation raises an error
225 return MediaMedium::GetReadBuffer(pSize,nDesiredSize);
226
227 m_pBuffer = new char [nDesiredSize];
228
229 *pSize = m_nReadBufLen = fread(m_pBuffer, 1, nDesiredSize, m_pFile);
230
231 if (!m_nReadBufLen)
232 {
233 if (feof(m_pFile))
234 m_fError |= MME_EOFMET;
235 else
236 m_fError |= MME_IOERROR;
237 }
238
239 return m_pBuffer;
240 }
241
CloseWriteBuffer(unsigned nPosOffset)242 void MediaStdFileMedium::CloseWriteBuffer(unsigned nPosOffset)
243 {
244 if (!m_pFile)
245 {
246 // the base/default implementation raises an error
247 MediaMedium::CloseWriteBuffer(nPosOffset);
248 return;
249 }
250
251 if (fwrite(m_pBuffer, 1, nPosOffset, m_pFile) < nPosOffset)
252 {
253 if (feof(m_pFile))
254 m_fError |= MME_EOFMET;
255 else
256 m_fError |= MME_IOERROR;
257 }
258
259 delete [] m_pBuffer;
260 }
261
CloseReadBuffer(unsigned nPosOffset)262 void MediaStdFileMedium::CloseReadBuffer(unsigned nPosOffset)
263 {
264 if (!m_pFile)
265 {
266 // the base/default implementation raises an error
267 MediaMedium::CloseReadBuffer(nPosOffset);
268 return;
269 }
270
271 if (nPosOffset != m_nReadBufLen && fseek(m_pFile,nPosOffset - m_nReadBufLen,SEEK_CUR))
272 m_fError |= MME_UNAVAIL;
273
274 m_nReadBufLen = 0;
275 delete [] m_pBuffer;
276 }
277
DoWriteBlock(void const * pData,unsigned nSize)278 void MediaStdFileMedium::DoWriteBlock(void const * pData, unsigned nSize)
279 {
280 if (!m_pFile)
281 {
282 MediaMedium::DoWriteBlock(pData,nSize);
283 return;
284 }
285
286 if (fwrite(pData, 1, nSize, m_pFile) < nSize)
287 {
288 if (feof(m_pFile))
289 m_fError |= MME_EOFMET;
290 else
291 m_fError |= MME_IOERROR;
292 }
293 }
294
DoReadBlock(void * pData,unsigned nSize)295 void MediaStdFileMedium::DoReadBlock(void * pData, unsigned nSize)
296 {
297 if (!m_pFile)
298 {
299 MediaMedium::DoReadBlock(pData,nSize);
300 return;
301 }
302
303 if (fread(pData, 1, nSize, m_pFile) < nSize)
304 {
305 if (feof(m_pFile))
306 m_fError |= MME_EOFMET;
307 else
308 m_fError |= MME_IOERROR;
309 }
310 }
311
DoGetPos()312 unsigned MediaStdFileMedium::DoGetPos()
313 {
314 long nFilePos = ftell(m_pFile);
315
316 if (-1L == nFilePos)
317 {
318 m_fError |= MME_UNAVAIL;
319 return 0;
320 }
321
322 return nFilePos - m_nReadBufLen;
323 }
324
DoSetPos(unsigned nPos)325 void MediaStdFileMedium::DoSetPos(unsigned nPos)
326 {
327 if (fseek(m_pFile,nPos,SEEK_SET))
328 m_fError |= MME_UNAVAIL;
329 }
330
331 // MediaMemoryReadMedium
332
GetReadBuffer(unsigned * pSize,unsigned nDesiredSize)333 void const * MediaMemoryReadMedium::GetReadBuffer(unsigned * pSize, unsigned nDesiredSize)
334 {
335 if (!m_pMem)
336 // the base/default implementation raises an error
337 return MediaMedium::GetReadBuffer(pSize,nDesiredSize);
338
339 *pSize = nDesiredSize;
340
341 return static_cast<char const *>(m_pMem)+m_nOffset/sizeof(char);
342 }
343
CloseReadBuffer(unsigned nPosOffset)344 void MediaMemoryReadMedium::CloseReadBuffer(unsigned nPosOffset)
345 {
346 if (!m_pMem)
347 {
348 // the base/default implementation raises an error
349 MediaMedium::CloseReadBuffer(nPosOffset);
350 return;
351 }
352
353 m_nOffset += nPosOffset;
354 }
355
DoReadBlock(void * pData,unsigned nSize)356 void MediaMemoryReadMedium::DoReadBlock(void * pData, unsigned nSize)
357 {
358 if (!m_pMem)
359 {
360 MediaMedium::DoReadBlock(pData,nSize);
361 return;
362 }
363
364 memcpy(pData,static_cast<char const *>(m_pMem)+m_nOffset/sizeof(char),nSize);
365
366 m_nOffset += nSize;
367 }
368
DoGetPos()369 unsigned MediaMemoryReadMedium::DoGetPos()
370 {
371 return m_nOffset;
372 }
373
DoSetPos(unsigned nPos)374 void MediaMemoryReadMedium::DoSetPos(unsigned nPos)
375 {
376 m_nOffset = nPos;
377 }
378
379 // MediaMemoryMedium
380
GetWriteBuffer(unsigned * pSize,unsigned nDesiredSize)381 void * MediaMemoryMedium::GetWriteBuffer(unsigned * pSize, unsigned nDesiredSize)
382 {
383 if (!m_pMem)
384 // the base/default implementation raises an error
385 return MediaMedium::GetWriteBuffer(pSize,nDesiredSize);
386
387 *pSize = nDesiredSize;
388
389 return static_cast<char *>(m_pMem)+m_nOffset/sizeof(char);
390 }
391
CloseWriteBuffer(unsigned nPosOffset)392 void MediaMemoryMedium::CloseWriteBuffer(unsigned nPosOffset)
393 {
394 if (!m_pMem)
395 {
396 // the base/default implementation raises an error
397 MediaMedium::CloseWriteBuffer(nPosOffset);
398 return;
399 }
400
401 m_nOffset += nPosOffset;
402 }
403
DoWriteBlock(void const * pData,unsigned nSize)404 void MediaMemoryMedium::DoWriteBlock(void const * pData, unsigned nSize)
405 {
406 if (!m_pMem)
407 {
408 MediaMedium::DoWriteBlock(pData,nSize);
409 return;
410 }
411
412 memcpy(static_cast<char *>(m_pMem)+m_nOffset/sizeof(char),pData,nSize);
413
414 m_nOffset += nSize;
415 }
416
417 // MediaSection
418
GetRemainingSize()419 unsigned MediaSection::GetRemainingSize()
420 {
421 if (!m_pMedium)
422 {
423 m_fError |= MME_UNAVAIL;
424 return 0;
425 }
426
427 unsigned nSectionSize = m_nMaxSize - GetPos();
428 unsigned nMediaSize = m_pMedium->GetRemainingSize();
429 m_fError |= m_pMedium->m_fError;
430
431 return nSectionSize < nMediaSize ? nSectionSize : nMediaSize;
432 }
433
GetWriteBuffer(unsigned * pSize,unsigned nDesiredSize)434 void * MediaSection::GetWriteBuffer(unsigned * pSize, unsigned nDesiredSize)
435 {
436 if (!m_pMedium)
437 return MediaMedium::GetWriteBuffer(pSize,nDesiredSize);
438
439 if (m_nPos + nDesiredSize > m_nMaxSize)
440 {
441 nDesiredSize = m_nMaxSize - m_nPos;
442 }
443
444 void * p = m_pMedium->GetWriteBuffer(pSize,nDesiredSize);
445 m_fError |= m_pMedium->m_fError;
446 return p;
447 }
448
GetReadBuffer(unsigned * pSize,unsigned nDesiredSize)449 void const * MediaSection::GetReadBuffer(unsigned * pSize, unsigned nDesiredSize)
450 {
451 if (!m_pMedium)
452 return MediaMedium::GetReadBuffer(pSize,nDesiredSize);
453
454 if (m_nPos + nDesiredSize > m_nMaxSize)
455 {
456 nDesiredSize = m_nMaxSize - m_nPos;
457 }
458
459 void const * p = m_pMedium->GetReadBuffer(pSize,nDesiredSize);
460 m_fError |= m_pMedium->m_fError;
461 return p;
462 }
463
CloseWriteBuffer(unsigned nPosOffset)464 void MediaSection::CloseWriteBuffer(unsigned nPosOffset)
465 {
466 if (!m_pMedium)
467 {
468 MediaMedium::CloseWriteBuffer(nPosOffset);
469 return;
470 }
471
472 m_nPos += nPosOffset;
473
474 m_pMedium->CloseWriteBuffer(nPosOffset);
475 m_fError |= m_pMedium->m_fError;
476 }
477
CloseReadBuffer(unsigned nPosOffset)478 void MediaSection::CloseReadBuffer(unsigned nPosOffset)
479 {
480 if (!m_pMedium)
481 {
482 MediaMedium::CloseReadBuffer(nPosOffset);
483 return;
484 }
485
486 m_nPos += nPosOffset;
487
488 m_pMedium->CloseReadBuffer(nPosOffset);
489 m_fError |= m_pMedium->m_fError;
490 }
491
DoWriteBlock(void const * pData,unsigned nSize)492 void MediaSection::DoWriteBlock(void const * pData, unsigned nSize)
493 {
494 if (!m_pMedium)
495 {
496 MediaMedium::DoWriteBlock(pData,nSize);
497 return;
498 }
499
500 if (m_nPos + nSize > m_nMaxSize)
501 {
502 m_fError |= MME_VEOFMET;
503 return;
504 }
505
506 m_nPos += nSize;
507
508 m_pMedium->DoWriteBlock(pData,nSize);
509 m_fError |= m_pMedium->m_fError;
510 }
511
DoReadBlock(void * pData,unsigned nSize)512 void MediaSection::DoReadBlock(void * pData, unsigned nSize)
513 {
514 if (!m_pMedium)
515 {
516 MediaMedium::DoReadBlock(pData,nSize);
517 return;
518 }
519
520 if (m_nPos + nSize > m_nMaxSize)
521 {
522 m_fError |= MME_VEOFMET;
523 return;
524 }
525
526 m_nPos += nSize;
527
528 m_pMedium->DoReadBlock(pData,nSize);
529 m_fError |= m_pMedium->m_fError;
530 }
531
DoGetPos()532 unsigned MediaSection::DoGetPos()
533 {
534 return m_nPos;
535 }
536
DoSetPos(unsigned nPos)537 void MediaSection::DoSetPos(unsigned nPos)
538 {
539 if (!m_pMedium)
540 {
541 m_fError |= MME_UNAVAIL;
542 return;
543 }
544
545 if (nPos > m_nMaxSize)
546 {
547 m_fError |= MME_VEOFMET;
548 return;
549 }
550
551 m_pMedium->DoSetPos(m_pMedium->DoGetPos()+nPos-m_nPos);
552 if (m_nPos > m_nUsedPos) m_nUsedPos = m_nPos;
553 m_nPos = nPos;
554
555 m_fError |= m_pMedium->m_fError;
556 }
557
558