开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
FLICSource.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

FLICSource.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "stdafx.h"
  23. #include "flicsource.h"
  24. #include "......DSUtilDSUtil.h"
  26. #ifdef REGISTER_FILTER
  28. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  29. {
  30. {&MEDIATYPE_Video, &MEDIASUBTYPE_RGB32},
  31. };
  33. const AMOVIESETUP_PIN sudOpPin[] =
  34. {
  35. {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  36. };
  38. const AMOVIESETUP_FILTER sudFilter[] =
  39. {
  40. {&__uuidof(CFLICSource), L"FLICSource", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin}
  41. };
  43. CFactoryTemplate g_Templates[] =
  44. {
  45. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CFLICSource>, NULL, &sudFilter[0]}
  46. };
  48. int g_cTemplates = countof(g_Templates);
  50. STDAPI DllRegisterServer()
  51. {
  52. SetRegKeyValue(
  53. _T("Media Type\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"), 
  54. _T("0"), _T("4,2,,11AF")); 
  56. SetRegKeyValue(
  57. _T("Media Type\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"), 
  58. _T("1"), _T("4,2,,12AF"));
  60. SetRegKeyValue(
  61. _T("Media Type\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"), 
  62. _T("Source Filter"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"));
  64. SetRegKeyValue(
  65. _T("Media Type\Extensions"), _T(".fli"), 
  66. _T("Source Filter"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"));
  68. SetRegKeyValue(
  69. _T("Media Type\Extensions"), _T(".flc"), 
  70. _T("Source Filter"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"));
  72. return AMovieDllRegisterServer2(TRUE);
  73. }
  75. STDAPI DllUnregisterServer()
  76. {
  77. DeleteRegKey(_T("Media Type\{e436eb83-524f-11ce-9f53-0020af0ba770}"), _T("{17DB5CF6-39BB-4d5b-B0AA-BEBA44673AD4}"));
  78. DeleteRegKey(_T("Media Type\Extensions"), _T(".fli"));
  79. DeleteRegKey(_T("Media Type\Extensions"), _T(".flc"));
  81. return AMovieDllRegisterServer2(FALSE);
  82. }
  84. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  86. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  87. {
  88.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  89. }
  91. #endif
  93. //
  94. // CFLICSource
  95. //
  97. CFLICSource::CFLICSource(LPUNKNOWN lpunk, HRESULT* phr)
  98. : CSource(NAME("CFLICSource"), lpunk, __uuidof(this))
  99. {
  100. }
  102. CFLICSource::~CFLICSource()
  103. {
  104. }
  106. STDMETHODIMP CFLICSource::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  107. {
  108.     CheckPointer(ppv, E_POINTER);
  110. return 
  111. QI(IFileSourceFilter)
  112. QI(IAMFilterMiscFlags)
  113. __super::NonDelegatingQueryInterface(riid, ppv);
  114. }
  116. // IFileSourceFilter
  118. STDMETHODIMP CFLICSource::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) 
  119. {
  120. if(GetPinCount() > 0)
  121. return VFW_E_ALREADY_CONNECTED;
  123. HRESULT hr = S_OK;
  124. if(!(new CFLICStream(pszFileName, this, &hr)))
  125. return E_OUTOFMEMORY;
  127. if(FAILED(hr))
  128. return hr;
  130. m_fn = pszFileName;
  132. return S_OK;
  133. }
  135. STDMETHODIMP CFLICSource::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)
  136. {
  137. if(!ppszFileName) return E_POINTER;
  139. if(!(*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR))))
  140. return E_OUTOFMEMORY;
  142. wcscpy(*ppszFileName, m_fn);
  144. return S_OK;
  145. }
  147. // IAMFilterMiscFlags
  149. ULONG CFLICSource::GetMiscFlags()
  150. {
  151. return AM_FILTER_MISC_FLAGS_IS_SOURCE;
  152. }
  154. // CFLICStream
  156. CFLICStream::CFLICStream(const WCHAR* wfn, CFLICSource* pParent, HRESULT* phr) 
  157. : CSourceStream(NAME("FLICStream"), phr, pParent, L"Output")
  158. , CSourceSeeking(NAME("FLICStream"), (IPin*)this, phr, &m_cSharedState)
  159. , m_bDiscontinuity(FALSE), m_bFlushing(FALSE)
  160. {
  161. CAutoLock cAutoLock(&m_cSharedState);
  163. CString fn(wfn);
  165. if(!m_flic.Open(fn, CFile::modeRead|CFile::shareDenyWrite))
  166. {
  167. if(phr) *phr = E_FAIL;
  168. return;
  169. }
  171. if(m_flic.Read(&m_hdr, sizeof(m_hdr)) != sizeof(m_hdr)
  172. || (m_hdr.id != 0xaf11 && m_hdr.id != 0xaf12)
  173. || m_hdr.bpp != 8)
  174. {
  175. if(phr) *phr = E_FAIL;
  176. return;
  177. }
  179. m_AvgTimePerFrame = (m_hdr.id == 0xaf11)
  180. ? 10000000i64 * max(m_hdr.ticks, 1) / 70
  181. : 10000000i64 * max(m_hdr.ticks, 1) / 1000;
  183. // not tested (lack of test files)
  184. {
  185. __int64 pos = m_flic.GetPosition();
  186. FLIC_PREFIX fp;
  187. if(m_flic.Read(&fp, sizeof(fp)) != sizeof(fp) || fp.id != 0xf100) 
  188. m_flic.Seek(pos, CFile::begin);
  189. else
  190. m_flic.Seek(pos + fp.size, CFile::begin);
  191. }
  193. do
  194. {
  195. FLIC_FRAME_ENTRY ffe;
  196. if(m_flic.Read(&ffe.hdr, sizeof(ffe.hdr)) != sizeof(ffe.hdr) || ffe.hdr.id != 0xf1fa) 
  197. break;
  198. ffe.pos = m_flic.GetPosition();
  199. ffe.fKeyframe = (m_frames.GetCount() == 0);
  201. int chunk = 0;
  202. while(chunk < ffe.hdr.chunks)
  203. {
  204. FLIC_CHUNK fc;
  205. if(m_flic.Read(&fc, sizeof(fc)) != sizeof(fc))
  206. break;
  207. /*
  208. switch(fc.type)
  209. {
  210. case FLIC_COLOR: _colorchunk(); break;
  211. case FLIC_256_COLOR: _color256chunk(); break;
  212. case FLIC_BRUN: _brunchunk(); break;
  213. case FLIC_LC: _lcchunk(); break;
  214. case FLIC_DELTA: _deltachunk(); break;
  215. case FLIC_BLACK: _blackchunk(); break;
  216. case FLIC_COPY: _copychunk(); break;
  217. case FLIC_MINI: break;
  218. default: break;
  219. }
  220. */
  221. ffe.fKeyframe = 
  222. (/*fc.type == FLIC_256_COLOR
  223. || fc.type == FLIC_64_COLOR
  224. ||*/ fc.type == FLIC_BRUN 
  225. || fc.type == FLIC_BLACK 
  226. || fc.type == FLIC_COPY);
  228. __int64 pos = m_flic.GetPosition() + fc.size - sizeof(fc);
  229. if(m_flic.Seek(pos, CFile::begin) != pos)
  230. break;
  232. chunk++;
  233. }
  234. if(chunk < ffe.hdr.chunks)
  235. break;
  237. __int64 pos = ffe.pos + ffe.hdr.size - sizeof(ffe.hdr);
  238. if(m_flic.Seek(pos, CFile::begin) != pos)
  239. break;
  241. m_frames.Add(ffe);
  242. }
  243. while(1);
  245. m_nLastFrameNum = -1;
  246. memset(m_pPalette, 0, sizeof(m_pPalette));
  247. if(!m_pFrameBuffer.Allocate(m_hdr.x*m_hdr.y*32>>3))
  248. {
  249. if(phr) *phr = E_OUTOFMEMORY;
  250. return;
  251. }
  253. m_rtDuration = m_rtStop = m_AvgTimePerFrame*m_frames.GetCount();
  255. if(phr) *phr = m_rtDuration > 0 ? S_OK : E_FAIL;
  256. }
  258. CFLICStream::~CFLICStream()
  259. {
  260. CAutoLock cAutoLock(&m_cSharedState);
  261. }
  263. STDMETHODIMP CFLICStream::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  264. {
  265.     CheckPointer(ppv, E_POINTER);
  267. return (riid == IID_IMediaSeeking) ? CSourceSeeking::NonDelegatingQueryInterface(riid, ppv) //GetInterface((IMediaSeeking*)this, ppv)
  268. : CSourceStream::NonDelegatingQueryInterface(riid, ppv);
  269. }
  271. void CFLICStream::UpdateFromSeek()
  272. {
  273. if(ThreadExists())
  274. {
  275. // next time around the loop, the worker thread will
  276. // pick up the position change.
  277. // We need to flush all the existing data - we must do that here
  278. // as our thread will probably be blocked in GetBuffer otherwise
  279.     
  280. m_bFlushing = TRUE;
  282. DeliverBeginFlush();
  283. // make sure we have stopped pushing
  284. Stop();
  285. // complete the flush
  286. DeliverEndFlush();
  288.         m_bFlushing = FALSE;
  290. // restart
  291. Run();
  292. }
  293. }
  295. HRESULT CFLICStream::SetRate(double dRate)
  296. {
  297. if(dRate <= 0)
  298. return E_INVALIDARG;
  300. {
  301. CAutoLock lock(CSourceSeeking::m_pLock);
  302. m_dRateSeeking = dRate;
  303. }
  305. UpdateFromSeek();
  307. return S_OK;
  308. }
  310. HRESULT CFLICStream::OnThreadStartPlay()
  311. {
  312.     m_bDiscontinuity = TRUE;
  313.     return DeliverNewSegment(m_rtStart, m_rtStop, m_dRateSeeking);
  314. }
  316. HRESULT CFLICStream::ChangeStart()
  317. {
  318.     {
  319.         CAutoLock lock(CSourceSeeking::m_pLock);
  320. m_rtSampleTime = 0;
  321. m_rtPosition = m_rtStart;
  322.     }
  324.     UpdateFromSeek();
  326.     return S_OK;
  327. }
  329. HRESULT CFLICStream::ChangeStop()
  330. {
  331.     {
  332.         CAutoLock lock(CSourceSeeking::m_pLock);
  333.         if(m_rtPosition < m_rtStop)
  334. return S_OK;
  335.     }
  337.     // We're already past the new stop time -- better flush the graph.
  338.     UpdateFromSeek();
  340.     return S_OK;
  341. }
  343. HRESULT CFLICStream::OnThreadCreate()
  344. {
  345.     CAutoLock cAutoLockShared(&m_cSharedState);
  346.     m_rtSampleTime = 0;
  347.     m_rtPosition = m_rtStart;
  349.     return CSourceStream::OnThreadCreate();
  350. }
  352. HRESULT CFLICStream::DecideBufferSize(IMemAllocator* pAlloc, ALLOCATOR_PROPERTIES* pProperties)
  353. {
  354. //    CAutoLock cAutoLock(m_pFilter->pStateLock());
  356.     ASSERT(pAlloc);
  357.     ASSERT(pProperties);
  359.     HRESULT hr = NOERROR;
  361. pProperties->cBuffers = 1;
  362. pProperties->cbBuffer = m_hdr.x*m_hdr.y*32>>3;
  364.     ALLOCATOR_PROPERTIES Actual;
  365.     if(FAILED(hr = pAlloc->SetProperties(pProperties, &Actual))) return hr;
  367.     if(Actual.cbBuffer < pProperties->cbBuffer) return E_FAIL;
  368.     ASSERT(Actual.cBuffers == pProperties->cBuffers);
  370.     return NOERROR;
  371. }
  373. HRESULT CFLICStream::FillBuffer(IMediaSample* pSample)
  374. {
  375. HRESULT hr;
  377. {
  378. CAutoLock cAutoLockShared(&m_cSharedState);
  380.         if(m_rtPosition >= m_rtStop)
  381. return S_FALSE;
  383. BYTE* pDataIn = m_pFrameBuffer;
  384. BYTE* pDataOut = NULL;
  385. if(!pDataIn || FAILED(hr = pSample->GetPointer(&pDataOut)) || !pDataOut)
  386. return S_FALSE;
  388. AM_MEDIA_TYPE* pmt;
  389. if(SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)
  390. {
  391. CMediaType mt(*pmt);
  392. SetMediaType(&mt);
  394. DeleteMediaType(pmt);
  395. }
  397. int w, h, bpp;
  398. if(m_mt.formattype == FORMAT_VideoInfo)
  399. {
  400. w = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader.biWidth;
  401. h = abs(((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader.biHeight);
  402. bpp = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader.biBitCount;
  403. }
  404. else if(m_mt.formattype == FORMAT_VideoInfo2)
  405. {
  406. w = ((VIDEOINFOHEADER2*)m_mt.pbFormat)->bmiHeader.biWidth;
  407. h = abs(((VIDEOINFOHEADER2*)m_mt.pbFormat)->bmiHeader.biHeight);
  408. bpp = ((VIDEOINFOHEADER2*)m_mt.pbFormat)->bmiHeader.biBitCount;
  409. }
  410. else
  411. {
  412. return S_FALSE;
  413. }
  415. int pitchIn = m_hdr.x;
  416. int pitchOut = w*bpp>>3;
  418. int nFrame = m_rtPosition / m_AvgTimePerFrame; // (int)(1.0 * m_rtPosition / m_AvgTimePerFrame + 0.5);
  420. {
  421. SeekToNearestKeyFrame(nFrame);
  423. while(m_nLastFrameNum < nFrame && !m_bFlushing)
  424. ExtractFrame(++m_nLastFrameNum);
  426. for(int y = 0, p = min(pitchIn, pitchOut); 
  427. y < h; 
  428. y++, pDataIn += pitchIn, pDataOut += pitchOut)
  429. {
  430. BYTE* src = pDataIn;
  431. BYTE* end = src + p;
  432. DWORD* dst = (DWORD*)pDataOut;
  433. while(src < end) *dst++ = m_pPalette[*src++];
  434. }
  435. }
  437. pSample->SetActualDataLength(pitchOut*h);
  439. REFERENCE_TIME rtStart, rtStop;
  440.         // The sample times are modified by the current rate.
  441.         rtStart = static_cast<REFERENCE_TIME>(m_rtSampleTime / m_dRateSeeking);
  442.         rtStop  = rtStart + static_cast<int>(m_AvgTimePerFrame / m_dRateSeeking);
  443.         pSample->SetTime(&rtStart, &rtStop);
  445.         m_rtSampleTime += m_AvgTimePerFrame;
  446.         m_rtPosition += m_AvgTimePerFrame;
  447. }
  449. pSample->SetSyncPoint(TRUE);
  451. if(m_bDiscontinuity) 
  452.     {
  453. pSample->SetDiscontinuity(TRUE);
  454. m_bDiscontinuity = FALSE;
  455. }
  457. return S_OK;
  458. }
  460. HRESULT CFLICStream::GetMediaType(int iPosition, CMediaType* pmt)
  461. {
  462.     CAutoLock cAutoLock(m_pFilter->pStateLock());
  464.     if(iPosition < 0) return E_INVALIDARG;
  465.     if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  467.     pmt->SetType(&MEDIATYPE_Video);
  468.     pmt->SetSubtype(&MEDIASUBTYPE_RGB32);
  469.     pmt->SetFormatType(&FORMAT_VideoInfo);
  470.     pmt->SetTemporalCompression(TRUE);
  472. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  473. memset(vih, 0, sizeof(VIDEOINFOHEADER));
  474. vih->AvgTimePerFrame = m_AvgTimePerFrame;
  475. vih->bmiHeader.biSize = sizeof(vih->bmiHeader);
  476. vih->bmiHeader.biWidth = m_hdr.x;
  477. vih->bmiHeader.biHeight = -m_hdr.y;
  478. vih->bmiHeader.biPlanes = 1;
  479. vih->bmiHeader.biBitCount = 32;
  480. vih->bmiHeader.biCompression = BI_RGB;
  481. vih->bmiHeader.biSizeImage = m_hdr.x*m_hdr.y*32>>3;
  483. pmt->SetSampleSize(vih->bmiHeader.biSizeImage);
  485.     return NOERROR;
  486. }
  488. HRESULT CFLICStream::CheckConnect(IPin* pPin)
  489. {
  490. return CSourceStream::CheckConnect(pPin);
  491. }
  493. HRESULT CFLICStream::CheckMediaType(const CMediaType* pmt)
  494. {
  495. if(pmt->majortype == MEDIATYPE_Video
  496. && pmt->subtype == MEDIASUBTYPE_RGB32
  497. && pmt->formattype == FORMAT_VideoInfo) return S_OK;
  499. return E_INVALIDARG;
  500. }
  502. STDMETHODIMP CFLICStream::Notify(IBaseFilter* pSender, Quality q)
  503. {
  504. return E_NOTIMPL;
  505. }
  507. ////////
  509. void CFLICStream::SeekToNearestKeyFrame(int nFrame)
  510. {
  511. if(m_nLastFrameNum == nFrame)
  512. return;
  514. if(m_nLastFrameNum > nFrame)
  515. m_nLastFrameNum = -1;
  517. for(int i = m_nLastFrameNum+1, j = min(m_frames.GetCount(), nFrame); i < j; i++)
  518. {
  519. FLIC_FRAME_ENTRY& ffe = m_frames[i];
  520. if(ffe.fKeyframe) 
  521. m_nLastFrameNum = i-1;
  522. }
  523. }
  525. void CFLICStream::ExtractFrame(int nFrame)
  526. {
  527. FLIC_FRAME_ENTRY& ffe = m_frames[nFrame];
  529. bool fNewPalette = false;
  530. bool fNewFrame = false;
  532. m_flic.Seek(ffe.pos, CFile::begin);
  534. int chunk = 0;
  535. while(chunk < ffe.hdr.chunks)
  536. {
  537. FLIC_CHUNK fc;
  538. if(m_flic.Read(&fc, sizeof(fc)) != sizeof(fc))
  539. break;
  541. __int64 next = m_flic.GetPosition() + fc.size - sizeof(fc);
  543. switch(fc.type)
  544. {
  545. case FLIC_64_COLOR: fNewPalette = _colorchunk(true); break;
  546. case FLIC_256_COLOR: fNewPalette = _colorchunk(false); break;
  547. case FLIC_BRUN: _brunchunk(); fNewFrame = true; break;
  548. case FLIC_LC: _lcchunk(); break;
  549. case FLIC_DELTA: _deltachunk(); break;
  550. case FLIC_BLACK: _blackchunk(); fNewFrame = true; break;
  551. case FLIC_COPY: _copychunk(); fNewFrame = true; break;
  552. case FLIC_MINI: break;
  553. default: break;
  554. }
  556. if(m_flic.Seek(next, CFile::begin) != next)
  557. break;
  559. chunk++;
  560. }
  562. if(chunk < ffe.hdr.chunks)
  563. ASSERT(0);
  565. ffe.fKeyframe = (fNewPalette && fNewFrame);
  566. }
  568. void CFLICStream::_blackchunk()
  569. {
  570. memset(m_pFrameBuffer, 0, m_hdr.x*m_hdr.y*32>>3);
  571. }
  573. void CFLICStream::_copychunk()
  574. {
  575. m_flic.Read(m_pFrameBuffer, m_hdr.x*m_hdr.y*32>>3);
  576. }
  578. bool CFLICStream::_colorchunk(bool f64)
  579. {
  580. int nColorsUpdated = 0;
  582. BYTE skip = 0;
  584. WORD packets;
  585. m_flic.Read(&packets, sizeof(packets));
  587. while(packets--)
  588. {
  589. BYTE skip2;
  590. m_flic.Read(&skip2, sizeof(skip2));
  591. skip += skip2;
  593. BYTE count;
  594. m_flic.Read(&count, sizeof(count));
  596. int len = (count == 0 ? (256-skip) : count);
  597. while(len-- > 0)
  598. {
  599. BYTE r, g, b;
  600. m_flic.Read(&r, sizeof(r));
  601. m_flic.Read(&g, sizeof(g));
  602. m_flic.Read(&b, sizeof(b));
  603. m_pPalette[skip++] = f64 
  604. ? ((r << 18)&0xff0000) | ((g << 10)&0xff00) | ((b << 2)&0xff)
  605. : ((r << 16)&0xff0000) | ((g << 8)&0xff00) | ((b << 0)&0xff);
  606. nColorsUpdated++;
  607. }
  608. }
  610. return(nColorsUpdated == 256);
  611. }
  613. void CFLICStream::_brunchunk()
  614. {
  615. BYTE* tmp = m_pFrameBuffer;
  617. int lines = m_hdr.y;
  618. while(lines--)
  619. {
  620. BYTE packets;
  621. m_flic.Read(&packets, sizeof(packets));
  623. BYTE* ptr = tmp;
  625. while(ptr < tmp + m_hdr.x)
  626. {
  627. signed char count;
  628. m_flic.Read(&count, sizeof(count));
  630. if(count >= 0)
  631. {
  632. BYTE c;
  633. m_flic.Read(&c, sizeof(c));
  634. memset(ptr, c, count);
  635. ptr += count;
  636. }
  637. else
  638. {
  639. m_flic.Read(ptr, -count);
  640. ptr += -count;
  641. }
  642. }
  644. tmp += m_hdr.x;
  645. }
  646. }
  648. void CFLICStream::_lcchunk()
  649. {
  650. WORD y;
  651. m_flic.Read(&y, sizeof(y));
  653. BYTE* tmp = &m_pFrameBuffer[y*m_hdr.x];
  655. WORD lines;
  656. m_flic.Read(&lines, sizeof(lines));
  658. while(lines--)
  659. {
  660. BYTE* ptr = tmp;
  662. BYTE packets;
  663. m_flic.Read(&packets, sizeof(packets));
  665. while(packets--)
  666. {
  667. BYTE skip;
  668. m_flic.Read(&skip, sizeof(skip));
  670. ptr += skip;
  672. signed char count;
  673. m_flic.Read(&count, sizeof(count));
  675. if(count >= 0)
  676. {
  677. m_flic.Read(ptr, count);
  678. ptr += count;
  679. }
  680. else
  681. {
  682. BYTE c;
  683. m_flic.Read(&c, sizeof(c));
  684. memset(ptr, c, -count);
  685. ptr += -count;
  686. }
  687. }
  689. tmp += m_hdr.x;
  690. }
  691. }
  693. void CFLICStream::_deltachunk()
  694. {
  695. BYTE* tmp = m_pFrameBuffer;
  697. WORD lines;
  698. m_flic.Read(&lines, sizeof(lines));
  700. while(lines--)
  701. {
  702. signed short packets;
  703. m_flic.Read(&packets, sizeof(packets));
  705. if(packets < 0)
  706. {
  707. if(packets&0x4000)
  708. {
  709. tmp += -packets * m_hdr.x;
  710. lines++;
  711. }
  712. else
  713. {
  714. signed char count;
  715. m_flic.Read(&count, sizeof(count));
  716. tmp[m_hdr.x-1] = (BYTE)packets;
  717. }
  718. }
  719. else
  720. {
  721. BYTE* ptr = tmp;
  723. while(packets--)
  724. {
  725. BYTE skip;
  726. m_flic.Read(&skip, sizeof(skip));
  728. ptr += skip;
  730. signed char count;
  731. m_flic.Read(&count, sizeof(count));
  733. if(count >= 0)
  734. {
  735. m_flic.Read(ptr, count << 1);
  736. ptr += count << 1;
  737. }
  738. else
  739. {
  740. WORD c;
  741. m_flic.Read(&c, sizeof(c));
  742. count = -count;
  743. while(count-- > 0)
  744. {
  745. *ptr++ = c>>8;
  746. *ptr++ = c&0xff;
  747. }
  748. }
  749. }
  751. tmp += m_hdr.x;
  752. }
  753. }
  754. }