src/filters/transform/vsfilter/plugins.cpp

   1 /*
   2  *      Copyright (C) 2003-2006 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  */
  21
  22 #include "stdafx.h"
  23 #include <afxdlgs.h>
  24 #include <atlpath.h>
  25 #include "resource.h"
  26 #include "../../../Subtitles/VobSubFile.h"
  27 #include "../../../Subtitles/RTS.h"
  28 #include "../../../Subtitles/SSF.h"
  29 #include "../../../SubPic/PooledSubPic.h"
  30 #include "../../../SubPic/SubPicQueueImpl.h"
  31 #include "../../../subpic/color_conv_table.h"
  32 #include "../../../subpic/SimpleSubPicWrapper.h"
  33 #include "DirectVobSub.h"
  34 #include "vfr.h"
  35
  36 //
  37 // Generic interface
  38 //
  39
  40 namespace Plugin
  41 {
  42
  43 class CFilter : public CUnknown, public CDirectVobSub, public CAMThread, public CCritSec
  44 {
  45 private:
  46         CString m_fn;
  47
  48 protected:
  49         float m_fps;
  50         CCritSec m_csSubLock;
  51         CComPtr<ISimpleSubPicProvider> m_simple_provider;
  52         CComPtr<ISubPicProvider> m_pSubPicProvider;
  53         DWORD_PTR m_SubPicProviderId;
  54
  55     CSimpleTextSubtitle::YCbCrMatrix m_script_selected_yuv;
  56     CSimpleTextSubtitle::YCbCrRange m_script_selected_range;
  57
  58     bool m_fLazyInit;
  59 public:
  60     CFilter() : CUnknown(NAME("CFilter"), NULL), m_fps(-1), m_SubPicProviderId(0), m_fLazyInit(false)
  61     {
  62         //fix me: should not do init here
  63         CacheManager::GetPathDataMruCache()->SetMaxItemNum(m_path_data_cache_max_item_num);
  64         CacheManager::GetScanLineData2MruCache()->SetMaxItemNum(m_scan_line_data_cache_max_item_num);
  65         CacheManager::GetOverlayNoBlurMruCache()->SetMaxItemNum(m_overlay_no_blur_cache_max_item_num);
  66         CacheManager::GetOverlayMruCache()->SetMaxItemNum(m_overlay_cache_max_item_num);
  67         SubpixelPositionControler::GetGlobalControler().SetSubpixelLevel( static_cast<SubpixelPositionControler::SUBPIXEL_LEVEL>(m_subpixel_pos_level) );
  68
  69         m_script_selected_yuv = CSimpleTextSubtitle::YCbCrMatrix_AUTO;
  70         m_script_selected_range = CSimpleTextSubtitle::YCbCrRange_AUTO;
  71
  72         CAMThread::Create();
  73     }
  74         virtual ~CFilter() {CAMThread::CallWorker(0);}
  75
  76     DECLARE_IUNKNOWN;
  77     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv)
  78     {
  79         CheckPointer(ppv, E_POINTER);
  80
  81         return QI(IDirectVobSub)
  82             QI(IDirectVobSub2)
  83             QI(IDirectVobSubXy)
  84             QI(IFilterVersion)
  85             __super::NonDelegatingQueryInterface(riid, ppv);
  86     }
  87
  88         CString GetFileName() {CAutoLock cAutoLock(this); return m_fn;}
  89         void SetFileName(CString fn) {CAutoLock cAutoLock(this); m_fn = fn;}
  90
  91     void SetYuvMatrix(SubPicDesc& dst)
  92     {
  93         ColorConvTable::YuvMatrixType yuv_matrix = ColorConvTable::BT601;
  94         ColorConvTable::YuvRangeType yuv_range = ColorConvTable::RANGE_TV;
  95
  96         if ( m_colorSpace==CDirectVobSub::YuvMatrix_AUTO )
  97         {
  98             switch(m_script_selected_yuv)
  99             {
 100             case CSimpleTextSubtitle::YCbCrMatrix_BT601:
 101                 yuv_matrix = ColorConvTable::BT601;
 102                 break;
 103             case CSimpleTextSubtitle::YCbCrMatrix_BT709:
 104                 yuv_matrix = ColorConvTable::BT709;
 105                 break;
 106             case CSimpleTextSubtitle::YCbCrMatrix_AUTO:
 107             default:
 108                 yuv_matrix = ColorConvTable::BT601;
 109                 break;
 110             }
 111         }
 112         else
 113         {
 114             switch(m_colorSpace)
 115             {
 116             case CDirectVobSub::BT_601:
 117                 yuv_matrix = ColorConvTable::BT601;
 118                 break;
 119             case CDirectVobSub::BT_709:
 120                 yuv_matrix = ColorConvTable::BT709;
 121                 break;
 122             case CDirectVobSub::GUESS:
 123                 yuv_matrix = (dst.w > m_bt601Width || dst.h > m_bt601Height) ? ColorConvTable::BT709 : ColorConvTable::BT601;
 124                 break;
 125             }
 126         }
 127
 128         if( m_yuvRange==CDirectVobSub::YuvRange_Auto )
 129         {
 130             switch(m_script_selected_range)
 131             {
 132             case CSimpleTextSubtitle::YCbCrRange_PC:
 133                 yuv_range = ColorConvTable::RANGE_PC;
 134                 break;
 135             case CSimpleTextSubtitle::YCbCrRange_TV:
 136                 yuv_range = ColorConvTable::RANGE_TV;
 137                 break;
 138             case CSimpleTextSubtitle::YCbCrRange_AUTO:
 139             default:
 140                 yuv_range = ColorConvTable::RANGE_TV;
 141                 break;
 142             }
 143         }
 144         else
 145         {
 146             switch(m_yuvRange)
 147             {
 148             case CDirectVobSub::YuvRange_TV:
 149                 yuv_range = ColorConvTable::RANGE_TV;
 150                 break;
 151             case CDirectVobSub::YuvRange_PC:
 152                 yuv_range = ColorConvTable::RANGE_PC;
 153                 break;
 154             case CDirectVobSub::YuvRange_Auto:
 155                 yuv_range = ColorConvTable::RANGE_TV;
 156                 break;
 157             }
 158         }
 159
 160         ColorConvTable::SetDefaultConvType(yuv_matrix, yuv_range);
 161     }
 162
 163         bool Render(SubPicDesc& dst, REFERENCE_TIME rt, float fps)
 164         {
 165                 if(!m_pSubPicProvider)
 166                         return(false);
 167
 168         if(!m_fLazyInit)
 169         {
 170             m_fLazyInit = true;
 171
 172             SetYuvMatrix(dst);
 173         }
 174                 CSize size(dst.w, dst.h);
 175
 176                 if(!m_simple_provider)
 177                 {
 178             CComPtr<ISubPicExAllocator> pAllocator = new CPooledSubPicAllocator(dst.type, size, 2);
 179
 180                         HRESULT hr;
 181                         if(!(m_simple_provider = new CSubPicQueueNoThread(pAllocator, &hr)) || FAILED(hr))
 182                         {
 183                                 m_simple_provider = NULL;
 184                                 return(false);
 185                         }
 186                 }
 187
 188                 if(m_SubPicProviderId != (DWORD_PTR)(ISubPicProvider*)m_pSubPicProvider)
 189                 {
 190                         m_simple_provider->SetSubPicProvider(m_pSubPicProvider);
 191                         m_SubPicProviderId = (DWORD_PTR)(ISubPicProvider*)m_pSubPicProvider;
 192                 }
 193
 194                 CComPtr<ISimpleSubPic> pSubPic;
 195                 if(!m_simple_provider->LookupSubPic(rt, &pSubPic))
 196                         return(false);
 197
 198         if(dst.type == MSP_RGB32 || dst.type == MSP_RGB24 || dst.type == MSP_RGB16 || dst.type == MSP_RGB15)
 199             dst.h = -dst.h;
 200         pSubPic->AlphaBlt(&dst);
 201
 202                 return(true);
 203         }
 204
 205         DWORD ThreadProc()
 206         {
 207                 SetThreadPriority(m_hThread, THREAD_PRIORITY_LOWEST);
 208
 209                 CAtlArray<HANDLE> handles;
 210                 handles.Add(GetRequestHandle());
 211
 212                 CString fn = GetFileName();
 213                 CFileStatus fs;
 214                 fs.m_mtime = 0;
 215                 CFileGetStatus(fn, fs);
 216
 217                 while(1)
 218                 {
 219                         DWORD i = WaitForMultipleObjects(handles.GetCount(), handles.GetData(), FALSE, 1000);
 220
 221                         if(WAIT_OBJECT_0 == i)
 222                         {
 223                                 Reply(S_OK);
 224                                 break;
 225                         }
 226                         else if(WAIT_OBJECT_0 + 1 >= i && i <= WAIT_OBJECT_0 + handles.GetCount())
 227                         {
 228                                 if(FindNextChangeNotification(handles[i - WAIT_OBJECT_0]))
 229                                 {
 230                                         CFileStatus fs2;
 231                                         fs2.m_mtime = 0;
 232                                         CFileGetStatus(fn, fs2);
 233
 234                                         if(fs.m_mtime < fs2.m_mtime)
 235                                         {
 236                                                 fs.m_mtime = fs2.m_mtime;
 237
 238                                                 if(CComQIPtr<ISubStream> pSubStream = m_pSubPicProvider)
 239                                                 {
 240                                                         CAutoLock cAutoLock(&m_csSubLock);
 241                                                         pSubStream->Reload();
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246                         else if(WAIT_TIMEOUT == i)
 247                         {
 248                                 CString fn2 = GetFileName();
 249
 250                                 if(fn != fn2)
 251                                 {
 252                                         CPath p(fn2);
 253                                         p.RemoveFileSpec();
 254                                         HANDLE h = FindFirstChangeNotification(p, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE);
 255                                         if(h != INVALID_HANDLE_VALUE)
 256                                         {
 257                                                 fn = fn2;
 258                                                 handles.SetCount(1);
 259                                                 handles.Add(h);
 260                                         }
 261                                 }
 262                         }
 263                         else // if(WAIT_ABANDONED_0 == i || WAIT_FAILED == i)
 264                         {
 265                                 break;
 266                         }
 267                 }
 268
 269                 m_hThread = 0;
 270
 271                 for(int i = 1; i < handles.GetCount(); i++)
 272                         FindCloseChangeNotification(handles[i]);
 273
 274                 return 0;
 275         }
 276 };
 277
 278 class CVobSubFilter : virtual public CFilter
 279 {
 280 public:
 281         CVobSubFilter(CString fn = _T(""))
 282         {
 283                 if(!fn.IsEmpty()) Open(fn);
 284         }
 285
 286         bool Open(CString fn)
 287         {
 288                 SetFileName(_T(""));
 289                 m_pSubPicProvider = NULL;
 290
 291                 if(CVobSubFile* vsf = new CVobSubFile(&m_csSubLock))
 292                 {
 293                         m_pSubPicProvider = (ISubPicProvider*)vsf;
 294                         if(vsf->Open(CString(fn))) SetFileName(fn);
 295                         else m_pSubPicProvider = NULL;
 296                 }
 297
 298                 return !!m_pSubPicProvider;
 299         }
 300 };
 301
 302 class CTextSubFilter : virtual public CFilter
 303 {
 304         int m_CharSet;
 305
 306 public:
 307         CTextSubFilter(CString fn = _T(""), int CharSet = DEFAULT_CHARSET, float fps = -1)
 308                 : m_CharSet(CharSet)
 309         {
 310                 m_fps = fps;
 311                 if(!fn.IsEmpty()) Open(fn, CharSet);
 312         }
 313
 314         int GetCharSet() {return(m_CharSet);}
 315
 316         bool Open(CString fn, int CharSet = DEFAULT_CHARSET)
 317         {
 318                 SetFileName(_T(""));
 319                 m_pSubPicProvider = NULL;
 320
 321                 if(!m_pSubPicProvider)
 322                 {
 323                         if(ssf::CRenderer* ssf = new ssf::CRenderer(&m_csSubLock))
 324                         {
 325                                 m_pSubPicProvider = (ISubPicProvider*)ssf;
 326                                 if(ssf->Open(CString(fn))) SetFileName(fn);
 327                                 else m_pSubPicProvider = NULL;
 328                         }
 329                 }
 330
 331                 if(!m_pSubPicProvider)
 332                 {
 333                         if(CRenderedTextSubtitle* rts = new CRenderedTextSubtitle(&m_csSubLock))
 334                         {
 335                                 m_pSubPicProvider = (ISubPicProvider*)rts;
 336                                 if(rts->Open(CString(fn), CharSet)) SetFileName(fn);
 337                                 else m_pSubPicProvider = NULL;
 338
 339                 m_script_selected_yuv = rts->m_eYCbCrMatrix;
 340                 m_script_selected_range = rts->m_eYCbCrRange;
 341                         }
 342                 }
 343
 344                 return !!m_pSubPicProvider;
 345         }
 346 };
 347
 348 //
 349 // VirtualDub interface
 350 //
 351
 352 namespace VirtualDub
 353 {
 354         #include "..\..\..\..\include\VirtualDub\VirtualDub.h"
 355
 356         class CVirtualDubFilter : virtual public CFilter
 357         {
 358         public:
 359                 CVirtualDubFilter() {}
 360                 virtual ~CVirtualDubFilter() {}
 361
 362                 virtual int RunProc(const FilterActivation* fa, const FilterFunctions* ff)
 363                 {
 364                         SubPicDesc dst;
 365                         dst.type = MSP_RGB32;
 366                         dst.w = fa->src.w;
 367                         dst.h = fa->src.h;
 368                         dst.bpp = 32;
 369                         dst.pitch = fa->src.pitch;
 370                         dst.bits = (LPVOID)fa->src.data;
 371
 372                         Render(dst, 10000i64*fa->pfsi->lSourceFrameMS, (float)1000 / fa->pfsi->lMicrosecsPerFrame);
 373
 374                         return 0;
 375                 }
 376
 377                 virtual long ParamProc(FilterActivation* fa, const FilterFunctions* ff)
 378                 {
 379                         fa->dst.offset  = fa->src.offset;
 380                         fa->dst.modulo  = fa->src.modulo;
 381                         fa->dst.pitch   = fa->src.pitch;
 382
 383                         return 0;
 384                 }
 385
 386                 virtual int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd) = 0;
 387                 virtual void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str) = 0;
 388                 virtual bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen) = 0;
 389         };
 390
 391         class CVobSubVirtualDubFilter : public CVobSubFilter, public CVirtualDubFilter
 392         {
 393         public:
 394                 CVobSubVirtualDubFilter(CString fn = _T(""))
 395                         : CVobSubFilter(fn) {}
 396
 397                 int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
 398                 {
 399                         AFX_MANAGE_STATE(AfxGetStaticModuleState());
 400
 401                         CFileDialog fd(TRUE, NULL, GetFileName(), OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY,
 402                                 _T("VobSub files (*.idx;*.sub)|*.idx;*.sub||"), CWnd::FromHandle(hwnd), 0);
 403
 404                         if(fd.DoModal() != IDOK) return 1;
 405
 406                         return Open(fd.GetPathName()) ? 0 : 1;
 407                 }
 408
 409                 void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
 410                 {
 411                         sprintf(str, " (%s)", !GetFileName().IsEmpty() ? CStringA(GetFileName()) : " (empty)");
 412                 }
 413
 414                 bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
 415                 {
 416                         CStringA fn(GetFileName());
 417                         fn.Replace("\\", "\\\\");
 418                         _snprintf(buf, buflen, "Config(\"%s\")", fn);
 419                         return(true);
 420                 }
 421         };
 422
 423         class CTextSubVirtualDubFilter : public CTextSubFilter, public CVirtualDubFilter
 424         {
 425         public:
 426                 CTextSubVirtualDubFilter(CString fn = _T(""), int CharSet = DEFAULT_CHARSET)
 427                         : CTextSubFilter(fn, CharSet) {}
 428
 429                 int ConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
 430                 {
 431                         AFX_MANAGE_STATE(AfxGetStaticModuleState());
 432
 433                         const TCHAR formats[] = _T("TextSub files (*.sub;*.srt;*.smi;*.ssa;*.ass;*.xss;*.psb;*.txt)|*.sub;*.srt;*.smi;*.ssa;*.ass;*.xss;*.psb;*.txt||");
 434                         CFileDialog fd(TRUE, NULL, GetFileName(), OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_ENABLETEMPLATE|OFN_ENABLEHOOK,
 435                                 formats, CWnd::FromHandle(hwnd), OPENFILENAME_SIZE_VERSION_400 /*0*/);
 436
 437                         UINT CALLBACK OpenHookProc(HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam);
 438
 439                         fd.m_pOFN->hInstance = AfxGetResourceHandle();
 440                         fd.m_pOFN->lpTemplateName = MAKEINTRESOURCE(IDD_TEXTSUBOPENTEMPLATE);
 441                         fd.m_pOFN->lpfnHook = OpenHookProc;
 442                         fd.m_pOFN->lCustData = (LPARAM)DEFAULT_CHARSET;
 443
 444                         if(fd.DoModal() != IDOK) return 1;
 445
 446                         return Open(fd.GetPathName(), fd.m_pOFN->lCustData) ? 0 : 1;
 447                 }
 448
 449                 void StringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
 450                 {
 451                         if(!GetFileName().IsEmpty()) sprintf(str, " (%s, %d)", CStringA(GetFileName()), GetCharSet());
 452                         else sprintf(str, " (empty)");
 453                 }
 454
 455                 bool FssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
 456                 {
 457                         CStringA fn(GetFileName());
 458                         fn.Replace("\\", "\\\\");
 459                         _snprintf(buf, buflen, "Config(\"%s\", %d)", fn, GetCharSet());
 460                         return(true);
 461                 }
 462         };
 463
 464         int vobsubInitProc(FilterActivation* fa, const FilterFunctions* ff)
 465         {
 466                 return !(*(CVirtualDubFilter**)fa->filter_data = new CVobSubVirtualDubFilter());
 467         }
 468
 469         int textsubInitProc(FilterActivation* fa, const FilterFunctions* ff)
 470         {
 471                 return !(*(CVirtualDubFilter**)fa->filter_data = new CTextSubVirtualDubFilter());
 472         }
 473
 474         void baseDeinitProc(FilterActivation* fa, const FilterFunctions* ff)
 475         {
 476                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 477                 if(f) delete f, f = NULL;
 478         }
 479
 480         int baseRunProc(const FilterActivation* fa, const FilterFunctions* ff)
 481         {
 482                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 483                 return f ? f->RunProc(fa, ff) : 1;
 484         }
 485
 486         long baseParamProc(FilterActivation* fa, const FilterFunctions* ff)
 487         {
 488                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 489                 return f ? f->ParamProc(fa, ff) : 1;
 490         }
 491
 492         int baseConfigProc(FilterActivation* fa, const FilterFunctions* ff, HWND hwnd)
 493         {
 494                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 495                 return f ? f->ConfigProc(fa, ff, hwnd) : 1;
 496         }
 497
 498         void baseStringProc(const FilterActivation* fa, const FilterFunctions* ff, char* str)
 499         {
 500                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 501                 if(f) f->StringProc(fa, ff, str);
 502         }
 503
 504         bool baseFssProc(FilterActivation* fa, const FilterFunctions* ff, char* buf, int buflen)
 505         {
 506                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 507                 return f ? f->FssProc(fa, ff, buf, buflen) : false;
 508         }
 509
 510         void vobsubScriptConfig(IScriptInterpreter* isi, void* lpVoid, CScriptValue* argv, int argc)
 511         {
 512                 FilterActivation* fa = (FilterActivation*)lpVoid;
 513                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 514                 if(f) delete f;
 515                 f = new CVobSubVirtualDubFilter(CString(*argv[0].asString()));
 516                 *(CVirtualDubFilter**)fa->filter_data = f;
 517         }
 518
 519         void textsubScriptConfig(IScriptInterpreter* isi, void* lpVoid, CScriptValue* argv, int argc)
 520         {
 521                 FilterActivation* fa = (FilterActivation*)lpVoid;
 522                 CVirtualDubFilter* f = *(CVirtualDubFilter**)fa->filter_data;
 523                 if(f) delete f;
 524                 f = new CTextSubVirtualDubFilter(CString(*argv[0].asString()), argv[1].asInt());
 525                 *(CVirtualDubFilter**)fa->filter_data = f;
 526         }
 527
 528         ScriptFunctionDef vobsub_func_defs[]={
 529                 { (ScriptFunctionPtr)vobsubScriptConfig, "Config", "0s" },
 530                 { NULL },
 531         };
 532
 533         CScriptObject vobsub_obj={
 534                 NULL, vobsub_func_defs
 535         };
 536
 537         struct FilterDefinition filterDef_vobsub =
 538         {
 539                 NULL, NULL, NULL,       // next, prev, module
 540                 "VobSub",                               // name
 541                 "Adds subtitles from a vob sequence.", // desc
 542                 "Gabest",               // maker
 543                 NULL,                   // private_data
 544                 sizeof(CVirtualDubFilter**), // inst_data_size
 545                 vobsubInitProc,         // initProc
 546                 baseDeinitProc,                 // deinitProc
 547                 baseRunProc,                    // runProc
 548                 baseParamProc,                  // paramProc
 549                 baseConfigProc,                 // configProc
 550                 baseStringProc,                 // stringProc
 551                 NULL,                                   // startProc
 552                 NULL,                                   // endProc
 553                 &vobsub_obj,                    // script_obj
 554                 baseFssProc,                    // fssProc
 555         };
 556
 557         ScriptFunctionDef textsub_func_defs[]={
 558                 { (ScriptFunctionPtr)textsubScriptConfig, "Config", "0si" },
 559                 { NULL },
 560         };
 561
 562         CScriptObject textsub_obj={
 563                 NULL, textsub_func_defs
 564         };
 565
 566         struct FilterDefinition filterDef_textsub =
 567         {
 568                 NULL, NULL, NULL,       // next, prev, module
 569                 "TextSub",                              // name
 570                 "Adds subtitles from srt, sub, psb, smi, ssa, ass file formats.", // desc
 571                 "Gabest",               // maker
 572                 NULL,                   // private_data
 573                 sizeof(CVirtualDubFilter**), // inst_data_size
 574                 textsubInitProc,        // initProc
 575                 baseDeinitProc,                 // deinitProc
 576                 baseRunProc,                    // runProc
 577                 baseParamProc,                  // paramProc
 578                 baseConfigProc,                 // configProc
 579                 baseStringProc,                 // stringProc
 580                 NULL,                                   // startProc
 581                 NULL,                                   // endProc
 582                 &textsub_obj,                   // script_obj
 583                 baseFssProc,                    // fssProc
 584         };
 585
 586         static FilterDefinition* fd_vobsub;
 587         static FilterDefinition* fd_textsub;
 588
 589         extern "C" __declspec(dllexport) int __cdecl VirtualdubFilterModuleInit2(FilterModule *fm, const FilterFunctions *ff, int& vdfd_ver, int& vdfd_compat)
 590         {
 591                 if(!(fd_vobsub = ff->addFilter(fm, &filterDef_vobsub, sizeof(FilterDefinition)))
 592                 || !(fd_textsub = ff->addFilter(fm, &filterDef_textsub, sizeof(FilterDefinition))))
 593                         return 1;
 594
 595                 vdfd_ver = VIRTUALDUB_FILTERDEF_VERSION;
 596                 vdfd_compat = VIRTUALDUB_FILTERDEF_COMPATIBLE;
 597
 598                 return 0;
 599         }
 600
 601         extern "C" __declspec(dllexport) void __cdecl VirtualdubFilterModuleDeinit(FilterModule *fm, const FilterFunctions *ff)
 602         {
 603                 ff->removeFilter(fd_textsub);
 604                 ff->removeFilter(fd_vobsub);
 605         }
 606 }
 607
 608 //
 609 // Avisynth interface
 610 //
 611
 612 namespace AviSynth1
 613 {
 614         #include "..\..\..\..\include\avisynth\avisynth1.h"
 615
 616         class CAvisynthFilter : public GenericVideoFilter, virtual public CFilter
 617         {
 618         public:
 619                 CAvisynthFilter(PClip c, IScriptEnvironment* env) : GenericVideoFilter(c) {}
 620
 621                 PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
 622                 {
 623                         PVideoFrame frame = child->GetFrame(n, env);
 624
 625                         env->MakeWritable(&frame);
 626
 627                         SubPicDesc dst;
 628                         dst.w = vi.width;
 629                         dst.h = vi.height;
 630                         dst.pitch = frame->GetPitch();
 631                         dst.bits = (void**)frame->GetWritePtr();
 632                         dst.bpp = vi.BitsPerPixel();
 633                         dst.type =
 634                                 vi.IsRGB32() ? ( env->GetVar("RGBA").AsBool() ? MSP_RGBA :MSP_RGB32) :
 635                                 vi.IsRGB24() ? MSP_RGB24 :
 636                                 vi.IsYUY2() ? MSP_YUY2 :
 637                                 -1;
 638
 639                         float fps = m_fps > 0 ? m_fps : (float)vi.fps_numerator / vi.fps_denominator;
 640
 641                         Render(dst, (REFERENCE_TIME)(10000000i64 * n / fps), fps);
 642
 643                         return(frame);
 644                 }
 645         };
 646
 647         class CVobSubAvisynthFilter : public CVobSubFilter, public CAvisynthFilter
 648         {
 649         public:
 650                 CVobSubAvisynthFilter(PClip c, const char* fn, IScriptEnvironment* env)
 651                         : CVobSubFilter(CString(fn))
 652                         , CAvisynthFilter(c, env)
 653                 {
 654                         if(!m_pSubPicProvider)
 655                                 env->ThrowError("VobSub: Can't open \"%s\"", fn);
 656                 }
 657         };
 658
 659         AVSValue __cdecl VobSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
 660         {
 661                 return(new CVobSubAvisynthFilter(args[0].AsClip(), args[1].AsString(), env));
 662         }
 663
 664         class CTextSubAvisynthFilter : public CTextSubFilter, public CAvisynthFilter
 665         {
 666         public:
 667                 CTextSubAvisynthFilter(PClip c, IScriptEnvironment* env, const char* fn, int CharSet = DEFAULT_CHARSET, float fps = -1)
 668                         : CTextSubFilter(CString(fn), CharSet, fps)
 669                         , CAvisynthFilter(c, env)
 670                 {
 671                         if(!m_pSubPicProvider)
 672                                 env->ThrowError("TextSub: Can't open \"%s\"", fn);
 673                 }
 674         };
 675
 676         AVSValue __cdecl TextSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
 677         {
 678                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString()));
 679         }
 680
 681         AVSValue __cdecl TextSubCreateSI(AVSValue args, void* user_data, IScriptEnvironment* env)
 682         {
 683                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt()));
 684         }
 685
 686         AVSValue __cdecl TextSubCreateSIF(AVSValue args, void* user_data, IScriptEnvironment* env)
 687         {
 688                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt(), args[3].AsFloat()));
 689         }
 690
 691         AVSValue __cdecl MaskSubCreateSIIFI(AVSValue args, void* user_data, IScriptEnvironment* env)
 692         {
 693                 AVSValue rgb32("RGB32");
 694                 AVSValue  tab[5] = {
 695                         args[1],
 696                         args[2],
 697                         args[3],
 698                         args[4],
 699                         rgb32
 700                 };
 701                 AVSValue value(tab,5);
 702                 const char * nom[5]={
 703                         "width",
 704                         "height",
 705                         "fps",
 706                         "length",
 707                         "pixel_type"
 708                 };
 709                 AVSValue clip(env->Invoke("Blackness",value,nom));
 710                 env->SetVar(env->SaveString("RGBA"),true);
 711                 return(new CTextSubAvisynthFilter(clip.AsClip(), env, args[0].AsString()));
 712         }
 713
 714         extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit(IScriptEnvironment* env)
 715         {
 716                 env->AddFunction("VobSub", "cs", VobSubCreateS, 0);
 717                 env->AddFunction("TextSub", "cs", TextSubCreateS, 0);
 718                 env->AddFunction("TextSub", "csi", TextSubCreateSI, 0);
 719                 env->AddFunction("TextSub", "csif", TextSubCreateSIF, 0);
 720                 env->AddFunction("MaskSub", "siifi", MaskSubCreateSIIFI, 0);
 721                 env->SetVar(env->SaveString("RGBA"),false);
 722                 return(NULL);
 723         }
 724 }
 725
 726 namespace AviSynth25
 727 {
 728         #include "..\..\..\..\include\avisynth\avisynth25.h"
 729
 730         static bool s_fSwapUV = false;
 731
 732         class CAvisynthFilter : public GenericVideoFilter, virtual public CFilter
 733         {
 734                 VFRTranslator *vfr;
 735
 736         public:
 737                 CAvisynthFilter(PClip c, IScriptEnvironment* env, VFRTranslator *_vfr=0) : GenericVideoFilter(c), vfr(_vfr) {}
 738
 739                 PVideoFrame __stdcall GetFrame(int n, IScriptEnvironment* env)
 740                 {
 741                         PVideoFrame frame = child->GetFrame(n, env);
 742
 743                         env->MakeWritable(&frame);
 744
 745                         SubPicDesc dst;
 746                         dst.w = vi.width;
 747                         dst.h = vi.height;
 748                         dst.pitch = frame->GetPitch();
 749                         dst.pitchUV = frame->GetPitch(PLANAR_U);
 750                         dst.bits = (void**)frame->GetWritePtr();
 751                         dst.bitsU = frame->GetWritePtr(PLANAR_U);
 752                         dst.bitsV = frame->GetWritePtr(PLANAR_V);
 753                         dst.bpp = dst.pitch/dst.w*8; //vi.BitsPerPixel();
 754                         dst.type =
 755                                 vi.IsRGB32() ?( env->GetVar("RGBA").AsBool() ? MSP_RGBA : MSP_RGB32)  :
 756                                 vi.IsRGB24() ? MSP_RGB24 :
 757                                 vi.IsYUY2() ? MSP_YUY2 :
 758                                 /*vi.IsYV12()*/ vi.pixel_type == VideoInfo::CS_YV12 ? (s_fSwapUV?MSP_IYUV:MSP_YV12) :
 759                                 /*vi.IsIYUV()*/ vi.pixel_type == VideoInfo::CS_IYUV ? (s_fSwapUV?MSP_YV12:MSP_IYUV) :
 760                                 -1;
 761
 762                         REFERENCE_TIME timestamp;
 763                         float fps = m_fps > 0 ? m_fps : (float)vi.fps_numerator / vi.fps_denominator;
 764                         if (!vfr)
 765                                 timestamp = (REFERENCE_TIME)(10000000i64 * n / fps);
 766                         else
 767                                 timestamp = (REFERENCE_TIME)(10000000 * vfr->TimeStampFromFrameNumber(n));
 768
 769                         Render(dst, timestamp, fps);
 770
 771                         return(frame);
 772                 }
 773         };
 774
 775         class CVobSubAvisynthFilter : public CVobSubFilter, public CAvisynthFilter
 776         {
 777         public:
 778                 CVobSubAvisynthFilter(PClip c, const char* fn, IScriptEnvironment* env)
 779                         : CVobSubFilter(CString(fn))
 780                         , CAvisynthFilter(c, env)
 781                 {
 782                         if(!m_pSubPicProvider)
 783                                 env->ThrowError("VobSub: Can't open \"%s\"", fn);
 784                 }
 785         };
 786
 787         AVSValue __cdecl VobSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
 788         {
 789                 return(new CVobSubAvisynthFilter(args[0].AsClip(), args[1].AsString(), env));
 790         }
 791
 792         class CTextSubAvisynthFilter : public CTextSubFilter, public CAvisynthFilter
 793         {
 794         public:
 795                 CTextSubAvisynthFilter(PClip c, IScriptEnvironment* env, const char* fn, int CharSet = DEFAULT_CHARSET, float fps = -1, VFRTranslator *vfr = 0)
 796                         : CTextSubFilter(CString(fn), CharSet, fps)
 797                         , CAvisynthFilter(c, env, vfr)
 798                 {
 799                         if(!m_pSubPicProvider)
 800                                 env->ThrowError("TextSub: Can't open \"%s\"", fn);
 801                 }
 802         };
 803
 804         /*AVSValue __cdecl TextSubCreateS(AVSValue args, void* user_data, IScriptEnvironment* env)
 805         {
 806                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString()));
 807         }
 808
 809         AVSValue __cdecl TextSubCreateSI(AVSValue args, void* user_data, IScriptEnvironment* env)
 810         {
 811                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt()));
 812         }
 813
 814         AVSValue __cdecl TextSubCreateSIF(AVSValue args, void* user_data, IScriptEnvironment* env)
 815         {
 816                 return(new CTextSubAvisynthFilter(args[0].AsClip(), env, args[1].AsString(), args[2].AsInt(), args[3].AsFloat()));
 817         }*/
 818
 819         AVSValue __cdecl TextSubCreateGeneral(AVSValue args, void* user_data, IScriptEnvironment* env)
 820         {
 821                 if (!args[1].Defined())
 822                         env->ThrowError("TextSub: You must specify a subtitle file to use");
 823
 824                 VFRTranslator *vfr = 0;
 825                 if (args[4].Defined())
 826                         vfr = GetVFRTranslator(args[4].AsString());
 827
 828                 return(new CTextSubAvisynthFilter(
 829                         args[0].AsClip(),
 830                         env,
 831                         args[1].AsString(),
 832                         args[2].AsInt(DEFAULT_CHARSET),
 833                         args[3].AsFloat(-1),
 834                         vfr));
 835         }
 836
 837         AVSValue __cdecl TextSubSwapUV(AVSValue args, void* user_data, IScriptEnvironment* env)
 838         {
 839                 s_fSwapUV = args[0].AsBool(false);
 840                 return(AVSValue());
 841         }
 842
 843         AVSValue __cdecl MaskSubCreate(AVSValue args, void* user_data, IScriptEnvironment* env)
 844         {
 845                 if (!args[0].Defined())
 846                         env->ThrowError("MaskSub: You must specify a subtitle file to use");
 847
 848                 if (!args[3].Defined() && !args[6].Defined())
 849                         env->ThrowError("MaskSub: You must specify either FPS or a VFR timecodes file");
 850
 851                 VFRTranslator *vfr = 0;
 852                 if (args[6].Defined())
 853                         vfr = GetVFRTranslator(args[6].AsString());
 854
 855                 AVSValue rgb32("RGB32");
 856                 AVSValue fps(args[3].AsFloat(25));
 857                 AVSValue  tab[6] = {
 858                         args[1],
 859                         args[2],
 860                         fps,
 861                         args[4],
 862                         rgb32
 863                 };
 864                 AVSValue value(tab,5);
 865                 const char * nom[5]={
 866                         "width",
 867                         "height",
 868                         "fps",
 869                         "length",
 870                         "pixel_type"
 871                 };
 872
 873                 AVSValue clip(env->Invoke("Blackness",value,nom));
 874                 env->SetVar(env->SaveString("RGBA"),true);
 875
 876                 return(new CTextSubAvisynthFilter(
 877                         clip.AsClip(),
 878                         env,
 879                         args[0].AsString(),
 880                         args[5].AsInt(DEFAULT_CHARSET),
 881                         args[3].AsFloat(-1),
 882                         vfr));
 883         }
 884
 885         extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit2(IScriptEnvironment* env)
 886         {
 887                 env->AddFunction("VobSub", "cs", VobSubCreateS, 0);
 888                 //env->AddFunction("TextSub", "cs", TextSubCreateS, 0);
 889                 //env->AddFunction("TextSub", "csi", TextSubCreateSI, 0);
 890                 //env->AddFunction("TextSub", "csif", TextSubCreateSIF, 0);
 891                 env->AddFunction("TextSub", "c[file]s[charset]i[fps]f[vfr]s", TextSubCreateGeneral, 0);
 892                 env->AddFunction("TextSubSwapUV", "b", TextSubSwapUV, 0);
 893                 env->AddFunction("MaskSub", "[file]s[width]i[height]i[fps]f[length]i[charset]i[vfr]s", MaskSubCreate, 0);
 894                 env->SetVar(env->SaveString("RGBA"),false);
 895                 return(NULL);
 896         }
 897 }
 898
 899 }
 900
 901 UINT CALLBACK OpenHookProc(HWND hDlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
 902 {
 903         switch(uiMsg)
 904         {
 905                 case WM_NOTIFY:
 906                 {
 907                         OPENFILENAME* ofn = ((OFNOTIFY *)lParam)->lpOFN;
 908
 909                         if(((NMHDR *)lParam)->code == CDN_FILEOK)
 910                         {
 911                                 ofn->lCustData = (LPARAM)CharSetList[SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_GETCURSEL, 0, 0)];
 912                         }
 913
 914                         break;
 915                 }
 916
 917                 case WM_INITDIALOG:
 918                 {
 919                         SetWindowLong(hDlg, GWL_USERDATA, lParam);
 920
 921                         for(int i = 0; i < CharSetLen; i++)
 922                         {
 923                                 CString s;
 924                                 s.Format(_T("%s (%d)"), CharSetNames[i], CharSetList[i]);
 925                                 SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING, 0, (LONG)(LPCTSTR)s);
 926                                 if(CharSetList[i] == (int)((OPENFILENAME*)lParam)->lCustData)
 927                                         SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_SETCURSEL, i, 0);
 928                         }
 929
 930                         break;
 931                 }
 932
 933                 default:
 934                         break;
 935         }
 936
 937         return FALSE;
 938 }