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

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

多媒体编程

开发平台：

Visual C++

plugins.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 <afxdlgs.h>
  24. #include <atlpath.h>
  25. #include "resource.h"
  26. #include "......subtitlesVobSubFile.h"
  27. #include "......subtitlesRTS.h"
  28. #include "......SubPicMemSubPic.h"
  30. //
  31. // Generic interface
  32. //
  34. namespace Plugin
  35. {
  37. class CFilter : public CAMThread, public CCritSec
  38. {
  39. private:
  40. CString m_fn;
  42. protected:
  43. float m_fps;
  44. CCritSec m_csSubLock;
  45. CComPtr<ISubPicQueue> m_pSubPicQueue;
  46. CComPtr<ISubPicProvider> m_pSubPicProvider;
  47. DWORD_PTR m_SubPicProviderId;
  49. public:
  50. CFilter() : m_fps(-1), m_SubPicProviderId(0) {CAMThread::Create();}
  51. virtual ~CFilter() {CAMThread::CallWorker(0);}
  53. CString GetFileName() {CAutoLock cAutoLock(this); return m_fn;}
  54. void SetFileName(CString fn) {CAutoLock cAutoLock(this); m_fn = fn;}
  56. bool Render(SubPicDesc& dst, REFERENCE_TIME rt, float fps)
  57. {
  58. if(!m_pSubPicProvider)
  59. return(false);
  61. CSize size(dst.w, dst.h);
  63. if(!m_pSubPicQueue)
  64. {
  65. CComPtr<ISubPicAllocator> pAllocator = new CMemSubPicAllocator(dst.type, size);
  67. HRESULT hr;
  68. if(!(m_pSubPicQueue = new CSubPicQueueNoThread(pAllocator, &hr)) || FAILED(hr))
  69. {
  70. m_pSubPicQueue = NULL;
  71. return(false);
  72. }
  73. }
  75. if(m_SubPicProviderId != (DWORD_PTR)(ISubPicProvider*)m_pSubPicProvider)
  76. {
  77. m_pSubPicQueue->SetSubPicProvider(m_pSubPicProvider);
  78. m_SubPicProviderId = (DWORD_PTR)(ISubPicProvider*)m_pSubPicProvider;
  79. }
  81. CComPtr<ISubPic> pSubPic;
  82. if(!m_pSubPicQueue->LookupSubPic(rt, &pSubPic))
  83. return(false);
  85. CRect r;
  86. pSubPic->GetDirtyRect(r);
  88. if(dst.type == MSP_RGB32 || dst.type == MSP_RGB24 || dst.type == MSP_RGB16 || dst.type == MSP_RGB15)
  89. dst.h = -dst.h;
  91. pSubPic->AlphaBlt(r, r, &dst);
  93. return(true);
  94. }
  96. DWORD ThreadProc()
  97. {
  98. SetThreadPriority(m_hThread, THREAD_PRIORITY_LOWEST);
  100. CArray<HANDLE> handles;
  101. handles.Add(GetRequestHandle());
  103. CString fn = GetFileName();
  104. CFileStatus fs;
  105. fs.m_mtime = 0;
  106. CFileGetStatus(fn, fs);
  108. while(1)
  109. {
  110. DWORD i = WaitForMultipleObjects(handles.GetSize(), handles.GetData(), FALSE, 1000);
  112. if(WAIT_OBJECT_0 == i)
  113. {
  114. Reply(S_OK);
  115. break;
  116. }
  117. else if(WAIT_ABANDONED_0 == i)
  118. {
  119. break;
  120. }
  121. else if(WAIT_OBJECT_0 + 1 >= i && i <= WAIT_OBJECT_0 + handles.GetCount())
  122. {
  123. if(FindNextChangeNotification(handles[i - WAIT_OBJECT_0]))
  124. {
  125. CFileStatus fs2;
  126. fs2.m_mtime = 0;
  127. CFileGetStatus(fn, fs2);
  129. if(fs.m_mtime < fs2.m_mtime)
  130. {
  131. fs.m_mtime = fs2.m_mtime;
  133. if(CComQIPtr<ISubStream> pSubStream = m_pSubPicProvider)
  134. {
  135. CAutoLock cAutoLock(&m_csSubLock);
  136. pSubStream->Reload();
  137. }
  138. }
  139. }
  140. }
  141. else if(WAIT_TIMEOUT == i)
  142. {
  143. CString fn2 = GetFileName();
  145. if(fn != fn2)
  146. {
  147. CPath p(fn2);
  148. p.RemoveFileSpec();
  149. HANDLE h = FindFirstChangeNotification(p, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE); 
  150. if(h != INVALID_HANDLE_VALUE)
  151. {
  152. fn = fn2;
  153. handles.SetSize(1);
  154. handles.Add(h);
  155. }
  156. }
  157. }
  158. }
  160. for(int i = 1; i < handles.GetCount(); i++)
  161. FindCloseChangeNotification(handles[i]);
  163. return 0;
  164. }
  165. };
  167. class CVobSubFilter : virtual public CFilter
  168. {
  169. public:
  170. CVobSubFilter(CString fn = _T(""))
  171. {
  172. if(!fn.IsEmpty()) Open(fn);
  173. }
  175. bool Open(CString fn)
  176. {
  177. SetFileName(_T(""));
  178. m_pSubPicProvider = NULL;
  180. if(CVobSubFile* vsf = new CVobSubFile(&m_csSubLock))
  181. {
  182. m_pSubPicProvider = (ISubPicProvider*)vsf;
  183. if(vsf->Open(CString(fn))) SetFileName(fn);
  184. else m_pSubPicProvider = NULL;
  185. }
  187. return !!m_pSubPicProvider;
  188. }
  189. };
  191. class CTextSubFilter : virtual public CFilter
  192. {
  193. int m_CharSet;
  195. public:
  196. CTextSubFilter(CString fn = _T(""), int CharSet = DEFAULT_CHARSET, float fps = -1)
  197. : m_CharSet(CharSet)
  198. {
  199. m_fps = fps;
  200. if(!fn.IsEmpty()) Open(fn, CharSet);
  201. }
  203. int GetCharSet() {return(m_CharSet);}
  205. bool Open(CString fn, int CharSet = DEFAULT_CHARSET)
  206. {
  207. SetFileName(_T(""));
  208. m_pSubPicProvider = NULL;
  210. if(CRenderedTextSubtitle* rts = new CRenderedTextSubtitle(&m_csSubLock))
  211. {
  212. m_pSubPicProvider = (ISubPicProvider*)rts;
  213. if(rts->Open(CString(fn), CharSet)) SetFileName(fn);
  214. else m_pSubPicProvider = NULL;
  215. }
  217. return !!m_pSubPicProvider;
  218. }
  219. };
  221. //
  222. // VirtualDub interface
  223. //
  225. namespace VirtualDub
  226. {
  227. #include "........includeVirtualDubVirtualDub.h"
  229. class CVirtualDubFilter : virtual public CFilter
  230. {
  231. public:
  232. CVirtualDubFilter() {}
  233. virtual ~CVirtualDubFilter() {}
  235. virtual int RunProc(const FilterActivation* fa, const FilterFunctions* ff)
  236. {
  237. SubPicDesc dst;
  238. dst.type = MSP_RGB32;
  239. dst.w = fa->src.w;
  240. dst.h = fa->src.h;
  241. dst.bpp = 32;
  242. dst.pitch = fa->src.pitch;
  243. dst.bits = (LPVOID)fa->src.data;
  245. Render(dst, 10000i64*fa->pfsi->lSourceFrameMS, (float)1000 / fa->pfsi->lMicrosecsPerFrame);
  247. return 0;
  248. }
  250. virtual long ParamProc(FilterActivation* fa, const FilterFunctions* ff)
  251. {
  252. fa->dst.offset = fa->src.offset;
  253. fa->dst.modulo = fa->src.modulo;
  254. fa->dst.pitch = fa->src.pitch;
  256. return 0;
  257. }
  259. virtual int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd) = 0;
  260. virtual void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str) = 0;
  261. virtual bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen) = 0;
  262. };
  264. class CVobSubVirtualDubFilter : public CVobSubFilter, public CVirtualDubFilter
  265. {
  266. public:
  267. CVobSubVirtualDubFilter(CString fn = _T("")) 
  268. : CVobSubFilter(fn) {}
  270. int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
  271. {
  272. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  274. CFileDialog fd(TRUE, NULL, GetFileName(), OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY, 
  275. _T("VobSub files (*.idx;*.sub)|*.idx;*.sub||"), CWnd::FromHandle(hwnd), 0);
  277. if(fd.DoModal() != IDOK) return 1;
  279. return Open(fd.GetPathName()) ? 0 : 1;
  280. }
  282. void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
  283. {
  284. sprintf(str, " (%s)", !GetFileName().IsEmpty() ? CStringA(GetFileName()) : " (empty)");
  285. }
  287. bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
  288. {
  289. CStringA fn(GetFileName());
  290. fn.Replace("\", "\\");
  291. _snprintf(buf, buflen, "Config("%s")", fn);
  292. return(true);
  293. }
  294. };
  296. class CTextSubVirtualDubFilter : public CTextSubFilter, public CVirtualDubFilter
  297. {
  298. public:
  299. CTextSubVirtualDubFilter(CString fn = _T(""), int CharSet = DEFAULT_CHARSET) 
  300. : CTextSubFilter(fn, CharSet) {}
  302. int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
  303. {
  304. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  306. const TCHAR formats[] = _T("TextSub files (*.sub;*.srt;*.smi;*.ssa;*.ass;*.xss;*.psb;*.txt)|*.sub;*.srt;*.smi;*.ssa;*.ass;*.xss;*.psb;*.txt||");
  307. CFileDialog fd(TRUE, NULL, GetFileName(), OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_ENABLETEMPLATE|OFN_ENABLEHOOK, 
  308. formats, CWnd::FromHandle(hwnd), OPENFILENAME_SIZE_VERSION_400 /*0*/);
  310. UINT CALLBACK OpenHookProc(HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam);
  312. fd.m_pOFN->hInstance = AfxGetResourceHandle();
  313. fd.m_pOFN->lpTemplateName = MAKEINTRESOURCE(IDD_TEXTSUBOPENTEMPLATE);
  314. fd.m_pOFN->lpfnHook = OpenHookProc;
  315. fd.m_pOFN->lCustData = (LPARAM)DEFAULT_CHARSET;
  317. if(fd.DoModal() != IDOK) return 1;
  319. return Open(fd.GetPathName(), fd.m_pOFN->lCustData) ? 0 : 1;
  320. }
  322. void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
  323. {
  324. if(!GetFileName().IsEmpty()) sprintf(str, " (%s, %d)", CStringA(GetFileName()), GetCharSet());
  325. else sprintf(str, " (empty)");
  326. }
  328. bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
  329. {
  330. CStringA fn(GetFileName());
  331. fn.Replace("\", "\\");
  332. _snprintf(buf, buflen, "Config("%s", %d)", fn, GetCharSet());
  333. return(true);
  334. }
  335. };
  337. int vobsubInitProc(FilterActivation* fa, const FilterFunctions* ff)
  338. {
  339. return !(*(CVirtualDubFilter**)fa->filter_data = new CVobSubVirtualDubFilter());
  340. }
  342. int textsubInitProc(FilterActivation* fa, const FilterFunctions* ff)
  343. {
  344. return !(*(CVirtualDubFilter**)fa->filter_data = new CTextSubVirtualDubFilter());
  345. }
  347. void baseDeinitProc(FilterActivation* fa, const FilterFunctions* ff)
  348. {
  349. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  350. if(f) delete f, f = NULL;
  351. }
  353. int baseRunProc(const FilterActivation* fa, const FilterFunctions* ff)
  354. {
  355. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  356. return f ? f->RunProc(fa, ff) : 1;
  357. }
  359. long baseParamProc(FilterActivation* fa, const FilterFunctions* ff)
  360. {
  361. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  362. return f ? f->ParamProc(fa, ff) : 1;
  363. }
  365. int baseConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
  366. {
  367. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  368. return f ? f->ConfigProc(fa, ff, hwnd) : 1;
  369. }
  371. void baseStringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
  372. {
  373. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  374. if(f) f->StringProc(fa, ff, str);
  375. }
  377. bool baseFssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
  378. {
  379. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  380. return f ? f->FssProc(fa, ff, buf, buflen) : false;
  381. }
  383. void vobsubScriptConfig(IScriptInterpreter* isi, void* lpVoid, CScriptValue* argv, int argc)
  384. {
  385. FilterActivation* fa = (FilterActivation*)lpVoid;
  386. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  387. if(f) delete f;
  388. f = new CVobSubVirtualDubFilter(CString(*argv[0].asString()));
  389. *(CVirtualDubFilter**)fa->filter_data = f;
  390. }
  392. void textsubScriptConfig(IScriptInterpreter* isi, void* lpVoid, CScriptValue* argv, int argc)
  393. {
  394. FilterActivation* fa = (FilterActivation*)lpVoid;
  395. CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
  396. if(f) delete f;
  397. f = new CTextSubVirtualDubFilter(CString(*argv[0].asString()), argv[1].asInt());
  398. *(CVirtualDubFilter**)fa->filter_data = f;
  399. }
  401. ScriptFunctionDef vobsub_func_defs[]={
  402. { (ScriptFunctionPtr)vobsubScriptConfig, "Config", "0s" },
  403. { NULL },
  404. };
  406. CScriptObject vobsub_obj={
  407. NULL, vobsub_func_defs
  408. };
  410. struct FilterDefinition filterDef_vobsub = 
  411. {
  412. NULL, NULL, NULL,       // next, prev, module
  413. "VobSub", // name
  414. "Adds subtitles from a vob sequence.", // desc
  415. "Gabest",               // maker
  416. NULL,                   // private_data
  417. sizeof(CVirtualDubFilter**), // inst_data_size
  418. vobsubInitProc,         // initProc
  419. baseDeinitProc, // deinitProc
  420. baseRunProc, // runProc
  421. baseParamProc, // paramProc
  422. baseConfigProc, // configProc
  423. baseStringProc, // stringProc
  424. NULL, // startProc
  425. NULL, // endProc
  426. &vobsub_obj, // script_obj
  427. baseFssProc, // fssProc
  428. };
  430. ScriptFunctionDef textsub_func_defs[]={
  431. { (ScriptFunctionPtr)textsubScriptConfig, "Config", "0si" },
  432. { NULL },
  433. };
  435. CScriptObject textsub_obj={
  436. NULL, textsub_func_defs
  437. };
  439. struct FilterDefinition filterDef_textsub = 
  440. {
  441. NULL, NULL, NULL,       // next, prev, module
  442. "TextSub", // name
  443. "Adds subtitles from srt, sub, psb, smi, ssa, ass file formats.", // desc
  444. "Gabest",               // maker
  445. NULL,                   // private_data
  446. sizeof(CVirtualDubFilter**), // inst_data_size
  447. textsubInitProc,        // initProc
  448. baseDeinitProc, // deinitProc
  449. baseRunProc, // runProc
  450. baseParamProc, // paramProc
  451. baseConfigProc, // configProc
  452. baseStringProc, // stringProc
  453. NULL, // startProc
  454. NULL, // endProc
  455. &textsub_obj, // script_obj
  456. baseFssProc, // fssProc
  457. };
  459. static FilterDefinition* fd_vobsub;
  460. static FilterDefinition* fd_textsub;
  462. extern "C" __declspec(dllexport) int __cdecl VirtualdubFilterModuleInit2(FilterModule *fm, const FilterFunctions *ff, int& vdfd_ver, int& vdfd_compat)
  463. {
  464. if(!(fd_vobsub = ff->addFilter(fm, &filterDef_vobsub, sizeof(FilterDefinition)))
  465. || !(fd_textsub = ff->addFilter(fm, &filterDef_textsub, sizeof(FilterDefinition))))
  466. return 1;
  468. vdfd_ver = VIRTUALDUB_FILTERDEF_VERSION;
  469. vdfd_compat = VIRTUALDUB_FILTERDEF_COMPATIBLE;
  471. return 0;
  472. }
  474. extern "C" __declspec(dllexport) void __cdecl VirtualdubFilterModuleDeinit(FilterModule *fm, const FilterFunctions *ff)
  475. {
  476. ff->removeFilter(fd_textsub);
  477. ff->removeFilter(fd_vobsub);
  478. }
  479. }
  481. //
  482. // Avisynth interface
  483. //
  485. namespace AviSynth1
  486. {
  487. #include "........includeavisynthavisynth1.h"
  489. class CAvisynthFilter : public GenericVideoFilter, virtual public CFilter
  490. {
  491. public:
  492. CAvisynthFilter(PClip c, IScriptEnvironment* env) : GenericVideoFilter(c) {}
  494. PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
  495. {
  496. PVideoFrame frame = child->GetFrame(n, env);
  498. env->MakeWritable(&frame);
  500. SubPicDesc dst;
  501. dst.w = vi.width;
  502. dst.h = vi.height;
  503. dst.pitch = frame->GetPitch();
  504. dst.bits = (void**)frame->GetWritePtr();
  505. dst.bpp = vi.BitsPerPixel();
  506. dst.type = 
  507. vi.IsRGB32() ? MSP_RGB32 : 
  508. vi.IsRGB24() ? MSP_RGB24 : 
  509. vi.IsYUY2() ? MSP_YUY2 : 
  510. -1;
  512. float fps = m_fps > 0 ? m_fps : (float)vi.fps_numerator / vi.fps_denominator;
  514. Render(dst, (REFERENCE_TIME)(10000000i64 * n / fps), fps);
  516. return(frame);
  517. }
  518. };
  520. class CVobSubAvisynthFilter : public CVobSubFilter, public CAvisynthFilter
  521. {
  522. public:
  523. CVobSubAvisynthFilter(PClip c, const char* fn, IScriptEnvironment* env)
  524. : CVobSubFilter(CString(fn))
  525. , CAvisynthFilter(c, env)
  526. {
  527. if(!m_pSubPicProvider)
  528. env->ThrowError("VobSub: Can't open "%s"", fn);
  529. }
  530. };
  532. AVSValue __cdecl VobSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
  533. {
  534. return(new CVobSubAvisynthFilter(args[0].AsClip(), args[1].AsString(), env));
  535. }
  536.     
  537. class CTextSubAvisynthFilter : public CTextSubFilter, public CAvisynthFilter
  538. {
  539. public:
  540. CTextSubAvisynthFilter(PClip c, IScriptEnvironment* env, const char* fn, int CharSet = DEFAULT_CHARSET, float fps = -1)
  541. : CTextSubFilter(CString(fn), CharSet, fps)
  542. , CAvisynthFilter(c, env)
  543. {
  544. if(!m_pSubPicProvider)
  545. env->ThrowError("TextSub: Can't open "%s"", fn);
  546. }
  547. };
  549. AVSValue __cdecl TextSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
  550. {
  551. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString()));
  552. }
  554. AVSValue __cdecl TextSubCreateSI(AVSValue args, void* user_data, IScriptEnvironment* env)
  555. {
  556. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt()));
  557. }
  559. AVSValue __cdecl TextSubCreateSIF(AVSValue args, void* user_data, IScriptEnvironment* env)
  560. {
  561. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt(), args[3].AsFloat()));
  562. }
  564. extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit(IScriptEnvironment* env)
  565. {
  566. env->AddFunction("VobSub", "cs", VobSubCreateS, 0);
  567. env->AddFunction("TextSub", "cs", TextSubCreateS, 0);
  568. env->AddFunction("TextSub", "csi", TextSubCreateSI, 0);
  569. env->AddFunction("TextSub", "csif", TextSubCreateSIF, 0);
  570. return(NULL);
  571. }
  572. }
  574. namespace AviSynth25
  575. {
  576. #include "........includeavisynthavisynth25.h"
  578. static bool s_fSwapUV = false;
  580. class CAvisynthFilter : public GenericVideoFilter, virtual public CFilter
  581. {
  582. public:
  583. CAvisynthFilter(PClip c, IScriptEnvironment* env) : GenericVideoFilter(c) {}
  585. PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
  586. {
  587. PVideoFrame frame = child->GetFrame(n, env);
  589. env->MakeWritable(&frame);
  591. SubPicDesc dst;
  592. dst.w = vi.width;
  593. dst.h = vi.height;
  594. dst.pitch = frame->GetPitch();
  595. dst.pitchUV = frame->GetPitch(PLANAR_U);
  596. dst.bits = (void**)frame->GetWritePtr();
  597. dst.bitsU = frame->GetWritePtr(PLANAR_U);
  598. dst.bitsV = frame->GetWritePtr(PLANAR_V);
  599. dst.bpp = dst.pitch/dst.w*8; //vi.BitsPerPixel();
  600. dst.type = 
  601. vi.IsRGB32() ? MSP_RGB32 : 
  602. vi.IsRGB24() ? MSP_RGB24 : 
  603. vi.IsYUY2() ? MSP_YUY2 : 
  604. /*vi.IsYV12()*/ vi.pixel_type == VideoInfo::CS_YV12 ? (s_fSwapUV?MSP_IYUV:MSP_YV12) : 
  605. /*vi.IsIYUV()*/ vi.pixel_type == VideoInfo::CS_IYUV ? (s_fSwapUV?MSP_YV12:MSP_IYUV) : 
  606. -1;
  608. float fps = m_fps > 0 ? m_fps : (float)vi.fps_numerator / vi.fps_denominator;
  610. Render(dst, (REFERENCE_TIME)(10000000i64 * n / fps), fps);
  612. return(frame);
  613. }
  614. };
  616. class CVobSubAvisynthFilter : public CVobSubFilter, public CAvisynthFilter
  617. {
  618. public:
  619. CVobSubAvisynthFilter(PClip c, const char* fn, IScriptEnvironment* env)
  620. : CVobSubFilter(CString(fn))
  621. , CAvisynthFilter(c, env)
  622. {
  623. if(!m_pSubPicProvider)
  624. env->ThrowError("VobSub: Can't open "%s"", fn);
  625. }
  626. };
  628. AVSValue __cdecl VobSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
  629. {
  630. return(new CVobSubAvisynthFilter(args[0].AsClip(), args[1].AsString(), env));
  631. }
  632.     
  633. class CTextSubAvisynthFilter : public CTextSubFilter, public CAvisynthFilter
  634. {
  635. public:
  636. CTextSubAvisynthFilter(PClip c, IScriptEnvironment* env, const char* fn, int CharSet = DEFAULT_CHARSET, float fps = -1)
  637. : CTextSubFilter(CString(fn), CharSet, fps)
  638. , CAvisynthFilter(c, env)
  639. {
  640. if(!m_pSubPicProvider)
  641. env->ThrowError("TextSub: Can't open "%s"", fn);
  642. }
  643. };
  645. AVSValue __cdecl TextSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
  646. {
  647. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString()));
  648. }
  650. AVSValue __cdecl TextSubCreateSI(AVSValue args, void* user_data, IScriptEnvironment* env)
  651. {
  652. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt()));
  653. }
  655. AVSValue __cdecl TextSubCreateSIF(AVSValue args, void* user_data, IScriptEnvironment* env)
  656. {
  657. return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt(), args[3].AsFloat()));
  658. }
  660. AVSValue __cdecl TextSubSwapUV(AVSValue args, void* user_data, IScriptEnvironment* env)
  661. {
  662. s_fSwapUV = args[0].AsBool(false);
  663. return(AVSValue());
  664. }
  666. extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit2(IScriptEnvironment* env)
  667. {
  668. env->AddFunction("VobSub", "cs", VobSubCreateS, 0);
  669. env->AddFunction("TextSub", "cs", TextSubCreateS, 0);
  670. env->AddFunction("TextSub", "csi", TextSubCreateSI, 0);
  671. env->AddFunction("TextSub", "csif", TextSubCreateSIF, 0);
  672. env->AddFunction("TextSubSwapUV", "b", TextSubSwapUV, 0);
  673. return(NULL);
  674. }
  675. }
  677. }
  679. UINT CALLBACK OpenHookProc(HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  680. {
  681. switch(uiMsg)
  682. {
  683. case WM_NOTIFY:
  684. {
  685. OPENFILENAME* ofn = ((OFNOTIFY *)lParam)->lpOFN;
  687. if(((NMHDR *)lParam)->code == CDN_FILEOK)
  688. {
  689. ofn->lCustData = (LPARAM)CharSetList[SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_GETCURSEL, 0, 0)];
  690. }
  692. break;
  693. }
  695. case WM_INITDIALOG:
  696. {
  697. SetWindowLong(hDlg, GWL_USERDATA, lParam);
  699. for(int i = 0; i < CharSetLen; i++)
  700. {
  701. CString s;
  702. s.Format(_T("%s (%d)"), CharSetNames[i], CharSetList[i]);
  703. SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING, 0, (LONG)(LPCTSTR)s);
  704. if(CharSetList[i] == (int)((OPENFILENAME*)lParam)->lCustData)
  705. SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_SETCURSEL, i, 0);
  706. }
  708. break;
  709. }
  711. default:
  712. break;
  713. }
  715. return FALSE;
  716. }