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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
VideoSource.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：39k
源码类别：

VC书籍

开发平台：

Visual C++

VideoSource.cpp：源码内容
  1. // VirtualDub - Video processing and capture application
  2. // Copyright (C) 1998-2001 Avery Lee
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. #include <crtdbg.h>
  19. #include <stdio.h>
  21. #include <windows.h>
  22. #include <vfw.h>
  24. #include "VideoSource.h"
  25. //#include "VBitmap.h"
  26. #include "AVIStripeSystem.h"
  27. //#include "ProgressDialog.h"
  28. //#include "MJPEGDecoder.h"
  29. //#include "crash.h"
  31. #include "error.h"
  32. #include "misc.h"
  33. #include "oshelper.h"
  34. //#include "helpfile.h"
  35. #include "resourceVD.h"
  37. ///////////////////////////
  39. extern const char *LookupVideoCodec(FOURCC);
  41. extern HINSTANCE g_hInst;
  42. extern HWND g_hWnd;
  44. ///////////////////////////
  46. const char g_szNoMPEG4Test[]="No MPEG-4 Test";
  48. static BOOL CALLBACK MP4CodecWarningDlgProc(HWND hdlg, UINT msg, WPARAM wParam, LPARAM lParam) {
  49. switch(msg) {
  50. case WM_INITDIALOG:
  51. return TRUE;
  52. case WM_COMMAND:
  53. switch(LOWORD(wParam)) {
  54. case IDOK:
  55. // HelpContext(hdlg, IDH_WARN_MPEG4);
  56. MessageBox( NULL,"WarningMPEG4", "WarningMPEG4", MB_OK );
  57. case IDCANCEL:
  58. if (IsDlgButtonChecked(hdlg, IDC_NOMORE))
  59. SetConfigDword(NULL, g_szNoMPEG4Test, 1);
  60. EndDialog(hdlg, 0);
  61. break;
  62. }
  63. break;
  64. }
  65. return FALSE;
  66. }
  68. static bool CheckMPEG4Codec(HIC hic, bool isV3) {
  69. char frame[0x380];
  70. BITMAPINFOHEADER bih;
  71. DWORD dw;
  73. if (QueryConfigDword(NULL, g_szNoMPEG4Test, &dw) && dw)
  74. return true;
  76. // Form a completely black frame if it's V3.
  78. bih.biSize = 40;
  79. bih.biWidth = 320;
  80. bih.biHeight = 240;
  81. bih.biPlanes = 1;
  82. bih.biBitCount = 24;
  83. bih.biCompression = '24PM';
  84. bih.biSizeImage = 0;
  85. bih.biXPelsPerMeter = 0;
  86. bih.biYPelsPerMeter = 0;
  87. bih.biClrUsed = 0;
  88. bih.biClrImportant = 0;
  90. if (isV3) {
  91. int i;
  93. frame[0] = (char)0x3f;
  94. frame[1] = (char)0x71;
  95. frame[2] = (char)0x1b;
  96. frame[3] = (char)0x7c;
  98. for(i=4; i<0x179; i+=5) {
  99. frame[i+0] = (char)0x2f;
  100. frame[i+1] = (char)0x0b;
  101. frame[i+2] = (char)0xc2;
  102. frame[i+3] = (char)0xf0;
  103. frame[i+4] = (char)0xbc;
  104. }
  106. frame[0x179] = (char)0xf0;
  107. frame[0x17a] = (char)0xb8;
  108. frame[0x17b] = (char)0x01;
  110. bih.biCompression = '34PM';
  111. bih.biSizeImage = 0x17c;
  112. }
  114. // Attempt to decompress.
  116. HANDLE h;
  118. h = ICImageDecompress(hic, 0, (BITMAPINFO *)&bih, frame, NULL);
  120. // if (!h)
  121. // DialogBox(g_hInst, MAKEINTRESOURCE(IDD_WARN_MPEG4), g_hWnd, MP4CodecWarningDlgProc);
  122. // else
  123. // GlobalFree(h);
  125. if (h) {
  126. GlobalFree(h);
  127. return true;
  128. } else {
  129. return false;
  130. }
  131. }
  133. ///////////////////////////
  135. VideoSource::VideoSource() {
  136. lpvBuffer = NULL;
  137. hBufferObject = NULL;
  138. bmihDecompressedFormat = NULL;
  139. }
  141. VideoSource::~VideoSource() {
  142. freemem(bmihDecompressedFormat);
  143. FreeFrameBuffer();
  144. }
  146. void *VideoSource::AllocFrameBuffer(long size) {
  147. hBufferObject = CreateFileMapping(
  148. (HANDLE)0xFFFFFFFF,
  149. NULL,
  150. PAGE_READWRITE,
  151. 0,
  152. size,
  153. NULL);
  155. if (!hBufferObject) return NULL;
  157. lBufferOffset = 0;
  159. lpvBuffer = MapViewOfFile(hBufferObject, FILE_MAP_ALL_ACCESS, 0, lBufferOffset, size);
  161. if (!lpvBuffer) {
  162. CloseHandle(hBufferObject);
  163. hBufferObject = NULL;
  164. }
  166. return lpvBuffer;
  167. }
  169. void VideoSource::FreeFrameBuffer() {
  170. if (hBufferObject) {
  171. if (lpvBuffer)
  172. UnmapViewOfFile(lpvBuffer);
  173. CloseHandle(hBufferObject);
  174. } else
  175. freemem(lpvBuffer);
  177. lpvBuffer = NULL;
  178. hBufferObject = NULL;
  179. }
  181. bool VideoSource::setDecompressedFormat(int depth) {
  182. memcpy(bmihDecompressedFormat, getImageFormat(), getFormatLen());
  183. bmihDecompressedFormat->biSize = sizeof(BITMAPINFOHEADER);
  184. bmihDecompressedFormat->biPlanes = 1;
  185. bmihDecompressedFormat->biBitCount = depth;
  186. bmihDecompressedFormat->biCompression = BI_RGB;
  187. bmihDecompressedFormat->biSizeImage = ((bmihDecompressedFormat->biWidth * depth + 31)/32)*4*bmihDecompressedFormat->biHeight;
  189. if (depth>8) {
  190. bmihDecompressedFormat->biClrUsed = 0;
  191. bmihDecompressedFormat->biClrImportant = 0;
  192. }
  194. invalidateFrameBuffer();
  196. return true;
  197. }
  199. bool VideoSource::setDecompressedFormat(BITMAPINFOHEADER *pbih) {
  200. if (pbih->biCompression == BI_RGB) {
  201. setDecompressedFormat(pbih->biBitCount);
  202. return true;
  203. }
  205. return false;
  206. }
  208. void VideoSource::streamBegin(bool) {
  209. stream_current_frame = -1;
  210. }
  212. void VideoSource::streamSetDesiredFrame(long frame_num) {
  213. long key;
  215. key = isKey(frame_num) ? frame_num : prevKey(frame_num);
  216. if (key<0) key = lSampleFirst;
  218. stream_desired_frame = frame_num;
  220. if (stream_current_frame<key || stream_current_frame>frame_num)
  221. stream_current_frame = key-1;
  223. }
  225. long VideoSource::streamGetNextRequiredFrame(BOOL *is_preroll) {
  226. if (stream_current_frame == stream_desired_frame) {
  227. *is_preroll = FALSE;
  229. return -1;
  230. }
  232. *is_preroll = (++stream_current_frame != stream_desired_frame);
  234. return stream_current_frame;
  235. }
  237. int VideoSource::streamGetRequiredCount(long *pSize) {
  239. if (pSize) {
  240. long current = stream_current_frame;
  241. long size = 0, onesize;
  242. long samp;
  244. while(current < stream_desired_frame) {
  245. if (AVIERR_OK == read(current, 1, NULL, NULL, &onesize, &samp))
  246. size += onesize;
  248. ++current;
  249. }
  251. *pSize = size;
  252. }
  254. return stream_desired_frame - stream_current_frame;
  255. }
  257. void VideoSource::invalidateFrameBuffer() {
  258. }
  260. bool VideoSource::isKeyframeOnly() {
  261.    return false;
  262. }
  264. bool VideoSource::isType1() {
  265.    return false;
  266. }
  268. ///////////////////////////
  270. VideoSourceAVI::VideoSourceAVI(IAVIReadHandler *pAVI, AVIStripeSystem *stripesys, IAVIReadHandler **stripe_files, bool use_internal, int mjpeg_mode, FOURCC fccForceVideo, FOURCC fccForceVideoHandler) {
  271. pAVIFile = pAVI;
  272. pAVIStream = NULL;
  273. lpvBuffer = NULL;
  274. hicDecomp = NULL;
  275. bmihTemp = NULL;
  276. key_flags = NULL;
  277. mjpeg_reorder_buffer = NULL;
  278. mjpeg_reorder_buffer_size = 0;
  279. mjpeg_splits = NULL;
  280. mjpeg_last = -1;
  281. this->fccForceVideo = fccForceVideo;
  282. this->fccForceVideoHandler = fccForceVideoHandler;
  283. hbmLame = NULL;
  284. fUseGDI = false;
  286. // striping...
  288. stripe_streams = NULL;
  289. stripe_index = NULL;
  290. this->stripesys = stripesys;
  291. this->stripe_files = stripe_files;
  292. this->use_internal = use_internal;
  293. this->mjpeg_mode = mjpeg_mode;
  295. mdec = NULL;
  297. try {
  298. _construct();
  299. } catch(...) {
  300. _destruct();
  301. throw;
  302. }
  303. }
  305. void VideoSourceAVI::_destruct() {
  306. delete stripe_index;
  308. if (stripe_streams) {
  309. int i;
  311. for(i=0; i<stripe_count; i++)
  312. if (stripe_streams[i])
  313. delete stripe_streams[i];
  315. delete stripe_streams;
  316. }
  318. if (bmihTemp) freemem(bmihTemp);
  319. if (hicDecomp) ICClose(hicDecomp);
  321. if (pAVIStream) delete pAVIStream;
  323. delete mdec;
  324. freemem(mjpeg_reorder_buffer);
  325. mjpeg_reorder_buffer = NULL;
  326. delete[] mjpeg_splits;
  327. mjpeg_splits = NULL;
  329. delete[] key_flags; key_flags = NULL;
  331. if (hbmLame) {
  332. DeleteObject(hbmLame);
  333. hbmLame = NULL;
  334. }
  335. }
  337. VideoSourceAVI::~VideoSourceAVI() {
  338. _destruct();
  339. }
  341. void VideoSourceAVI::_construct() {
  342. LONG format_len;
  343. BITMAPINFOHEADER *bmih;
  344. bool is_mjpeg, is_dib;
  346. // 寻找标准的vids流
  348. bIsType1 = false;
  349. pAVIStream = pAVIFile->GetStream(streamtypeVIDEO, 0);
  350. if (!pAVIStream) {
  351. pAVIStream = pAVIFile->GetStream('svai', 0);
  354. if (!pAVIStream)
  355. throw MyError("No video stream found.");
  357. bIsType1 = true;
  358. }
  360. if (pAVIStream->Info(&streamInfo, sizeof streamInfo))
  361. throw MyError("Error obtaining video stream info.");
  363. // ADDITION FOR STRIPED AVI SUPPORT:
  364. //
  365. // If this is an index for a stripe system, then the video stream will have
  366. // 'VDST' as its fccHandler and video compression.  This will probably
  367. // correspond to the "VDub Frameserver" compressor, but since VirtualDub can
  368. // connect to its own frameservers more efficiently though the AVIFile
  369. // interface, it makes sense to open striped files in native mode.
  370. //
  371. // For this to work, we must have been sent the striping specs beforehand,
  372. // or else we won't be able to open the stripes.
  374. if (streamInfo.fccHandler == 'TSDV') {
  375. int i;
  377. if (!stripesys)
  378. throw MyError("AVI file is striped - must be opened with stripe definition file.");
  380. // 为条纹流表分配内存空间
  382. stripe_count = stripesys->getStripeCount();
  384. if (!(stripe_streams = new IAVIReadStream *[stripe_count]))
  385. throw MyMemoryError();
  387. for(i=0; i<stripe_count; i++)
  388. stripe_streams[i] = NULL;
  392. format_stream = NULL;
  394. for(i=0; i<stripe_count; i++) {
  395. if (stripesys->getStripeInfo(i)->isVideo()) {
  396. stripe_streams[i] = stripe_files[i]->GetStream(streamtypeVIDEO, 0);
  397. if (!stripe_streams[i])
  398. throw MyError("Striping: cannot open video stream for stripe #%d", i+1);
  400. if (!format_stream) format_stream = stripe_streams[i];
  401. }
  402. }
  404. if (!format_stream)
  405. throw MyError("Striping: No video stripes found!");
  409. if (format_stream->Info(&streamInfo, sizeof streamInfo))
  410. throw MyError("Error obtaining video stream info from first video stripe.");
  412. // 初始化下标
  414. if (!(stripe_index = new AVIStripeIndexLookup(pAVIStream)))
  415. throw MyMemoryError();
  417. } else {
  418. if (stripesys)
  419. throw MyError("This is not a striped AVI file.");
  421. format_stream = pAVIStream;
  422. }
  424. // 读视频格式。如果遇到条纹，那么条纹的引索有一个虚拟格式
  425. // 所以必须从一个视频条纹得到它相应的格式。如果是格式是
  426. // type-1 DV,继续要虚拟之。
  428. if (bIsType1) {
  429. format_len = sizeof(BITMAPINFOHEADER);
  431. if (!(bmih = (BITMAPINFOHEADER *)allocFormat(format_len))) throw MyMemoryError();
  433. bmih->biSize = sizeof(BITMAPINFOHEADER);
  434. bmih->biWidth = 720;
  436. if (streamInfo.dwRate > streamInfo.dwScale*26i64)
  437. bmih->biHeight = 480;
  438. else
  439. bmih->biHeight = 576;
  441. bmih->biPlanes = 1;
  442. bmih->biBitCount = 24;
  443. bmih->biCompression = 'dsvd';
  444. bmih->biSizeImage = streamInfo.dwSuggestedBufferSize;
  445. bmih->biXPelsPerMeter = 0;
  446. bmih->biYPelsPerMeter = 0;
  447. bmih->biClrUsed = 0;
  448. bmih->biClrImportant = 0;
  449. } else {
  450. format_stream->FormatSize(0, &format_len);
  452. if (!(bmih = (BITMAPINFOHEADER *)allocFormat(format_len))) throw MyMemoryError();
  454. if (format_stream->ReadFormat(0, getFormat(), &format_len))
  455. throw MyError("Error obtaining video stream format.");
  456. }
  457. if (!(bmihTemp = (BITMAPINFOHEADER *)allocmem(format_len))) throw MyMemoryError();
  458. if (!(bmihDecompressedFormat = (BITMAPINFOHEADER *)allocmem(format_len))) throw MyMemoryError();
  460. // RGB8/16/24/32和YUY2颜色空间可以被处理
  462. is_dib = (bmih->biCompression == BI_RGB) || (bmih->biCompression == '2YUY');
  464. // 如果需要，强制转换视频格式
  466. if (fccForceVideo)
  467. getImageFormat()->biCompression = fccForceVideo;
  469. if (fccForceVideoHandler)
  470. streamInfo.fccHandler = fccForceVideoHandler;
  472. is_mjpeg = isEqualFOURCC(bmih->biCompression, 'GPJM')
  473. || isEqualFOURCC(fccForceVideo, 'GPJM')
  474. || isEqualFOURCC(bmih->biCompression, '1bmd')
  475. || isEqualFOURCC(fccForceVideo, '1bmd');
  477. // 如果格式为MJPEG,检查是否需要修改输出格式或者流信息
  479. lSampleFirst = pAVIStream->Start();
  480. lSampleLast = pAVIStream->End();
  482. if (is_mjpeg) {
  483. BITMAPINFOHEADER *pbih = getImageFormat();
  485. if (mjpeg_mode && mjpeg_mode != IFMODE_SWAP && pbih->biHeight > 288) {
  486. pbih->biHeight /= 2;
  488. if (mjpeg_mode == IFMODE_SPLIT1 || mjpeg_mode == IFMODE_SPLIT2) {
  489. streamInfo.dwRate *= 2;
  490. streamInfo.dwLength *= 2;
  491. lSampleLast = lSampleLast*2 - lSampleFirst;
  492. }
  493. }
  495. if (mjpeg_mode) {
  496. if (!(mjpeg_splits = new long[lSampleLast - lSampleFirst]))
  497. throw MyMemoryError();
  499. for(int i=0; i<lSampleLast-lSampleFirst; i++)
  500. mjpeg_splits[i] = -1;
  501. }
  502. } else
  503. mjpeg_mode = 0;
  505. memcpy(bmihTemp, getFormat(), format_len);
  507. // 分配帧缓存
  509. if (!AllocFrameBuffer(bmih->biWidth * 4 * bmih->biHeight + 4))
  510. throw MyMemoryError();
  512. // 取得解码器
  513. //
  514. // 'DIB '是标准的解码后的AVI文件标记值。不过有一些条纹程序使用
  515. // (null) 和 'RAW '
  517. hicDecomp = NULL;
  519. if (bmih->biCompression == BI_BITFIELDS || bmih->biCompression == BI_RLE8 || bmih->biCompression == BI_RLE4
  520. || (bmih->biCompression == BI_RGB && bmih->biBitCount<16 && bmih->biBitCount != 8)) {
  522. // 如果是冷僻的格式，用GDI处理
  524. fUseGDI = true;
  526. } else if (!is_dib) {
  527. FOURCC fccOriginalCodec = bmih->biCompression;
  529. // 如果是老式的MPEG-4解码器,尝试所有的已知的老式解码器
  530. // 它们都是同种的解码器，因此互相兼容
  533. switch(bmih->biCompression) {
  534. case '34PM': // Microsoft MPEG-4 V3
  535. case '3VID': // "DivX Low-Motion" (4.10.0.3917)
  536. case '4VID': // "DivX Fast-Motion" (4.10.0.3920)
  537. case '14PA': // "AngelPotion Definitive" (4.0.00.3688)
  538. if (AttemptCodecNegotiation(bmih, is_mjpeg)) return;
  539. bmih->biCompression = '34PM';
  540. if (AttemptCodecNegotiation(bmih, is_mjpeg)) return;
  541. bmih->biCompression = '3VID';
  542. if (AttemptCodecNegotiation(bmih, is_mjpeg)) return;
  543. bmih->biCompression = '4VID';
  544. if (AttemptCodecNegotiation(bmih, is_mjpeg)) return;
  545. bmih->biCompression = '14PA';
  546. default:
  547. if (AttemptCodecNegotiation(bmih, is_mjpeg)) return;
  548. break;
  549. }
  552. const char *s = LookupVideoCodec(fccOriginalCodec);
  554. throw MyError("Couldn't locate decompressor for format '%c%c%c%c' (%s)n"
  555. "n"
  556. "VirtualDub requires a Video for Windows (VFW) compatible codec to decompress "
  557. "video. DirectShow codecs, such as those used by Windows Media Player, are not "
  558. "suitable."
  559. ,(fccOriginalCodec    ) & 0xff
  560. ,(fccOriginalCodec>> 8) & 0xff
  561. ,(fccOriginalCodec>>16) & 0xff
  562. ,(fccOriginalCodec>>24) & 0xff
  563. ,s ? s : "unknown");
  564. }
  565. }
  567. bool VideoSourceAVI::AttemptCodecNegotiation(BITMAPINFOHEADER *bmih, bool is_mjpeg) {
  569. // VideoMatrix sets streamInfo.fccHandler to NULL.  Danger, Will Robinson.
  571. if (!use_internal) {
  573. // Try the handler specified in the file first.  In some cases, it'll
  574. // be wrong or missing.
  576. if (streamInfo.fccHandler)
  577. hicDecomp = ICOpen(ICTYPE_VIDEO, streamInfo.fccHandler, ICMODE_DECOMPRESS);
  579. if (!hicDecomp || ICERR_OK!=ICDecompressQuery(hicDecomp, bmih, NULL)) {
  580. if (hicDecomp)
  581. ICClose(hicDecomp);
  583. // Pick a handler based on the biCompression field instead.
  585. hicDecomp = ICOpen(ICTYPE_VIDEO, bmih->biCompression, ICMODE_DECOMPRESS);
  587. if (!hicDecomp || ICERR_OK!=ICDecompressQuery(hicDecomp, bmih, NULL)) {
  588. if (hicDecomp)
  589. ICClose(hicDecomp);
  591. // AngelPotion f*cks us over here and overwrites our format if we keep this in.
  592. // So let's write protect the format.  You'll see a nice C0000005 error when
  593. // the AP DLL tries to modify it.
  595. // hicDecomp = ICLocate(ICTYPE_VIDEO, NULL, getImageFormat(), NULL, ICMODE_DECOMPRESS);
  597. int siz = getFormatLen();
  599. BITMAPINFOHEADER *pbih_protected = (BITMAPINFOHEADER *)VirtualAlloc(NULL, siz, MEM_COMMIT, PAGE_READWRITE);
  601. if (pbih_protected) {
  602. DWORD dwOldProtect;
  604. memcpy(pbih_protected, bmih, siz);
  605. VirtualProtect(pbih_protected, siz, PAGE_READONLY, &dwOldProtect);
  607. hicDecomp = ICLocate(ICTYPE_VIDEO, NULL, pbih_protected, NULL, ICMODE_DECOMPRESS);
  609. VirtualFree(pbih_protected, 0, MEM_RELEASE);
  610. }
  611. }
  612. }
  613. }
  615. if (!hicDecomp) {
  617. // Is it MJPEG or I420?  Maybe we can do it ourselves.
  619. if (is_mjpeg) {
  620. // if (!(mdec = CreateMJPEGDecoder(getImageFormat()->biWidth, getImageFormat()->biHeight)))
  621. // throw MyMemoryError();
  623. return true;
  624. } else {
  625. return false;
  626. }
  627. } else {
  629. // check for bad MPEG-4 V2/V3 codec
  631. if (isEqualFOURCC(bmih->biCompression, '24PM'))
  632. return CheckMPEG4Codec(hicDecomp, false);
  633. else if (isEqualFOURCC(bmih->biCompression, '34PM'))
  634. return CheckMPEG4Codec(hicDecomp, true);
  635. else
  636. return true;
  637. }
  638. }
  640. ///////////////////////////////////////////////////////////////////////////
  642. void VideoSourceAVI::Reinit() {
  643. long nOldFrames, nNewFrames;
  645. nOldFrames = lSampleLast - lSampleFirst;
  646. nNewFrames = pAVIStream->End() - pAVIStream->Start();
  648. if (mjpeg_splits) {
  649. nOldFrames >>= 1;
  650. }
  652. if (nOldFrames != nNewFrames && (mjpeg_mode==IFMODE_SPLIT1 || mjpeg_mode==IFMODE_SPLIT2)) {
  653. // We have to resize the mjpeg_splits array.
  655. long *pNewSplits = new long[lSampleLast - lSampleFirst];
  657. if (!pNewSplits)
  658. throw MyMemoryError();
  660. int i;
  662. memcpy(pNewSplits, mjpeg_splits, sizeof(long)*nOldFrames);
  664. for(i=nOldFrames; i<nNewFrames; i++)
  665. pNewSplits[i] = -1;
  667. delete[] mjpeg_splits;
  669. mjpeg_splits = pNewSplits;
  670. }
  672. if (pAVIStream->Info(&streamInfo, sizeof streamInfo))
  673. throw MyError("Error obtaining video stream info.");
  675. lSampleFirst = pAVIStream->Start();
  677. if (mjpeg_splits) {
  678. streamInfo.dwRate *= 2;
  679. streamInfo.dwLength *= 2;
  680. lSampleLast = pAVIStream->End() * 2 - lSampleFirst;
  681. } else
  682. lSampleLast = pAVIStream->End();
  684. streamInfo.dwLength = lSampleLast - lSampleFirst;
  685. }
  687. void VideoSourceAVI::redoKeyFlags() {
  688. long lSample;
  689. long lMaxFrame=0;
  690. long lActualBytes, lActualSamples;
  691. int err;
  692. void *lpInputBuffer = NULL;
  693. void *lpKeyBuffer = NULL;
  694. BOOL fStreamBegun = FALSE;
  695. int iBytes;
  696. long *pFrameSums;
  698. if (!hicDecomp)
  699. return;
  701. iBytes = (lSampleLast+7-lSampleFirst)>>3;
  703. if (!(key_flags = new char[iBytes]))
  704. throw MyMemoryError();
  706. memset(key_flags, 0, iBytes);
  708. // Find maximum frame
  710. lSample = lSampleFirst;
  711. while(lSample < lSampleLast) {
  712. err = _read(lSample, 1, NULL, 0, &lActualBytes, &lActualSamples);
  713. if (err == AVIERR_OK)
  714. // throw MyAVIError("VideoSource", err);
  716. if (lActualBytes > lMaxFrame) lMaxFrame = lActualBytes;
  718. ++lSample;
  719. }
  721. if (!setDecompressedFormat(24))
  722. if (!setDecompressedFormat(32))
  723. if (!setDecompressedFormat(16))
  724. if (!setDecompressedFormat(8))
  725. throw MyError("Video decompressor is incapable of decompressing to an RGB format.");
  727. if (!(lpInputBuffer = new char[((lMaxFrame+7)&-8) + lMaxFrame]))
  728. throw MyMemoryError();
  730. if (!(pFrameSums = new long[lSampleLast - lSampleFirst])) {
  731. delete[] lpInputBuffer;
  732. throw MyMemoryError();
  733. }
  735. try {
  736. // ProgressDialog pd(NULL, "AVI Import Filter", "Rekeying video stream", (lSampleLast - lSampleFirst)*2, true);
  737. // pd.setValueFormat("Frame %ld of %ld");
  738. MessageBox( NULL, "AVI Import Filter", "Rekeying video stream", MB_OK);
  740. streamBegin(true);
  741. fStreamBegun = TRUE;
  743. lSample = lSampleFirst;
  744. while(lSample < lSampleLast) {
  745. long lBlackTotal=0, lWhiteTotal=0;
  746. long x, y;
  747. const long lWidth = (bmihDecompressedFormat->biWidth * bmihDecompressedFormat->biBitCount + 7)/8;
  748. const long lModulo = (4-lWidth)&3;
  749. const long lHeight = bmihDecompressedFormat->biHeight;
  750. unsigned char *ptr;
  752. _RPT1(0,"Rekeying frame %ldn", lSample);
  754. err = _read(lSample, 1, lpInputBuffer, lMaxFrame, &lActualBytes, &lActualSamples);
  755. if (err != AVIERR_OK)
  756. // throw MyAVIError("VideoSourceAVI", err);
  757. goto rekey_error;
  759. #if 0
  760. // decompress frame with an all black background
  762. memset(lpvBuffer, 0, bmihDecompressedFormat->biSizeImage);
  763. streamGetFrame(lpInputBuffer, lActualBytes, FALSE, FALSE, lSample);
  765. ptr = (unsigned char *)lpvBuffer;
  766. y = lHeight;
  767. do {
  768. x = lWidth;
  769. do {
  770. lBlackTotal += (long)*ptr++;
  771. } while(--x);
  773. ptr += lModulo;
  774. } while(--y);
  776. // decompress frame with an all white background
  778. memset(lpvBuffer, 0xff, bmihDecompressedFormat->biSizeImage);
  779. streamGetFrame(lpInputBuffer, lActualBytes, FALSE, FALSE, lSample);
  781. ptr = (unsigned char *)lpvBuffer;
  782. y = lHeight;
  783. do {
  784. x = lWidth;
  785. do {
  786. lWhiteTotal += (long)*ptr++;
  787. } while(--x);
  789. ptr += lModulo;
  790. } while(--y);
  791. #else
  793. streamGetFrame(lpInputBuffer, lActualBytes, FALSE, FALSE, lSample);
  795. ptr = (unsigned char *)lpvBuffer;
  796. y = lHeight;
  797. do {
  798. x = lWidth;
  799. do {
  800. lWhiteTotal += (long)*ptr++;
  801. lWhiteTotal ^= 0xAAAAAAAA;
  802. } while(--x);
  804. ptr += lModulo;
  805. } while(--y);
  808. pFrameSums[lSample - lSampleFirst] = lWhiteTotal;
  809. #endif
  811. // if (lBlackTotal == lWhiteTotal)
  812. // key_flags[(lSample - lSampleFirst)>>3] |= 1<<((lSample-lSampleFirst)&7);
  814. rekey_error:
  815. ++lSample;
  817. // pd.advance(lSample - lSampleFirst);
  818. // pd.check();
  819. }
  821. lSample = lSampleFirst;
  822. do {
  823. long lBlackTotal=0, lWhiteTotal=0;
  824. long x, y;
  825. const long lWidth = (bmihDecompressedFormat->biWidth * bmihDecompressedFormat->biBitCount + 7)/8;
  826. const long lModulo = (4-lWidth)&3;
  827. const long lHeight = bmihDecompressedFormat->biHeight;
  828. unsigned char *ptr;
  830. _RPT1(0,"Rekeying frame %ldn", lSample);
  832. err = _read(lSample, 1, lpInputBuffer, lMaxFrame, &lActualBytes, &lActualSamples);
  833. if (err != AVIERR_OK)
  834. // throw MyAVIError("VideoSourceAVI", err);
  835. goto rekey_error2;
  837. streamGetFrame(lpInputBuffer, lActualBytes, FALSE, FALSE, lSample);
  839. ptr = (unsigned char *)lpvBuffer;
  840. y = lHeight;
  841. do {
  842. x = lWidth;
  843. do {
  844. lWhiteTotal += (long)*ptr++;
  845. lWhiteTotal ^= 0xAAAAAAAA;
  846. } while(--x);
  848. ptr += lModulo;
  849. } while(--y);
  852. if (lWhiteTotal == pFrameSums[lSample - lSampleFirst])
  853. key_flags[(lSample - lSampleFirst)>>3] |= 1<<((lSample-lSampleFirst)&7);
  855. rekey_error2:
  856. if (lSample == lSampleFirst)
  857. lSample = lSampleLast-1;
  858. else
  859. --lSample;
  861. // pd.advance(lSampleLast*2 - (lSample+lSampleFirst));
  862. // pd.check();
  863. } while(lSample >= lSampleFirst+1);
  865. streamEnd();
  866. } catch(...) {
  867. if (fStreamBegun) streamEnd();
  868. delete[] lpInputBuffer;
  869. delete[] pFrameSums;
  870. throw;
  871. }
  873. delete[] lpInputBuffer;
  874. delete[] pFrameSums;
  875. }
  877. int VideoSourceAVI::_read(LONG lStart, LONG lCount, LPVOID lpBuffer, LONG cbBuffer, LONG *lBytesRead, LONG *lSamplesRead) {
  878. IAVIReadStream *pSource = pAVIStream;
  879. bool phase = (lStart - lSampleFirst)&1;
  881. if (mjpeg_mode == IFMODE_SPLIT1 || mjpeg_mode == IFMODE_SPLIT2)
  882. lStart = lSampleFirst + (lStart - lSampleFirst)/2;
  884. // 如果被条纹化，那么寻找正确的条纹
  886. if (stripesys) {
  887. AVIStripeIndexEntry *asie;
  888. long offset;
  890. if (!(asie = stripe_index->lookup(lStart)))
  891. return AVIERR_FILEREAD;
  893. offset = lStart - asie->lSampleFirst;
  895. if (lCount > asie->lSampleCount-offset)
  896. lCount = asie->lSampleCount-offset;
  898. if (!stripe_streams[asie->lStripe])
  899. return AVIERR_FILEREAD;
  901. pSource = stripe_streams[asie->lStripe];
  902. lStart = asie->lStripeSample + offset;
  903. }
  905. // 是否为MJPEG修正模式?
  907. if (mjpeg_mode) {
  908. int res;
  909. LONG lBytes, lSamples;
  910. long lRealSample = lStart;
  911. long lOffset, lLength;
  913. // 是否和上次输入的sample相同?
  915. if (lStart == mjpeg_last) {
  916. lBytes = mjpeg_last_size;
  917. res = AVIERR_OK;
  918. } else {
  920. // 把sample读入内存。如果不知道放入的地址或者已经知道
  921. // 条纹在那里，仅仅返回sample的大小
  923. if (lpBuffer || mjpeg_splits[lStart - lSampleFirst]<0) {
  925. mjpeg_last = -1;
  927. if (mjpeg_reorder_buffer_size)
  928. res = pSource->Read(lStart, 1, mjpeg_reorder_buffer, mjpeg_reorder_buffer_size, &lBytes, &lSamples);
  930. if (res == AVIERR_BUFFERTOOSMALL || !mjpeg_reorder_buffer_size) {
  931. void *new_buffer;
  932. int new_size;
  934. res = pSource->Read(lStart, 1, NULL, 0, &lBytes, &lSamples);
  936. if (res == AVIERR_OK) {
  938. _ASSERT(lBytes != 0);
  940. new_size = (lBytes + 4095) & -4096;
  942. new_buffer = reallocmem(mjpeg_reorder_buffer, new_size);
  944. if (!new_buffer)
  945. return AVIERR_MEMORY;
  947. mjpeg_reorder_buffer = new_buffer;
  948. mjpeg_reorder_buffer_size = new_size;
  950. res = pSource->Read(lStart, 1, mjpeg_reorder_buffer, mjpeg_reorder_buffer_size, &lBytes, &lSamples);
  951. }
  952. }
  954. if (res == AVIERR_OK) {
  955. mjpeg_last = lStart;
  956. mjpeg_last_size = lBytes;
  957. }
  958. } else
  959. res = pSource->Read(lStart, 1, NULL, 0, &lBytes, &lSamples);
  960. }
  963. if (res != AVIERR_OK) {
  964. if (lBytesRead)
  965. *lBytesRead = 0;
  966. if (lSamplesRead)
  967. *lSamplesRead = 0;
  968. return res;
  969. } else if (!lBytes) {
  970. if (lBytesRead)
  971. *lBytesRead = 0;
  972. if (lSamplesRead)
  973. *lSamplesRead = 1;
  974. return AVIERR_OK;
  975. }
  977. // 在sample中寻找SOI标记
  979. lOffset = 0;
  980. lLength = lBytes;
  982. {
  983. int i;
  985. // 是否已经知道条纹在哪里?
  987. if (mjpeg_splits[lStart-lSampleFirst]<0) {
  988. for(i=2; i<lBytes-2; i++)
  989. if (((unsigned char *)mjpeg_reorder_buffer)[i] == (unsigned char)0xFF
  990. && ((unsigned char *)mjpeg_reorder_buffer)[i+1] == (unsigned char)0xD8)
  991. break;
  993. mjpeg_splits[lStart - lSampleFirst] = i;
  994. } else {
  995. i = mjpeg_splits[lStart - lSampleFirst];
  996. }
  998. if (i<lBytes-2) {
  999. if (mjpeg_mode != IFMODE_SWAP) {
  1000. switch(mjpeg_mode) {
  1001. case IFMODE_SPLIT2:
  1002. phase = !phase;
  1003. break;
  1004. case IFMODE_DISCARD1:
  1005. phase = false;
  1006. break;
  1007. case IFMODE_DISCARD2:
  1008. phase = true;
  1009. break;
  1010. }
  1012. if (phase) {
  1013. lOffset = i;
  1014. lLength = lBytes - i;
  1015. } else {
  1016. lOffset = 0;
  1017. lLength = i;
  1018. }
  1019. } else
  1020. lOffset = i;
  1021. }
  1022. }
  1024. if (lpBuffer) {
  1025. if (lSamplesRead)
  1026. *lSamplesRead = 1;
  1027. if (lBytesRead)
  1028. *lBytesRead = lLength;
  1030. if (cbBuffer < lLength)
  1031. return AVIERR_BUFFERTOOSMALL;
  1033. if (mjpeg_mode == IFMODE_SWAP) {
  1034. char *pp1 = (char *)lpBuffer;
  1035. char *pp2 = (char *)lpBuffer + (lBytes - lOffset);
  1037. memcpy(pp1, (char *)mjpeg_reorder_buffer+lOffset, lBytes - lOffset);
  1038. if (lOffset)
  1039. memcpy(pp2, mjpeg_reorder_buffer, lOffset);
  1041. if (((short *)pp1)[1]==(short)0xE0FF)
  1042. pp1[10] = 1;
  1044. if (((short *)pp2)[1]==(short)0xE0FF)
  1045. pp2[10] = 2;
  1047. } else {
  1049. memcpy(lpBuffer, (char *)mjpeg_reorder_buffer+lOffset, lLength);
  1051. // 通过APP0标记在MJPEG头打补丁
  1053. // FFD8 FFE0 0010 'AVI1' 极性
  1055. if (((short *)lpBuffer)[1]==(short)0xE0FF)
  1056. ((char *)lpBuffer)[10] = 0;
  1057. }
  1059. return AVIERR_OK;
  1060. } else {
  1061. if (lSamplesRead)
  1062. *lSamplesRead = 1;
  1063. if (lBytesRead)
  1064. *lBytesRead = lLength;
  1066. return AVIERR_OK;
  1067. }
  1069. } else
  1070. return pSource->Read(lStart, lCount, lpBuffer, cbBuffer, lBytesRead, lSamplesRead);
  1071. }
  1073. BOOL VideoSourceAVI::_isKey(LONG samp) {
  1074. if ((mjpeg_mode & -2) == IFMODE_SPLIT1)
  1075. samp = lSampleFirst + (samp - lSampleFirst)/2;
  1077. if (key_flags) {
  1078. samp -= lSampleFirst;
  1080. return !!(key_flags[samp>>3] & (1<<(samp&7)));
  1081. } else
  1082. return pAVIStream->IsKeyFrame(samp);
  1083. }
  1085. LONG VideoSourceAVI::nearestKey(LONG lSample) {
  1086. if (key_flags) {
  1087. if (lSample < lSampleFirst || lSample >= lSampleLast)
  1088. return -1;
  1090. if (_isKey(lSample)) return lSample;
  1092. return prevKey(lSample);
  1093. }
  1095. // if (lNear == -1)
  1096. // throw MyError("VideoSourceAVI: error getting previous key frame");
  1098. if ((mjpeg_mode & -2) == IFMODE_SPLIT1) {
  1099. return pAVIStream->NearestKeyFrame(lSampleFirst + (lSample-lSampleFirst)/2)*2-lSampleFirst;
  1100. } else {
  1101. return pAVIStream->NearestKeyFrame(lSample);
  1102. }
  1103. }
  1105. LONG VideoSourceAVI::prevKey(LONG lSample) {
  1106. if ((mjpeg_mode & -2) == IFMODE_SPLIT1) {
  1107. lSample = lSampleFirst + (lSample - lSampleFirst)/2;
  1109. if (key_flags) {
  1110. if (lSample >= lSampleLast) return -1;
  1112. while(--lSample >= lSampleFirst)
  1113. if (_isKey(lSample)) return lSample*2-lSampleFirst;
  1115. return -1;
  1116. } else
  1117. return pAVIStream->PrevKeyFrame(lSample)*2-lSampleFirst;
  1118. } else {
  1119. if (key_flags) {
  1120. if (lSample >= lSampleLast) return -1;
  1122. while(--lSample >= lSampleFirst)
  1123. if (_isKey(lSample)) return lSample;
  1125. return -1;
  1126. } else
  1127. return pAVIStream->PrevKeyFrame(lSample);
  1128. }
  1129. }
  1131. LONG VideoSourceAVI::nextKey(LONG lSample) {
  1132. if ((mjpeg_mode & -2) == IFMODE_SPLIT1) {
  1133. lSample = lSampleFirst + (lSample - lSampleFirst)/2;
  1135. if (key_flags) {
  1136. if (lSample < lSampleFirst) return -1;
  1138. while(++lSample < lSampleLast)
  1139. if (_isKey(lSample)) return lSample*2 - lSampleFirst;
  1141. return -1;
  1142. } else
  1143. return pAVIStream->NextKeyFrame(lSample)*2 - lSampleFirst;
  1145. } else {
  1147. if (key_flags) {
  1148. if (lSample < lSampleFirst) return -1;
  1150. while(++lSample < lSampleLast)
  1151. if (_isKey(lSample)) return lSample;
  1153. return -1;
  1154. } else
  1155. return pAVIStream->NextKeyFrame(lSample);
  1157. }
  1158. }
  1160. __int64 VideoSourceAVI::sampleOffset(LONG lSample)
  1161. {
  1162. return pAVIStream->FramePos(lSample);
  1163. }
  1165. bool VideoSourceAVI::setDecompressedFormat(int depth) {
  1166. VideoSource::setDecompressedFormat(depth);
  1168. if (fUseGDI) {
  1169. void *pv;
  1170. HDC hdc;
  1172. if (depth != 24 && depth != 32 && depth != 16)
  1173. return false;
  1175. if (hbmLame)
  1176. DeleteObject(hbmLame);
  1178. hbmLame = NULL;
  1180. if (hdc = CreateCompatibleDC(NULL)) {
  1181. hbmLame = CreateDIBSection(hdc, (BITMAPINFO *)bmihDecompressedFormat, DIB_RGB_COLORS, &pv, hBufferObject, 0);
  1182. DeleteDC(hdc);
  1183. }
  1185. return true;
  1187. } else if (mdec)
  1188. return depth == 32 || depth == 16;
  1189. else if (hicDecomp)
  1190. return ICERR_OK == ICDecompressQuery(hicDecomp, getImageFormat(), bmihDecompressedFormat);
  1191. else if (getImageFormat()->biCompression == '024I')
  1192. return depth == 32;
  1193. else
  1194. return depth == 32 || depth == 24 || depth == 16;
  1195. }
  1197. bool VideoSourceAVI::setDecompressedFormat(BITMAPINFOHEADER *pbih) {
  1198. if (pbih->biCompression == BI_RGB)
  1199. return setDecompressedFormat(pbih->biBitCount);
  1201. if (mdec)
  1202. return false;
  1204. if (hicDecomp && ICERR_OK == ICDecompressQuery(hicDecomp, getImageFormat(), pbih)) {
  1205. memcpy(bmihDecompressedFormat, pbih, sizeof(BITMAPINFOHEADER));
  1207. invalidateFrameBuffer();
  1208. return true;
  1209. }
  1211. return false;
  1212. }
  1214. ////////////////////////////////////////////////
  1216. void DIBconvert(void *src0, BITMAPINFOHEADER *srcfmt, void *dst0, BITMAPINFOHEADER *dstfmt) {
  1217. if (srcfmt->biCompression == '2YUY')
  1218. // VBitmap(dst0, dstfmt).BitBltFromYUY2(0, 0, &VBitmap(src0, srcfmt), 0, 0, -1, -1);
  1219. ;
  1220. else if (srcfmt->biCompression == '024I')
  1221. // VBitmap(dst0, dstfmt).BitBltFromI420(0, 0, &VBitmap(src0, srcfmt), 0, 0, -1, -1);
  1222. ;
  1223. else
  1224. // VBitmap(dst0, dstfmt).BitBlt(0, 0, &VBitmap(src0, srcfmt), 0, 0, -1, -1);
  1225. ;
  1226. }
  1228. ////////////////////////////////////////////////
  1230. void VideoSourceAVI::invalidateFrameBuffer() {
  1231. if (lLastFrame != -1 && hicDecomp)
  1232. ICDecompressEnd(hicDecomp);
  1233. lLastFrame = -1;
  1234. }
  1236. BOOL VideoSourceAVI::isFrameBufferValid() {
  1237. return lLastFrame != -1;
  1238. }
  1240. char VideoSourceAVI::getFrameTypeChar(long lFrameNum) {
  1241. if (lFrameNum<lSampleFirst || lFrameNum >= lSampleLast)
  1242. return ' ';
  1244. if (_isKey(lFrameNum))
  1245. return 'K';
  1247. long lBytes, lSamples;
  1248. int err = _read(lFrameNum, 1, NULL, 0, &lBytes, &lSamples);
  1250. if (err != AVIERR_OK)
  1251. return ' ';
  1253. return lBytes ? ' ' : 'D';
  1254. }
  1256. bool VideoSourceAVI::isStreaming() {
  1257. return pAVIStream->isStreaming();
  1258. }
  1260. bool VideoSourceAVI::isKeyframeOnly() {
  1261.    return pAVIStream->isKeyframeOnly();
  1262. }
  1264. bool VideoSourceAVI::isType1() {
  1265.    return bIsType1;
  1266. }
  1268. void VideoSourceAVI::streamBegin(bool fRealTime) {
  1269. DWORD err;
  1271. stream_current_frame = -1;
  1273. pAVIStream->BeginStreaming(lSampleFirst, lSampleLast, fRealTime ? 1000 : 2000);
  1275. use_ICDecompressEx = FALSE;
  1277. if (hicDecomp) {
  1278. BITMAPINFOHEADER *bih_src = bmihTemp;
  1279. BITMAPINFOHEADER *bih_dst = getDecompressedFormat();
  1281. if (ICERR_OK != (err = ICDecompressBegin(
  1282. hicDecomp,
  1283. getImageFormat(),
  1284. getDecompressedFormat()
  1285. )))
  1287. if (err == ICERR_UNSUPPORTED) {
  1288. use_ICDecompressEx = TRUE;
  1290. err = ICDecompressExBegin(
  1291. hicDecomp,
  1292. 0,
  1293. bih_src,
  1294. NULL,
  1295. 0,0,
  1296. bih_src->biWidth,bih_src->biHeight,
  1297. bih_dst,
  1298. lpvBuffer,
  1299. 0,0,
  1300. bih_dst->biWidth,bih_dst->biHeight
  1301. );
  1303. }
  1305. if (ICERR_UNSUPPORTED != err && ICERR_OK != err)
  1306. throw MyICError("VideoSourceAVI", err);
  1307. }
  1308. }
  1310. void *VideoSourceAVI::streamGetFrame(void *inputBuffer, LONG data_len, BOOL is_key, BOOL is_preroll, long frame_num) {
  1311. DWORD err;
  1313. if (!data_len) return getFrameBuffer();
  1315. if (fUseGDI) {
  1316. if (!hbmLame)
  1317. throw MyError("Insufficient GDI resources to convert frame.");
  1319. SetDIBits(NULL, hbmLame, 0, getDecompressedFormat()->biHeight, inputBuffer, (BITMAPINFO *)getFormat(),
  1320. DIB_RGB_COLORS);
  1321. GdiFlush();
  1323. } else if (hicDecomp) {
  1324. // Asus ASV1 crashes with zero byte frames!!!
  1326. if (data_len) {
  1327. BITMAPINFOHEADER *bih_src = bmihTemp;
  1328. BITMAPINFOHEADER *bih_dst = getDecompressedFormat();
  1330. bmihTemp->biSizeImage = data_len;
  1332. // VDCHECKPOINT;
  1333. if (use_ICDecompressEx)
  1334. err =  ICDecompressEx(
  1335. hicDecomp,
  1336. //   (is_preroll ? ICDECOMPRESS_PREROLL : 0) |
  1337. //   | (data_len ? 0 : ICDECOMPRESS_NULLFRAME)
  1338.   (is_key ? 0 : ICDECOMPRESS_NOTKEYFRAME),
  1339. bih_src,
  1340. inputBuffer,
  1341. 0,0,
  1342. bih_src->biWidth, bih_src->biHeight,
  1343. bih_dst,
  1344. lpvBuffer,
  1345. 0,0,
  1346. bih_dst->biWidth, bih_dst->biHeight
  1347. );
  1349. else
  1350. err =  ICDecompress(
  1351. hicDecomp,
  1352. //   (is_preroll ? ICDECOMPRESS_PREROLL : 0) |
  1353. //   | (data_len ? 0 : ICDECOMPRESS_NULLFRAME)
  1354.   (is_key ? 0 : ICDECOMPRESS_NOTKEYFRAME),
  1355. bih_src,
  1356. inputBuffer,
  1357. bih_dst,
  1358. lpvBuffer
  1359. );
  1360. // VDCHECKPOINT;
  1362. if (ICERR_OK != err)
  1363. throw MyICError(use_ICDecompressEx ? "VideoSourceAVI [ICDecompressEx]" : "VideoSourceAVI [ICDecompress]", err);
  1364. }
  1366. } else if (mdec) {
  1368. /* try {
  1369. if (getDecompressedFormat()->biBitCount == 32)
  1370. mdec->decodeFrame32((unsigned long *)getFrameBuffer(), (unsigned char *)inputBuffer, data_len);
  1371. else
  1372. mdec->decodeFrame16((unsigned long *)getFrameBuffer(), (unsigned char *)inputBuffer, data_len);
  1373. } catch(char *s) {
  1374. throw MyError(s);
  1375. }
  1376. */
  1377.    } else {
  1378.       if (data_len < getImageFormat()->biSizeImage)
  1379.          throw MyError("VideoSourceAVI: uncompressed frame is short (expected %d bytes, got %d)", getImageFormat()->biSizeImage, data_len);
  1381.       DIBconvert(inputBuffer, getImageFormat(), getFrameBuffer(), getDecompressedFormat());
  1382.    }
  1383. // memcpy(getFrameBuffer(), inputBuffer, getDecompressedFormat()->biSizeImage);
  1385. return getFrameBuffer();
  1386. }
  1388. void VideoSourceAVI::streamEnd() {
  1390. // If an error occurs, but no one is there to hear it, was
  1391. // there ever really an error?
  1393. if (hicDecomp) {
  1394. if (use_ICDecompressEx)
  1395. ICDecompressExEnd(hicDecomp);
  1396. else
  1397. ICDecompressEnd(hicDecomp);
  1398. }
  1400. pAVIStream->EndStreaming();
  1402. }
  1404. void *VideoSourceAVI::getFrame(LONG lFrameDesired) {
  1405. void *dataBuffer = NULL;
  1406. LONG dataBufferSize = 0;
  1407. LONG lFrameKey, lFrameNum, lFrameErr=-1;
  1408. LONG lBytesRead, lSamplesRead;
  1409. DWORD err;
  1410. int aviErr;
  1412. // illegal frame number?
  1414. if (lFrameDesired < lSampleFirst || lFrameDesired >= lSampleLast)
  1415. throw MyError("VideoSourceAVI: bad frame # (%d not within [%d, %d])", lFrameDesired, lSampleFirst, lSampleLast-1);
  1417. // do we already have this frame?
  1419. if (lLastFrame == lFrameDesired)
  1420. return getFrameBuffer();
  1422. if (hicDecomp) {
  1424. // back us off to the last key frame if we need to
  1426. lFrameNum = lFrameKey = nearestKey(lFrameDesired);
  1428. _RPT1(0,"Nearest key frame: %ldn", lFrameKey);
  1430. if (lLastFrame > lFrameKey && lLastFrame < lFrameDesired)
  1431. lFrameNum = lLastFrame+1;
  1433. // tell VCM we're going to do a little decompression...
  1435. if (lLastFrame == -1) {
  1436. err = ICDecompressBegin(hicDecomp, getImageFormat(), getDecompressedFormat());
  1437. if (err != ICERR_OK) throw MyICError("VideoSourceAVI", err);
  1438. }
  1439. } else {
  1440. lFrameNum = lFrameDesired;
  1441. }
  1443. _RPT2(0,"VideoSourceAVI: obtaining frame %ld, last was %ldn", lFrameDesired, lLastFrame);
  1445. try {
  1446. restart:
  1447. do {
  1448. _RPT1(0,"VideoSourceAVI: decompressing frame %ldn", lFrameNum);
  1450. for(;;) {
  1451. if (!dataBuffer)
  1452. aviErr = AVIERR_BUFFERTOOSMALL;
  1453. else
  1454. aviErr = read(lFrameNum, 1, dataBuffer, dataBufferSize, &lBytesRead, &lSamplesRead);
  1456. if (aviErr == AVIERR_BUFFERTOOSMALL) {
  1457. void *newDataBuffer;
  1459. aviErr = read(lFrameNum, 1, NULL, 0, &lBytesRead, &lSamplesRead);
  1461. if (aviErr) throw MyAVIError("VideoSourceAVI", aviErr);
  1463. dataBufferSize = (lBytesRead+65535) & -65535;
  1465. if (!(newDataBuffer = reallocmem(dataBuffer, dataBufferSize)))
  1466. throw MyMemoryError();
  1468. dataBuffer = newDataBuffer;
  1470. } else if (aviErr) {
  1471. throw MyAVIError("VideoSourceAVI", aviErr);
  1472. } else {
  1473. // if (hicDecomp || lBytesRead) break;
  1474. // --lFrameNum;
  1475. break;
  1476. }
  1477. };
  1479. if (!lBytesRead) continue;
  1481. if (fUseGDI)
  1482. streamGetFrame(dataBuffer, lBytesRead, TRUE, FALSE, lFrameNum);
  1483. else if (hicDecomp) {
  1484. bmihTemp->biSizeImage = lBytesRead;
  1486. if (lBytesRead) {
  1487. #if 0
  1488. if( lFrameErr==lFrameNum ) {
  1489. if( bit>16 ) {
  1490. bit--;
  1491. int byt = bit>>3;
  1492. BYTE mask = 1 << (bit&7);
  1493. BYTE *p = (BYTE*)dataBuffer;
  1494. p[byt] ^= mask;
  1495. } else {
  1496. throw MyICError("VideoSourceAVI", err);
  1497. }
  1498. }
  1499. #endif
  1500. // VDCHECKPOINT;
  1501. if (ICERR_OK != (err =  ICDecompress(
  1502. hicDecomp,
  1503. //   (lFrameNum<lFrameDesired ? ICDECOMPRESS_PREROLL : 0) |
  1504. //   (lBytesRead ? 0 : ICDECOMPRESS_NULLFRAME) |
  1505.   (lFrameNum > lFrameKey ? ICDECOMPRESS_NOTKEYFRAME : 0),
  1506. bmihTemp,
  1507. dataBuffer,
  1508. getDecompressedFormat(),
  1509. lpvBuffer))) {
  1510. #if 0
  1511. if( lFrameErr==lFrameNum ) {
  1512. //lFrameNum = lFrameKey;
  1513. goto restart;
  1514. }
  1515. if( lFrameErr<0 ) {
  1516. bit = lBytesRead*8;
  1517. lFrameErr = lFrameNum;
  1518. lFrameNum = lFrameKey;
  1519. goto restart;
  1520. }
  1521. #endif
  1522. throw MyICError("VideoSourceAVI", err);
  1523. }
  1524. #if 0
  1525. if( lFrameErr>=0 && (lFrameNum==lFrameErr) ) {
  1526. _RPT2(0,"VideoSourceAVI: frame %ld has errors, xoring bit %ld corrects itn", lFrameNum, bit);
  1527. }
  1528. #endif
  1529. // VDCHECKPOINT;
  1530. }
  1531. } else if (mdec) {
  1532. /* try {
  1533. if (getDecompressedFormat()->biBitCount == 32)
  1534. mdec->decodeFrame32((unsigned long *)getFrameBuffer(), (unsigned char *)dataBuffer, lBytesRead);
  1535. else
  1536. mdec->decodeFrame16((unsigned long *)getFrameBuffer(), (unsigned char *)dataBuffer, lBytesRead);
  1537. } catch(char *s) {
  1538. throw MyError(s);
  1539. }
  1540.  */        } else {
  1541.             if (lBytesRead < getImageFormat()->biSizeImage)
  1542.                throw MyError("VideoSourceAVI: uncompressed frame is short (expected %d bytes, got %d)", getImageFormat()->biSizeImage, lBytesRead);
  1544.             DIBconvert(dataBuffer, getImageFormat(), getFrameBuffer(), getDecompressedFormat());
  1545.          }
  1546. // } else memcpy(getFrameBuffer(), dataBuffer, getDecompressedFormat()->biSizeImage);
  1548. } while(++lFrameNum <= lFrameDesired);
  1550. } catch(MyError e) {
  1551. if (dataBuffer) freemem(dataBuffer);
  1552. ICDecompressEnd(hicDecomp);
  1553. lLastFrame = -1;
  1554. throw e;
  1555. }
  1557. if (dataBuffer) freemem(dataBuffer);
  1558. // if (hicDecomp) ICDecompressEnd(hicDecomp);
  1560. lLastFrame = lFrameDesired; 
  1562. return getFrameBuffer();
  1563. }