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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PALMAP.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：13k
源码类别：

Windows编程

开发平台：

Visual C++

PALMAP.C：源码内容
  1. /****************************************************************************
  2.  *
  3.  *  PALMAP.C
  4.  *
  5.  *  Stream handler to map to a palette.
  6.  *
  7.  ***************************************************************************/
  9. /**************************************************************************
  10.  *
  11.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  12.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  13.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  14.  *  PURPOSE.
  15.  *
  16.  *  Copyright (C) 1992 - 1997 Microsoft Corporation.  All Rights Reserved.
  17.  *
  18.  **************************************************************************/
  20. #define INC_OLE2
  21. #include <windows.h>
  22. #include <windowsx.h>
  23. #include <mmsystem.h>
  24. #include <vfw.h>
  25. #include <string.h>
  27. #include "dibmap.h"
  28. #include "palmap.h"
  29. #include "palmap.rc"
  31. #define INITGUID
  32. #include <initguid.h>
  34. // Bring in the external GUIDs we need. Apparently compobj.lib doesn't define
  35. DEFINE_OLEGUID(IID_IUnknown, 0x00000000L, 0, 0);
  38. HINSTANCE ghMod;
  40. STDAPI AVIStreamMakePalette(
  41. PAVISTREAM pavi,
  42. LONG lSkip,
  43. HPALETTE FAR *lphpal,
  44. LPBYTE lp16to8,
  45. int nColors)
  46. {
  47. LPHISTOGRAM lpHist = NULL;
  48. LONG l, lEnd;
  49. LONG lRet = AVIERR_OK;
  50. PGETFRAME pgf = NULL;
  52. if (!pavi || !lphpal || nColors < 2 || nColors > 256)
  53. return ResultFromScode(AVIERR_BADPARAM);
  55. if (lSkip < 1)
  56. lSkip = 1;
  58. lpHist = InitHistogram(NULL);
  59. if (!lpHist)
  60. return ResultFromScode(AVIERR_MEMORY);
  62. pgf = AVIStreamGetFrameOpen(pavi, NULL);
  64. l = AVIStreamStart(pavi);
  65. lEnd = l + AVIStreamLength(pavi);
  66. for (l = AVIStreamStart(pavi), lEnd = l + AVIStreamLength(pavi);
  67. l < lEnd;
  68. l += lSkip) {
  69. LPBITMAPINFOHEADER lpbi;
  71. lpbi = AVIStreamGetFrame(pgf, l);
  73. if (!lpbi) {
  74. lRet = AVIERR_INTERNAL;
  75. goto error;
  76. }
  78. DibHistogram(lpbi, NULL, 0, 0, -1, -1, lpHist);
  79. }
  81. *lphpal = HistogramPalette(lpHist, lp16to8, nColors);
  83. if (!*lphpal)
  84. lRet = AVIERR_MEMORY;
  86. error:
  87. if (pgf)
  88. AVIStreamGetFrameClose(pgf);
  90. if (lpHist)
  91. FreeHistogram(lpHist);
  93. return ResultFromScode(lRet);
  94. }
  98. typedef struct {
  99. IAVIStreamVtbl FAR * lpVtbl;
  101. ULONG ulRefCount;
  103. //
  104. // instance data
  105. //
  106. PAVISTREAM pavi;
  107. PGETFRAME pgf;
  108. AVISTREAMINFO sinfo;
  109. HPALETTE hpal;
  110. LPBYTE lp16to8;
  111. LONG lLastFrame;
  112. LPBITMAPINFOHEADER lpdibLast;
  113. } PALMAPSTREAM, FAR*PPALMAPSTREAM;
  115. ///////////////////////////////////////////////////////////////////////////
  116. ///////////////////////////////////////////////////////////////////////////
  118. HRESULT STDMETHODCALLTYPE PalMapStreamQueryInterface(
  119. PAVISTREAM ps,
  120. REFIID riid,
  121. LPVOID FAR* ppvObj);
  122. HRESULT STDMETHODCALLTYPE PalMapStreamCreate(
  123. PAVISTREAM ps,
  124. LONG lParam1,
  125. LONG lParam2);
  126. ULONG STDMETHODCALLTYPE PalMapStreamAddRef(
  127. PAVISTREAM ps);
  128. ULONG STDMETHODCALLTYPE PalMapStreamRelease(
  129. PAVISTREAM ps);
  130. HRESULT STDMETHODCALLTYPE PalMapStreamInfo(
  131. PAVISTREAM ps,
  132. AVISTREAMINFOW FAR * psi,
  133. LONG lSize);
  134. LONG STDMETHODCALLTYPE PalMapStreamFindKeyFrame(
  135. PAVISTREAM ps,
  136. LONG lPos,
  137. LONG lFlags);
  138. HRESULT STDMETHODCALLTYPE PalMapStreamReadFormat(
  139. PAVISTREAM ps,
  140. LONG lPos,
  141. LPVOID lpFormat,
  142. LONG FAR *lpcbFormat);
  143. HRESULT STDMETHODCALLTYPE PalMapStreamSetFormat(
  144. PAVISTREAM ps,
  145. LONG lPos,
  146. LPVOID lpFormat,
  147. LONG cbFormat);
  148. HRESULT STDMETHODCALLTYPE PalMapStreamRead(
  149. PAVISTREAM ps,
  150. LONG lStart,
  151. LONG lSamples,
  152. LPVOID lpBuffer,
  153. LONG cbBuffer,
  154. LONG FAR * plBytes,
  155. LONG FAR * plSamples);
  156. HRESULT STDMETHODCALLTYPE PalMapStreamWrite(
  157. PAVISTREAM ps,
  158. LONG lStart,
  159. LONG lSamples,
  160. LPVOID lpBuffer,
  161. LONG cbBuffer,
  162. DWORD dwFlags,
  163. LONG FAR *plSampWritten,
  164. LONG FAR *plBytesWritten);
  165. HRESULT STDMETHODCALLTYPE PalMapStreamDelete(
  166. PAVISTREAM ps,
  167. LONG lStart,
  168. LONG lSamples);
  169. HRESULT STDMETHODCALLTYPE PalMapStreamReadData(
  170. PAVISTREAM ps,
  171. DWORD fcc,
  172. LPVOID lp,
  173. LONG FAR *lpcb);
  174. HRESULT STDMETHODCALLTYPE PalMapStreamWriteData(
  175. PAVISTREAM ps,
  176. DWORD fcc,
  177. LPVOID lp,
  178. LONG cb);
  179. HRESULT STDMETHODCALLTYPE PalMapStreamSetInfo(
  180.         PAVISTREAM ps,
  181.         AVISTREAMINFOW FAR * psi,
  182.         LONG lSize);
  184. IAVIStreamVtbl PalMapStreamHandler = {
  185. PalMapStreamQueryInterface,
  186. PalMapStreamAddRef,
  187. PalMapStreamRelease,
  188. PalMapStreamCreate,
  189. PalMapStreamInfo,
  190. PalMapStreamFindKeyFrame,
  191. PalMapStreamReadFormat,
  192. PalMapStreamSetFormat,
  193. PalMapStreamRead,
  194. PalMapStreamWrite,
  195. PalMapStreamDelete,
  196. PalMapStreamReadData,
  197. PalMapStreamWriteData,
  198.         PalMapStreamSetInfo
  199. };
  201. STDAPI AVICreateMappedStream(PAVISTREAM FAR *ppsMapped,
  202. PAVISTREAM ps,
  203. int nColors)
  204. {
  205. PPALMAPSTREAM pavi;
  206. HRESULT hr;
  208. *ppsMapped = 0;
  210. pavi = (PPALMAPSTREAM) GlobalAllocPtr(GHND, sizeof(PALMAPSTREAM));
  211. if (pavi == NULL)
  212. return ResultFromScode(AVIERR_MEMORY);
  214. pavi->lpVtbl = &PalMapStreamHandler;
  216. hr = (pavi->lpVtbl->Create)((PAVISTREAM) pavi, (LONG) ps, nColors);
  218. if (hr != NOERROR) {
  219. (pavi->lpVtbl->Release)((PAVISTREAM) pavi);
  220. return hr;
  221. }
  223. *ppsMapped = (PAVISTREAM) pavi;
  225. return AVIERR_OK;
  228. }
  230. ///////////////////////////////////////////////////////////////////////////
  231. //
  232. //  PalMapStreamOpen()
  233. //
  234. //  open a single stream of a particular type from a AVI file.
  235. //
  236. //  params:
  237. //      szFile      - PAVISTREAM
  238. //      fccType     - must be streamtypeVIDEO
  239. //      lParam     - nColors
  240. //
  241. //  returns:
  242. //      a PAVISTREAM for the specifed stream or NULL.
  243. //
  244. ///////////////////////////////////////////////////////////////////////////
  246. HRESULT STDMETHODCALLTYPE PalMapStreamCreate(
  247. PAVISTREAM ps,
  248. LONG lParam1,
  249. LONG lParam2)
  250. {
  251. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  252. TCHAR achTemp[128];
  253. TCHAR achTemplate[64];
  255. LONG lRet = AVIERR_OK;
  257. pavi->ulRefCount = 1;
  259. AVIStreamAddRef((PAVISTREAM) lParam1);
  261. pavi->pavi = (PAVISTREAM) lParam1;
  263. AVIStreamInfo(pavi->pavi, &pavi->sinfo, sizeof(pavi->sinfo));
  265. if (pavi->sinfo.fccType != streamtypeVIDEO) {
  266. lRet = AVIERR_INTERNAL;
  267. goto error;
  268. }
  270. pavi->pgf = AVIStreamGetFrameOpen(pavi->pavi, NULL);
  272. if (!pavi->pgf) {
  273. lRet = AVIERR_INTERNAL;
  274. goto error;
  275. }
  277. pavi->sinfo.fccHandler = 0;
  279. // Fix up stream name
  280. LoadString(ghMod, IDS_STREAMNAME, achTemplate,
  281. sizeof(achTemplate) / sizeof(TCHAR));
  282. wsprintf(achTemp, achTemplate, pavi->sinfo.szName, lParam2);
  283. lstrcpyn(pavi->sinfo.szName, achTemp,
  284. sizeof(pavi->sinfo.szName) / sizeof(TCHAR));
  285. pavi->sinfo.szName[sizeof(pavi->sinfo.szName) / sizeof(TCHAR) - 1] =
  286.                 TEXT('');
  288. // default to 256 colors
  289. if (lParam2 < 2 || lParam2 > 256)
  290. lParam2 = 256;
  292. pavi->lp16to8 = GlobalAllocPtr(GMEM_MOVEABLE, 32768L);
  293. if (!pavi->lp16to8) {
  294. lRet = AVIERR_MEMORY;
  295. goto error;
  296. }
  298. lRet = GetScode(AVIStreamMakePalette(pavi->pavi,
  299. AVIStreamLength(pavi->pavi) / 30,
  300. &pavi->hpal, pavi->lp16to8,
  301. (int) lParam2));
  303. pavi->lLastFrame = -1;
  305. error:
  306. return ResultFromScode(lRet);
  307. }
  309. ///////////////////////////////////////////////////////////////////////////
  310. //
  311. //  PalMapStreamQueryInterface()
  312. //
  313. //      let other people know what interfaces we support
  314. //
  315. ///////////////////////////////////////////////////////////////////////////
  316. HRESULT STDMETHODCALLTYPE PalMapStreamQueryInterface(
  317. PAVISTREAM ps,
  318. REFIID riid,
  319. LPVOID FAR* ppvObj)
  320. {
  321. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  323. if (IsEqualIID(riid, &IID_IUnknown))
  324. *ppvObj = ps;
  325. else if (IsEqualIID(riid, &IID_IAVIStream))
  326. *ppvObj = ps;
  327. else
  328. return ResultFromScode(E_NOINTERFACE);
  330. pavi->ulRefCount++;
  331. return NOERROR;
  332. }
  334. ///////////////////////////////////////////////////////////////////////////
  335. //
  336. //  PalMapStreamAddRef()
  337. //
  338. //      increase the reference count of the stream
  339. //
  340. ///////////////////////////////////////////////////////////////////////////
  342. ULONG STDMETHODCALLTYPE PalMapStreamAddRef(
  343. PAVISTREAM ps)
  344. {
  345. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  347. return ++pavi->ulRefCount;
  348. }
  350. ///////////////////////////////////////////////////////////////////////////
  351. //
  352. //  PalMapStreamRelease()
  353. //
  354. //      close a PalMapStream stream
  355. //
  356. ///////////////////////////////////////////////////////////////////////////
  358. ULONG STDMETHODCALLTYPE PalMapStreamRelease(
  359. PAVISTREAM ps)
  360. {
  361. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  363. if (!pavi)
  364. return 0;
  366. if (--pavi->ulRefCount)
  367. return pavi->ulRefCount;
  369. if (pavi->pgf)
  370. AVIStreamGetFrameClose(pavi->pgf);
  371. pavi->pgf = 0;
  373. if (pavi->pavi)
  374. AVIStreamClose(pavi->pavi);
  375. pavi->pavi = 0;
  377. if (pavi->lp16to8) {
  378. GlobalFreePtr(pavi->lp16to8);
  379. pavi->lp16to8 = 0;
  380. }
  382. if (pavi->hpal) {
  383. DeletePalette(pavi->hpal);
  384. pavi->hpal = 0;
  385. }
  387. if (pavi->lpdibLast) {
  388. GlobalFreePtr(pavi->lpdibLast);
  389. pavi->lpdibLast = 0;
  390. }
  392. GlobalFreePtr(pavi);
  394. return 0;
  395. }
  397. ///////////////////////////////////////////////////////////////////////////
  398. ///////////////////////////////////////////////////////////////////////////
  400. HRESULT STDMETHODCALLTYPE PalMapStreamReadFormat(
  401. PAVISTREAM ps,
  402. LONG lPos,
  403. LPVOID lpFormat,
  404. LONG FAR *lpcbFormat)
  405. {
  406. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  407. LONG lSize;
  409. PalMapStreamRead(ps, lPos, 1, NULL, 0, NULL, NULL);
  411. if (pavi->lpdibLast == 0)
  412. return ResultFromScode(AVIERR_INTERNAL);
  413. lSize = pavi->lpdibLast->biSize
  414. + pavi->lpdibLast->biClrUsed * sizeof(RGBQUAD);
  416. if (lpFormat)
  417. hmemcpy(lpFormat, pavi->lpdibLast,
  418. min(*lpcbFormat, lSize));
  420. *lpcbFormat = lSize;
  422. return 0;
  423. }
  425. LONG STDMETHODCALLTYPE PalMapStreamFindKeyFrame(
  426. PAVISTREAM ps,
  427. LONG lPos,
  428. LONG lFlags)
  429. {
  430. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  432. return lPos;
  433. }
  436. ///////////////////////////////////////////////////////////////////////////
  437. ///////////////////////////////////////////////////////////////////////////
  439. HRESULT STDMETHODCALLTYPE PalMapStreamInfo(
  440. PAVISTREAM ps,
  441. AVISTREAMINFOW FAR * psi,        // OLE interfaces are ALWAYS UNICODE
  442. LONG lSize)
  443. {
  444. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  446. if (psi)
  447. hmemcpy(psi, &pavi->sinfo, min(lSize, sizeof(pavi->sinfo)));
  449. return 0;
  450. }
  453. ///////////////////////////////////////////////////////////////////////////
  454. ///////////////////////////////////////////////////////////////////////////
  456. HRESULT STDMETHODCALLTYPE PalMapStreamRead(
  457. PAVISTREAM ps,
  458. LONG lStart,
  459. LONG lSamples,
  460. LPVOID lpBuffer,
  461. LONG cbBuffer,
  462. LONG FAR * plBytes,
  463. LONG FAR * plSamples)
  464. {
  465. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  467. LPBITMAPINFOHEADER lpbi;
  468. LPVOID lp;
  470. if (lStart != pavi->lLastFrame) {
  471. pavi->lLastFrame = -1;
  472. lpbi = AVIStreamGetFrame(pavi->pgf, lStart);
  474. if (!lpbi)
  475. goto ReadNothing;
  477. if (pavi->lpdibLast) {
  478. GlobalFreePtr(pavi->lpdibLast);
  479. pavi->lpdibLast = 0;
  480. }
  482. pavi->lpdibLast = DibReduce(lpbi, NULL, pavi->hpal, pavi->lp16to8);
  483. pavi->lLastFrame = lStart;
  484. }
  486. lpbi = pavi->lpdibLast;
  487. //
  488. // a NULL buffer means return the size buffer needed to read
  489. // the given sample.
  490. //
  491. lp = (LPBYTE) lpbi + lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
  493. if (plBytes)
  494. *plBytes = lpbi->biSizeImage;
  496. if (plSamples)
  497. *plSamples = 1;
  499. if (lpBuffer) {
  500. if (cbBuffer >= (LONG) lpbi->biSizeImage)
  501. hmemcpy(lpBuffer, lp, lpbi->biSizeImage);
  502. else
  503. goto ReadNothing;
  504. }
  506. return 0;
  508. ReadNothing:
  509. if (plBytes)
  510. *plBytes = 0;
  512. if (plSamples)
  513. *plSamples = 0;
  515. return ResultFromScode(AVIERR_BUFFERTOOSMALL);
  516. }
  520. //
  521. //
  522. // Extra unimplemented functions.....
  523. //
  524. //
  525. //
  526. HRESULT STDMETHODCALLTYPE PalMapStreamReadData(
  527. PAVISTREAM ps,
  528. DWORD fcc,
  529. LPVOID lp,
  530. LONG FAR *lpcb)
  531. {
  532. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  533. return ResultFromScode(AVIERR_UNSUPPORTED);
  534. }
  536. HRESULT STDMETHODCALLTYPE PalMapStreamSetFormat(
  537. PAVISTREAM ps,
  538. LONG lPos,
  539. LPVOID lpFormat,
  540. LONG cbFormat)
  541. {
  542. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  543. return ResultFromScode(AVIERR_UNSUPPORTED);
  544. }
  546. HRESULT STDMETHODCALLTYPE PalMapStreamWriteData(
  547. PAVISTREAM ps,
  548. DWORD fcc,
  549. LPVOID lp,
  550. LONG cb)
  551. {
  552. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  553. return ResultFromScode(AVIERR_UNSUPPORTED);
  554. }
  556. HRESULT STDMETHODCALLTYPE PalMapStreamWrite(
  557. PAVISTREAM ps,
  558. LONG lStart,
  559. LONG lSamples,
  560. LPVOID lpBuffer,
  561. LONG cbBuffer,
  562. DWORD dwFlags,
  563. LONG FAR *plSampWritten,
  564. LONG FAR *plBytesWritten)
  565. {
  566. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  567. return ResultFromScode(AVIERR_UNSUPPORTED);
  568. }
  570. HRESULT STDMETHODCALLTYPE PalMapStreamDelete(
  571. PAVISTREAM ps,
  572. LONG lStart,
  573. LONG lSamples)
  574. {
  575. PPALMAPSTREAM pavi = (PPALMAPSTREAM) ps;
  576. return ResultFromScode(AVIERR_UNSUPPORTED);
  577. }
  579. HRESULT STDMETHODCALLTYPE PalMapStreamSetInfo(
  580.    PAVISTREAM ps,
  581.    AVISTREAMINFOW FAR * psi,
  582.    LONG lSize)
  583. {
  584. return ResultFromScode(AVIERR_UNSUPPORTED);
  585. }
  587. EXTERN_C int CALLBACK WEP(
  588. BOOL fSystemExit)
  589. {
  590. return TRUE;
  591. }
  594. EXTERN_C BOOL APIENTRY DllMain(HANDLE, DWORD, LPVOID);
  595. EXTERN_C BOOL APIENTRY DllMain(
  596. HANDLE hModule,
  597. DWORD dwReason,
  598. LPVOID lpReserved )
  599. {
  600. switch( dwReason)
  601. {
  602. case DLL_PROCESS_ATTACH:
  603. if(ghMod == NULL)
  604. ghMod = (HMODULE)hModule;
  605. break;
  606. case DLL_THREAD_ATTACH:
  607. break;
  608. case DLL_THREAD_DETACH:
  609. break;
  610. case DLL_PROCESS_DETACH:
  611. break;
  612. }
  613. return TRUE;
  614. }