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

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

VC书籍

开发平台：

Visual C++

InputFile.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 <process.h>
  19. #include <stdio.h>
  21. #include <windows.h>
  22. #include <vfw.h>
  23. //#include <commdlg.h>
  25. #include "InputFile.h"
  26. #include "AudioSource.h"
  27. #include "VideoSource.h"
  28. #include "Error.h"
  29. #include "AVIStripeSystem.h"
  30. #include "AVIReadHandler.h"
  32. //#include "gui.h"
  33. #include "oshelper.h"
  34. //#include "prefs.h"
  36. #include "Varios.h"
  38. #include "resourceVD.h"
  40. //extern HINSTANCE g_hInst;
  41. //extern char g_msgBuf[128];
  42. //extern const char fileFiltersAppend[];
  43. //extern HWND g_hWnd;
  45. /////////////////////////////////////////////////////////////////////
  47. InputFileOptions::~InputFileOptions() {
  48. }
  50. /////////////////////////////////////////////////////////////////////
  52. InputFilenameNode::InputFilenameNode(const char *_n) : name(strdup(_n)) {
  53. // if (!name)
  54. // throw MyMemoryError();
  55. }
  57. InputFilenameNode::~InputFilenameNode() {
  58. free((char *)name);
  59. }
  61. /////////////////////////////////////////////////////////////////////
  63. InputFile::~InputFile() {
  64. InputFilenameNode *ifn;
  66. while(ifn = listFiles.RemoveTail())
  67. delete ifn;
  68. }
  70. void InputFile::AddFilename(const char *lpszFile) {
  71. InputFilenameNode *ifn = new InputFilenameNode(lpszFile);
  73. if (ifn)
  74. listFiles.AddTail(ifn);
  75. }
  77. bool InputFile::Append(const char *szFile) {
  78. return false;
  79. }
  81. void InputFile::setOptions(InputFileOptions *) {
  82. }
  84. InputFileOptions *InputFile::promptForOptions(HWND) {
  85. return NULL;
  86. }
  88. InputFileOptions *InputFile::createOptions(const char *buf) {
  89. return NULL;
  90. }
  92. void InputFile::InfoDialog(HWND hwndParent) {
  93. }
  95. void InputFile::setAutomated(bool) {
  96. }
  98. bool InputFile::isOptimizedForRealtime() {
  99. return false;
  100. }
  102. bool InputFile::isStreaming() {
  103. return false;
  104. }
  106. /////////////////////////////////////////////////////////////////////
  108. char InputFileAVI::szME[]="AVI Import Filter";
  110. InputFileAVI::InputFileAVI(bool) {
  111. audioSrc = NULL;
  112. videoSrc = NULL;
  114. stripesys = NULL;
  115. stripe_files = NULL;
  116. fAutomated = false;
  118. fAcceptPartial = false;
  119. fInternalMJPEG = false;
  120. fDisableFastIO = false;
  121. iMJPEGMode = 0;
  122. fccForceVideo = 0;
  123. fccForceVideoHandler = 0;
  124. lForceAudioHz = 0;
  126. pAVIFile = NULL;
  128. fCompatibilityMode = fRedoKeyFlags = false;
  130. fAutoscanSegments = false;
  131. }
  133. InputFileAVI::~InputFileAVI() {
  135. delete videoSrc;
  136. delete audioSrc;
  138. if (stripe_files) {
  139. int i;
  141. for(i=0; i<stripe_count; i++)
  142. if (stripe_files[i])
  143. stripe_files[i]->Release();
  145. delete stripe_files;
  146. }
  147. delete stripesys;
  149. if (pAVIFile)
  150. pAVIFile->Release();
  151. }
  153. ///////////////////////////////////////////////
  157. class InputFileAVIOptions : public InputFileOptions {
  158. public:
  159. struct InputFileAVIOpts {
  160. int len;
  161. int iMJPEGMode;
  162. FOURCC fccForceVideo;
  163. FOURCC fccForceVideoHandler;
  164. long lForceAudioHz;
  166. bool fCompatibilityMode;
  167. bool fAcceptPartial;
  168. bool fRedoKeyFlags;
  169. bool fInternalMJPEG;
  170. bool fDisableFastIO;
  171. } opts;
  173. ~InputFileAVIOptions();
  175. bool read(const char *buf);
  176. int write(char *buf, int buflen);
  178. static BOOL APIENTRY SetupDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam);
  179. };
  181. InputFileAVIOptions::~InputFileAVIOptions() {
  182. }
  184. bool InputFileAVIOptions::read(const char *buf) {
  185. const InputFileAVIOpts *pp = (const InputFileAVIOpts *)buf;
  187. if (pp->len != sizeof(InputFileAVIOpts))
  188. return false;
  190. opts = *pp;
  192. return true;
  193. }
  195. int InputFileAVIOptions::write(char *buf, int buflen) {
  196. InputFileAVIOpts *pp = (InputFileAVIOpts *)buf;
  198. if (buflen<sizeof(InputFileAVIOpts))
  199. return 0;
  201. opts.len = sizeof(InputFileAVIOpts);
  202. *pp = opts;
  204. return sizeof(InputFileAVIOpts);
  205. }
  207. ///////
  209. BOOL APIENTRY InputFileAVIOptions::SetupDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam) {
  210. InputFileAVIOptions *thisPtr = (InputFileAVIOptions *)GetWindowLong(hDlg, DWL_USER);
  212. switch(message) {
  213. case WM_INITDIALOG:
  214. SetWindowLong(hDlg, DWL_USER, lParam);
  215. SendDlgItemMessage(hDlg, IDC_FORCE_FOURCC, EM_LIMITTEXT, 4, 0);
  216. CheckDlgButton(hDlg, IDC_IF_NORMAL, BST_CHECKED);
  217. return TRUE;
  219. case WM_COMMAND:
  220. switch(LOWORD(wParam)) {
  221. case IDCANCEL:
  222. if (GetDlgItem(hDlg, IDC_ACCEPTPARTIAL))
  223. thisPtr->opts.fAcceptPartial = !!IsDlgButtonChecked(hDlg, IDC_ACCEPTPARTIAL);
  225. thisPtr->opts.fCompatibilityMode = !!IsDlgButtonChecked(hDlg, IDC_AVI_COMPATIBILITYMODE);
  226. thisPtr->opts.fRedoKeyFlags = !!IsDlgButtonChecked(hDlg, IDC_AVI_REKEY);
  227. thisPtr->opts.fInternalMJPEG = !!IsDlgButtonChecked(hDlg, IDC_AVI_INTERNALMJPEG);
  228. thisPtr->opts.fDisableFastIO = !!IsDlgButtonChecked(hDlg, IDC_AVI_DISABLEOPTIMIZEDIO);
  230. if (IsDlgButtonChecked(hDlg, IDC_IF_NORMAL))
  231. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_NORMAL;
  232. else if (IsDlgButtonChecked(hDlg, IDC_IF_SWAP))
  233. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_SWAP;
  234. else if (IsDlgButtonChecked(hDlg, IDC_IF_SPLITNOSWAP))
  235. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_SPLIT1;
  236. else if (IsDlgButtonChecked(hDlg, IDC_IF_SPLITSWAP))
  237. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_SPLIT2;
  238. else if (IsDlgButtonChecked(hDlg, IDC_IF_DISCARDFIRST))
  239. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_DISCARD1;
  240. else if (IsDlgButtonChecked(hDlg, IDC_IF_DISCARDSECOND))
  241. thisPtr->opts.iMJPEGMode = VideoSourceAVI::IFMODE_DISCARD2;
  243. if (IsDlgButtonChecked(hDlg, IDC_FORCE_FOURCC)) {
  244. union {
  245. char c[5];
  246. FOURCC fccType;
  247. };
  248. int i;
  250. i = SendDlgItemMessage(hDlg, IDC_FOURCC, WM_GETTEXT, sizeof c, (LPARAM)c);
  252. memset(c+i, ' ', 5-i);
  254. if (fccType == 0x20202020)
  255. fccType = ' BID'; // force nothing to DIB, since 0 means no force
  257. thisPtr->opts.fccForceVideo = fccType;
  258. } else
  259. thisPtr->opts.fccForceVideo = 0;
  261. if (IsDlgButtonChecked(hDlg, IDC_FORCE_HANDLER)) {
  262. union {
  263. char c[5];
  264. FOURCC fccType;
  265. };
  266. int i;
  268. i = SendDlgItemMessage(hDlg, IDC_FOURCC2, WM_GETTEXT, sizeof c, (LPARAM)c);
  270. memset(c+i, ' ', 5-i);
  272. if (fccType == 0x20202020)
  273. fccType = ' BID'; // force nothing to DIB, since 0 means no force
  275. thisPtr->opts.fccForceVideoHandler = fccType;
  276. } else
  277. thisPtr->opts.fccForceVideoHandler = 0;
  279. if (IsDlgButtonChecked(hDlg, IDC_FORCE_SAMPRATE))
  280. thisPtr->opts.lForceAudioHz = GetDlgItemInt(hDlg, IDC_AUDIORATE, NULL, FALSE);
  281. else
  282. thisPtr->opts.lForceAudioHz = 0;
  284. EndDialog(hDlg, 0);
  285. return TRUE;
  287. case IDC_FORCE_FOURCC:
  288. EnableWindow(GetDlgItem(hDlg, IDC_FOURCC), IsDlgButtonChecked(hDlg, IDC_FORCE_FOURCC));
  289. return TRUE;
  291. case IDC_FORCE_HANDLER:
  292. EnableWindow(GetDlgItem(hDlg, IDC_FOURCC2), IsDlgButtonChecked(hDlg, IDC_FORCE_HANDLER));
  293. return TRUE;
  295. case IDC_FORCE_SAMPRATE:
  296. EnableWindow(GetDlgItem(hDlg, IDC_AUDIORATE), IsDlgButtonChecked(hDlg, IDC_FORCE_SAMPRATE));
  297. return TRUE;
  298. }
  299. break;
  300. }
  302. return FALSE;
  303. }
  305. void InputFileAVI::setOptions(InputFileOptions *_ifo) {
  306. InputFileAVIOptions *ifo = (InputFileAVIOptions *)_ifo;
  308. fCompatibilityMode = ifo->opts.fCompatibilityMode;
  309. fAcceptPartial = ifo->opts.fAcceptPartial;
  310. fRedoKeyFlags = ifo->opts.fRedoKeyFlags;
  311. fInternalMJPEG = ifo->opts.fInternalMJPEG;
  312. fDisableFastIO = ifo->opts.fDisableFastIO;
  313. iMJPEGMode = ifo->opts.iMJPEGMode;
  314. fccForceVideo = ifo->opts.fccForceVideo;
  315. fccForceVideoHandler= ifo->opts.fccForceVideoHandler;
  316. lForceAudioHz = ifo->opts.lForceAudioHz;
  317. }
  319. InputFileOptions *InputFileAVI::createOptions(const char *buf) {
  320. InputFileAVIOptions *ifo = new InputFileAVIOptions();
  322. if (!ifo) throw MyMemoryError();
  324. if (!ifo->read(buf)) {
  325. delete ifo;
  326. return NULL;
  327. }
  329. return ifo;
  330. }
  332. InputFileOptions *InputFileAVI::promptForOptions(HWND hwnd) {
  333. InputFileAVIOptions *ifo = new InputFileAVIOptions();
  335. if (!ifo) throw MyMemoryError();
  337. DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_EXTOPENOPTS_AVI),
  338. hwnd, InputFileAVIOptions::SetupDlgProc, (LPARAM)ifo);
  340. return ifo;
  341. }
  343. ///////////////////////////////////////////////
  345. static bool fileExists(const char *fn) {
  346. DWORD dwAttrib = GetFileAttributes(fn);
  348. return dwAttrib != -1 && !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY);
  349. }
  351. void InputFileAVI::EnableSegmentAutoscan() {
  352. fAutoscanSegments = true;
  353. }
  355. void InputFileAVI::ForceCompatibility() {
  356. fCompatibilityMode = true;
  357. }
  359. void InputFileAVI::setAutomated(bool fAuto) {
  360. fAutomated = fAuto;
  361. }
  363. void InputFileAVI::Init(char *szFile) {
  364. HRESULT err;
  365. PAVIFILE paf;
  367. AddFilename(szFile);
  369. if (fCompatibilityMode) {
  370. if (err = AVIFileOpen(&paf, szFile, OF_READ, NULL))
  371. throw MyAVIError(szME, err);
  373. if (!(pAVIFile = CreateAVIReadHandler(paf))) {
  374. AVIFileRelease(paf);
  375. throw MyMemoryError();
  376. }
  377. } else {
  378. if (!(pAVIFile = CreateAVIReadHandler(szFile)))
  379. throw MyMemoryError();
  380. }
  382. if (fDisableFastIO)
  383. pAVIFile->EnableFastIO(false);
  385. if (!(videoSrc = new VideoSourceAVI(pAVIFile,NULL,NULL,fInternalMJPEG, iMJPEGMode, fccForceVideo, fccForceVideoHandler)))
  386. throw MyMemoryError();
  388. if (!videoSrc->init())
  389. throw MyError("%s: problem opening video stream", szME);
  391. if (fRedoKeyFlags)
  392. ((VideoSourceAVI *)videoSrc)->redoKeyFlags();
  393. else if (pAVIFile->isIndexFabricated() && !fAutomated && !videoSrc->isKeyframeOnly())
  394. MessageBox(NULL,
  395. //NFJ "Warning: VirtualDub has reconstructed the index for this file, but you have not specified "
  396. //NFJ "rekeying in the extended open options dialog.  Seeking in this file may be slow.",
  397. "The File integrity is NOT OK",
  398. "AVI Import Filter Warning",
  399. MB_OK|MB_ICONEXCLAMATION);
  401. if (videoSrc->isType1() && !fAutomated)
  402. MessageBox(NULL,
  403. //NFJ "Warning: Type-1 DV file detected. Type-1 DV files have video and audio combined into one stream, "
  404. //NFJ "and VirtualDub currently cannot extract the audio. Only the video stream will be available."
  405. "This program doesn't accept Type-1 DV files"
  406. ,
  407. "AVI Import Filter Warning",
  408. MB_OK|MB_ICONEXCLAMATION);
  411. audioSrc = new AudioSourceAVI(pAVIFile);
  412. if (!audioSrc->init()) {
  413. delete audioSrc;
  414. audioSrc = NULL;
  415. } else if (lForceAudioHz) {
  416. WAVEFORMATEX *pwfex = (WAVEFORMATEX *)audioSrc->getFormat();
  418. pwfex->nAvgBytesPerSec = MulDiv(pwfex->nAvgBytesPerSec, lForceAudioHz, pwfex->nSamplesPerSec);
  419. pwfex->nSamplesPerSec = lForceAudioHz;
  420. audioSrc->streamInfo.dwScale = pwfex->nBlockAlign;
  421. audioSrc->streamInfo.dwRate = pwfex->nAvgBytesPerSec;
  422. }
  424. if (fAutoscanSegments) {
  425. char szPath[MAX_PATH], szNameTail[MAX_PATH];
  426. const char *pszName = SplitPathName(szFile);
  427. char *s = szNameTail;
  429. strcpy(szNameTail, pszName);
  430. memcpy(szPath, szFile, pszName-szFile);
  431. szPath[pszName-szFile]=0;
  433. while(*s)
  434. ++s;
  436. if (s > szNameTail+7 && !stricmp(s-7, ".00.avi")) {
  437. int nSegment = 0;
  438. const char *pszPath;
  440. s -= 7;
  441. *s=0;
  443. MergePath(szPath, szNameTail);
  444. s = szPath;
  445. while(*s)
  446. ++s;
  448. try {
  449. while(pAVIFile->getSegmentHint(&pszPath)) {
  451. wsprintf(s, ".%02d.avi", ++nSegment);
  453. if (!fileExists(szPath)) {
  454. if (pszPath && *pszPath) {
  455. strcpy(szPath, pszPath);
  456. MergePath(szPath, szNameTail);
  457. s = szPath;
  458. while(*s)
  459. ++s;
  460. }
  461. wsprintf(s, ".%02d.avi", nSegment);
  462. }
  464. if (!fileExists(szPath)) {
  465. MessageBox( NULL, "N鉶 encontro fich", "N鉶 encontro fich", MB_OK );
  466. /* OPENFILENAME ofn;
  467. char szTitle[MAX_PATH];
  469. wsprintf(szTitle, "Cannot find file %s.%02d.avi", szNameTail, nSegment);
  471. ofn.lStructSize = sizeof(OPENFILENAME);
  472. ofn.hwndOwner = g_hWnd;
  473. ofn.lpstrFilter = fileFiltersAppend;
  474. ofn.lpstrCustomFilter = NULL;
  475. ofn.nFilterIndex = 1;
  476. ofn.lpstrFile = szPath;
  477. ofn.nMaxFile = sizeof szPath;
  478. ofn.lpstrFileTitle = NULL;
  479. ofn.lpstrInitialDir = NULL;
  480. ofn.lpstrTitle = szTitle;
  481. ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_ENABLESIZING;
  482. ofn.lpstrDefExt = g_prefs.main.fAttachExtension ? "avi" : NULL;
  484. if (!GetOpenFileName(&ofn))
  485. throw MyUserAbortError();
  487. if (!Append(szPath))
  488. break;
  490. ((char *)SplitPathName(szPath))[0] = 0;
  491. MergePath(szPath, szNameTail);
  492. s = szPath;
  493. while(*s)
  494. ++s;
  495. */
  496. } else if (!Append(szPath))
  497. break;
  498. }
  499. } catch(MyError e) {
  500. wsprintf(szPath, "Cannot load video segment %02d", nSegment);
  502. e.post(NULL, szPath);
  503. }
  504. }
  505. }
  506. }
  508. bool InputFileAVI::Append(const char *szFile) {
  509. if (fCompatibilityMode || stripesys)
  510. return false;
  512. if (!szFile)
  513. return true;
  515. if (pAVIFile->AppendFile(szFile)) {
  516. if (videoSrc)
  517. ((VideoSourceAVI *)videoSrc)->Reinit();
  518. if (audioSrc)
  519. ((AudioSourceAVI *)audioSrc)->Reinit();
  521. AddFilename(szFile);
  523. return true;
  524. }
  526. return false;
  527. }
  529. void InputFileAVI::InitStriped(char *szFile) {
  530. int i;
  531. HRESULT err;
  532. PAVIFILE paf;
  533. IAVIReadHandler *index_file;
  535. if (!(stripesys = new AVIStripeSystem(szFile)))
  536. throw MyMemoryError();
  538. stripe_count = stripesys->getStripeCount();
  540. if (!(stripe_files = new IAVIReadHandler *[stripe_count]))
  541. throw MyMemoryError();
  543. for(i=0; i<stripe_count; i++)
  544. stripe_files[i]=NULL;
  546. for(i=0; i<stripe_count; i++) {
  547. AVIStripe *asdef = stripesys->getStripeInfo(i);
  549. // Ordinarily, OF_SHARE_DENY_WRITE would be better, but XingMPEG
  550. // Encoder requires write access to AVI files... *sigh*
  552. if (err = AVIFileOpen(&paf, asdef->szName, OF_READ | OF_SHARE_DENY_NONE, NULL))
  553. throw MyAVIError("AVI Striped Import Filter", err);
  555. if (!(stripe_files[i] = CreateAVIReadHandler(paf))) {
  556. AVIFileRelease(paf);
  557. throw MyMemoryError();
  558. }
  560. if (asdef->isIndex())
  561. index_file = stripe_files[i];
  562. }
  564. if (!(videoSrc = new VideoSourceAVI(index_file, stripesys, stripe_files, fInternalMJPEG, iMJPEGMode, fccForceVideo)))
  565. throw MyMemoryError();
  567. if (!videoSrc->init())
  568. throw MyError("%s: problem opening video stream", szME);
  570. if (fRedoKeyFlags) ((VideoSourceAVI *)videoSrc)->redoKeyFlags();
  572. if (!(audioSrc = new AudioSourceAVI(index_file)))
  573. throw MyMemoryError();
  575. if (!audioSrc->init()) {
  576. delete audioSrc;
  577. audioSrc = NULL;
  578. }
  579. }
  581. bool InputFileAVI::isOptimizedForRealtime() {
  582. return pAVIFile->isOptimizedForRealtime();
  583. }
  585. bool InputFileAVI::isStreaming() {
  586. return pAVIFile->isStreaming();
  587. }
  589. ///////////////////////////////////////////////////////////////////////////
  591. typedef struct MyFileInfo {
  592. InputFileAVI *thisPtr;
  594. volatile HWND hWndAbort;
  595. HWND hWnd;
  596. UINT statTimer;
  597. long lVideoKFrames;
  598. long lVideoKMinSize;
  599. __int64 i64VideoKTotalSize;
  600. long lVideoKMaxSize;
  601. long lVideoCFrames;
  602. long lVideoCMinSize;
  603. __int64 i64VideoCTotalSize;
  604. long lVideoCMaxSize;
  606. bool isDivX;
  607. long lDivXComp;
  609. long lAudioFrames;
  610. long lAudioMinSize;
  611. __int64 i64AudioTotalSize;
  612. long lAudioMaxSize;
  614. long lAudioPreload;
  616. bool bAudioFramesIndeterminate;
  617. } MyFileInfo;
  619. void InputFileAVI::_InfoDlgThread(void *pvInfo) {
  620. MyFileInfo *pInfo = (MyFileInfo *)pvInfo;
  621. LONG i;
  622. LONG lActualBytes, lActualSamples;
  623. VideoSourceAVI *inputVideoAVI = (VideoSourceAVI *)pInfo->thisPtr->videoSrc;
  624. AudioSourceAVI *inputAudioAVI = (AudioSourceAVI *)pInfo->thisPtr->audioSrc;
  626. pInfo->lVideoCMinSize = 0x7FFFFFFF;
  627. pInfo->lVideoKMinSize = 0x7FFFFFFF;
  629. for(i=inputVideoAVI->lSampleFirst; i<inputVideoAVI->lSampleLast; ++i) {
  630. if (inputVideoAVI->isKey(i)) {
  631. ++pInfo->lVideoKFrames;
  633. if (!inputVideoAVI->read(i, 1, NULL, 0, &lActualBytes, NULL)) {
  634. pInfo->i64VideoKTotalSize += lActualBytes;
  635. if (lActualBytes < pInfo->lVideoKMinSize) pInfo->lVideoKMinSize = lActualBytes;
  636. if (lActualBytes > pInfo->lVideoKMaxSize) pInfo->lVideoKMaxSize = lActualBytes;
  637. }
  638. } else {
  639. ++pInfo->lVideoCFrames;
  641. if (!inputVideoAVI->read(i, 1, NULL, 0, &lActualBytes, NULL)) {
  642. pInfo->i64VideoCTotalSize += lActualBytes;
  643. if (lActualBytes < pInfo->lVideoCMinSize) pInfo->lVideoCMinSize = lActualBytes;
  644. if (lActualBytes > pInfo->lVideoCMaxSize) pInfo->lVideoCMaxSize = lActualBytes;
  645. }
  646. }
  648. if( pInfo->isDivX ) {
  649. unsigned char *b = (unsigned char *)malloc( lActualBytes );
  650. if( b ) {
  651. if (!inputVideoAVI->read(i, 1, b, lActualBytes, &lActualBytes, NULL)) {
  652. pInfo->lDivXComp += ((b[0] & 0x3E)>>1);
  653. }
  654. free( b );
  655. }
  656. }
  658. if (pInfo->hWndAbort) {
  659. SendMessage(pInfo->hWndAbort, WM_USER+256, 0, 0);
  660. return;
  661. }
  662. }
  664. if (inputAudioAVI) {
  665. pInfo->lAudioMinSize = 0x7FFFFFFF;
  666. pInfo->bAudioFramesIndeterminate = false;
  668. i = inputAudioAVI->lSampleFirst;
  669. while(i < inputAudioAVI->lSampleLast) {
  670. if (inputAudioAVI->read(i, AVISTREAMREAD_CONVENIENT, NULL, 0, &lActualBytes, &lActualSamples))
  671. break;
  673. if (!lActualSamples) {
  674. pInfo->bAudioFramesIndeterminate = true;
  675. break;
  676. }
  678. ++pInfo->lAudioFrames;
  679. i += lActualSamples;
  681. if (inputAudioAVI->streamInfo.dwInitialFrames == pInfo->lAudioFrames)
  682. pInfo->lAudioPreload = i - inputAudioAVI->lSampleFirst;
  684. pInfo->i64AudioTotalSize += lActualBytes;
  685. if (lActualBytes < pInfo->lAudioMinSize) pInfo->lAudioMinSize = lActualBytes;
  686. if (lActualBytes > pInfo->lAudioMaxSize) pInfo->lAudioMaxSize = lActualBytes;
  688. if (pInfo->hWndAbort) {
  689. SendMessage(pInfo->hWndAbort, WM_USER+256, 0, 0);
  690. return;
  691. }
  692. }
  693. }
  695. SendMessage(pInfo->hWnd, WM_TIMER, 0, 0);
  697. pInfo->hWndAbort = (HWND)1;
  698. }
  700. BOOL APIENTRY InputFileAVI::_InfoDlgProc( HWND hDlg, UINT message, UINT wParam, LONG lParam) {
  701. MyFileInfo *pInfo = (MyFileInfo *)GetWindowLong(hDlg, DWL_USER);
  702. InputFileAVI *thisPtr;
  704. if (pInfo)
  705. thisPtr = pInfo->thisPtr;
  707. char g_msgBuf[1024]; //NFJ
  710.     switch (message)
  711.     {
  712.         case WM_INITDIALOG:
  713. SetWindowLong(hDlg, DWL_USER, lParam);
  714. pInfo = (MyFileInfo *)lParam;
  715. thisPtr = pInfo->thisPtr;
  717. if (thisPtr->videoSrc) {
  718. ICINFO icinfo;
  719. char *s;
  720. HIC hic;
  721. const VideoSourceAVI *pvs = (const VideoSourceAVI *)thisPtr->videoSrc;
  723. sprintf(g_msgBuf, "%dx%d, %.3f fps (%ld 祍)n",
  724. thisPtr->videoSrc->getImageFormat()->biWidth,
  725. thisPtr->videoSrc->getImageFormat()->biHeight,
  726. (float)thisPtr->videoSrc->streamInfo.dwRate / thisPtr->videoSrc->streamInfo.dwScale,
  727. MulDiv(thisPtr->videoSrc->streamInfo.dwScale, 1000000L, thisPtr->videoSrc->streamInfo.dwRate));
  728. SetDlgItemText(hDlg, IDC_VIDEO_FORMAT, g_msgBuf);
  730. s = g_msgBuf + sprintf(g_msgBuf, "%ld (", thisPtr->videoSrc->streamInfo.dwLength);
  731. ticks_to_str(s, MulDiv(1000L*thisPtr->videoSrc->streamInfo.dwLength, thisPtr->videoSrc->streamInfo.dwScale, thisPtr->videoSrc->streamInfo.dwRate));
  732. strcat(s,")");
  733. SetDlgItemText(hDlg, IDC_VIDEO_NUMFRAMES, g_msgBuf);
  735. strcpy(g_msgBuf, "Unknown");
  737. if (hic = pvs->getDecompressorHandle()) {
  738. if (ICGetInfo(hic, &icinfo, sizeof(ICINFO))) {
  739. g_msgBuf[WideCharToMultiByte(CP_ACP, 0, icinfo.szDescription, -1, g_msgBuf, sizeof(g_msgBuf)-7, NULL, NULL)]=0;
  740. if( icinfo.fccHandler==mmioFOURCC('D','I','V','3') || icinfo.fccHandler==mmioFOURCC('D','I','V','4') ) {
  741. pInfo->isDivX = true;
  742. }
  743. }
  744. } else if (pvs->isUsingInternalMJPEG())
  745. strcpy(g_msgBuf, "VirtualDub internal MJPEG");
  746. else if (pvs->getImageFormat()->biCompression == '2YUY')
  747. strcpy(g_msgBuf, "YUV 4:2:2 (YUY2)");
  748. else if (pvs->getImageFormat()->biCompression == '024I')
  749. strcpy(g_msgBuf, "YUV 4:2:0 (I420)");
  750. else
  751. sprintf(g_msgBuf, "Uncompressed RGB%d", pvs->getImageFormat()->biBitCount);
  753. SetDlgItemText(hDlg, IDC_VIDEO_COMPRESSION, g_msgBuf);
  754. }
  755. if (thisPtr->audioSrc) {
  756. WAVEFORMATEX *fmt = thisPtr->audioSrc->getWaveFormat();
  757. DWORD cbwfxTemp;
  758. WAVEFORMATEX *pwfxTemp;
  759. HACMSTREAM has;
  760. HACMDRIVERID hadid;
  761. ACMDRIVERDETAILS add;
  762. bool fSuccessful = false;
  764. sprintf(g_msgBuf, "%ldHz", fmt->nSamplesPerSec);
  765. SetDlgItemText(hDlg, IDC_AUDIO_SAMPLINGRATE, g_msgBuf);
  767. sprintf(g_msgBuf, "%d (%s)", fmt->nChannels, fmt->nChannels>1 ? "Stereo" : "Mono");
  768. SetDlgItemText(hDlg, IDC_AUDIO_CHANNELS, g_msgBuf);
  770. sprintf(g_msgBuf, "%d-bit", fmt->wBitsPerSample);
  771. SetDlgItemText(hDlg, IDC_AUDIO_PRECISION, g_msgBuf);
  773. sprintf(g_msgBuf, "%ld", thisPtr->audioSrc->lSampleLast - thisPtr->audioSrc->lSampleFirst);
  774. SetDlgItemText(hDlg, IDC_AUDIO_NUMFRAMES, g_msgBuf);
  776. ////////// Attempt to detect audio compression //////////
  778. if (fmt->wFormatTag != WAVE_FORMAT_PCM) {
  779. // Retrieve maximum format size.
  781. acmMetrics(NULL, ACM_METRIC_MAX_SIZE_FORMAT, (LPVOID)&cbwfxTemp);
  783. // Fill out a destination wave format (PCM).
  785. if (pwfxTemp = (WAVEFORMATEX *)allocmem(cbwfxTemp)) {
  786. pwfxTemp->wFormatTag = WAVE_FORMAT_PCM;
  788. // Ask ACM to fill out the details.
  790. if (!acmFormatSuggest(NULL, fmt, pwfxTemp, cbwfxTemp, ACM_FORMATSUGGESTF_WFORMATTAG)) {
  791. if (!acmStreamOpen(&has, NULL, fmt, pwfxTemp, NULL, NULL, NULL, ACM_STREAMOPENF_NONREALTIME)) {
  792. if (!acmDriverID((HACMOBJ)has, &hadid, 0)) {
  793. memset(&add, 0, sizeof add);
  795. add.cbStruct = sizeof add;
  797. if (!acmDriverDetails(hadid, &add, 0)) {
  798. SetDlgItemText(hDlg, IDC_AUDIO_COMPRESSION, add.szLongName);
  800. fSuccessful = true;
  801. }
  802. }
  804. acmStreamClose(has, 0);
  805. }
  806. }
  808. freemem(pwfxTemp);
  809. }
  811. if (!fSuccessful) {
  812. char buf[32];
  814. wsprintf(buf, "Unknown (tag %04X)", fmt->wFormatTag);
  815. SetDlgItemText(hDlg, IDC_AUDIO_COMPRESSION, buf);
  816. }
  817. } else {
  818. // It's a PCM format...
  820. SetDlgItemText(hDlg, IDC_AUDIO_COMPRESSION, "PCM (Uncompressed)");
  821. }
  822. }
  824. pInfo->hWnd = hDlg;
  826. _beginthread(_InfoDlgThread, 10000, pInfo);
  828. pInfo->statTimer = SetTimer(hDlg, 1, 25000000, NULL);
  830.             return (TRUE);
  832.         case WM_COMMAND:                      
  833.             if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
  834.             {
  835. if (pInfo->hWndAbort == (HWND)1)
  836. EndDialog(hDlg, TRUE);
  837. else
  838. pInfo->hWndAbort = hDlg;
  839.                 return TRUE;
  840.             }
  841.             break;
  843. case WM_DESTROY:
  844. if (pInfo->statTimer) KillTimer(hDlg, pInfo->statTimer);
  845. break;
  847. case WM_TIMER:
  848. _RPT0(0,"timer hitn");
  849. sprintf(g_msgBuf, "%ld", pInfo->lVideoKFrames);
  850. SetDlgItemText(hDlg, IDC_VIDEO_NUMKEYFRAMES, g_msgBuf);
  852. if (pInfo->lVideoKFrames)
  853. sprintf(g_msgBuf, "%ld/%I64d/%ld (%I64dK)"
  854. ,pInfo->lVideoKMinSize
  855. ,pInfo->i64VideoKTotalSize/pInfo->lVideoKFrames
  856. ,pInfo->lVideoKMaxSize
  857. ,(pInfo->i64VideoKTotalSize+1023)>>10);
  858. else
  859. strcpy(g_msgBuf,"(no key frames)");
  860. SetDlgItemText(hDlg, IDC_VIDEO_KEYFRAMESIZES, g_msgBuf);
  862. if (pInfo->lVideoCFrames)
  863. sprintf(g_msgBuf, "%ld/%I64d/%ld (%I64dK)"
  864. ,pInfo->lVideoCMinSize
  865. ,pInfo->i64VideoCTotalSize/pInfo->lVideoCFrames
  866. ,pInfo->lVideoCMaxSize
  867. ,(pInfo->i64VideoCTotalSize+1023)>>10);
  868. else
  869. strcpy(g_msgBuf,"(no delta frames)");
  870. SetDlgItemText(hDlg, IDC_VIDEO_NONKEYFRAMESIZES, g_msgBuf);
  872. if( pInfo->isDivX ) {
  873. sprintf(g_msgBuf, "%7.3f", 200.0/(((double)pInfo->lDivXComp)/thisPtr->videoSrc->streamInfo.dwLength) );
  874. SetDlgItemText(hDlg, IDC_VIDEO_COMPRESSIONLEVEL, g_msgBuf);
  875. }
  877. if (thisPtr->audioSrc) {
  878. if (pInfo->bAudioFramesIndeterminate) {
  879. SetDlgItemText(hDlg, IDC_AUDIO_NUMFRAMES, "(indeterminate)");
  880. SetDlgItemText(hDlg, IDC_AUDIO_FRAMESIZES, "(indeterminate)");
  881. SetDlgItemText(hDlg, IDC_AUDIO_PRELOAD, "(indeterminate)");
  882. } else {
  883. sprintf(g_msgBuf,"%ld",pInfo->lAudioFrames);
  884. SetDlgItemText(hDlg, IDC_AUDIO_NUMFRAMES, g_msgBuf);
  886. if (pInfo->lAudioFrames)
  887. sprintf(g_msgBuf, "%ld/%I64d/%ld (%I64dK)"
  888. ,pInfo->lAudioMinSize
  889. ,pInfo->i64AudioTotalSize/pInfo->lAudioFrames
  890. ,pInfo->lAudioMaxSize
  891. ,(pInfo->i64AudioTotalSize+1023)>>10);
  892. else
  893. strcpy(g_msgBuf,"(no audio frames)");
  894. SetDlgItemText(hDlg, IDC_AUDIO_FRAMESIZES, g_msgBuf);
  896. sprintf(g_msgBuf, "%ld samples (%.2fs)",pInfo->lAudioPreload,(double)pInfo->lAudioPreload/thisPtr->audioSrc->getWaveFormat()->nSamplesPerSec);
  897. SetDlgItemText(hDlg, IDC_AUDIO_PRELOAD, g_msgBuf);
  898. }
  899. }
  901. /////////
  903. if (pInfo->hWndAbort) {
  904. KillTimer(hDlg, pInfo->statTimer);
  905. return TRUE;
  906. }
  908. break;
  910. case WM_USER+256:
  911. EndDialog(hDlg, TRUE);  
  912. break;
  913.     }
  914.     return FALSE;
  915. }
  917. void InputFileAVI::InfoDialog(HWND hwndParent) {
  918. MyFileInfo mai;
  920. memset(&mai, 0, sizeof mai);
  921. mai.thisPtr = this;
  923. // DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_AVI_INFO), hwndParent, _InfoDlgProc, (LPARAM)&mai);
  924. }