src/filters/transform/vsfilter/DirectVobSubFilter.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 <math.h>
  24 #include <time.h>
  25 #include "DirectVobSubFilter.h"
  26 #include "TextInputPin.h"
  27 #include "DirectVobSubPropPage.h"
  28 #include "VSFilter.h"
  29 #include "systray.h"
  30 #include "../../../DSUtil/MediaTypes.h"
  31 #include "../../../SubPic/SubPicQueueImpl.h"
  32 #include "../../../SubPic/PooledSubPic.h"
  33 #include "../../../subpic/color_conv_table.h"
  34
  35 #include <initguid.h>
  36 #include "..\..\..\..\include\moreuuids.h"
  37
  38 #include "CAutoTiming.h"
  39 #include "xy_logger.h"
  40
  41 #define MAX_SUBPIC_QUEUE_LENGTH 1
  42
  43 ///////////////////////////////////////////////////////////////////////////
  44
  45 /*removeme*/
  46 bool g_RegOK = true;//false; // doesn't work with the dvd graph builder
  47 #include "valami.cpp"
  48
  49 #ifdef __DO_LOG
  50 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
  51 #endif
  52
  53 ////////////////////////////////////////////////////////////////////////////
  54 //
  55 // Constructor
  56 //
  57
  58 CDirectVobSubFilter::CDirectVobSubFilter(LPUNKNOWN punk, HRESULT* phr, const GUID& clsid)
  59         : CBaseVideoFilter(NAME("CDirectVobSubFilter"), punk, phr, clsid)
  60         , m_nSubtitleId(-1)
  61         , m_fMSMpeg4Fix(false)
  62         , m_fps(25)
  63 {
  64         DbgLog((LOG_TRACE, 3, _T("CDirectVobSubFilter::CDirectVobSubFilter")));
  65
  66     // and then, anywhere you need it:
  67
  68 #ifdef __DO_LOG
  69     LPTSTR  strDLLPath = new TCHAR[_MAX_PATH];
  70     ::GetModuleFileName( reinterpret_cast<HINSTANCE>(&__ImageBase), strDLLPath, _MAX_PATH);
  71     CString dllPath = strDLLPath;
  72     dllPath += ".properties";
  73     xy_logger::doConfigure( dllPath.GetString() );
  74 #endif
  75
  76         AFX_MANAGE_STATE(AfxGetStaticModuleState());
  77
  78         m_hdc = 0;
  79         m_hbm = 0;
  80         m_hfont = 0;
  81
  82         {
  83                 LOGFONT lf;
  84                 memset(&lf, 0, sizeof(lf));
  85                 lf.lfCharSet = DEFAULT_CHARSET;
  86                 lf.lfOutPrecision = OUT_CHARACTER_PRECIS;
  87                 lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  88                 lf.lfQuality = ANTIALIASED_QUALITY;
  89                 HDC hdc = GetDC(NULL);
  90                 lf.lfHeight = 28;
  91             //MulDiv(20, GetDeviceCaps(hdc, LOGPIXELSY), 54);
  92                 ReleaseDC(NULL, hdc);
  93                 lf.lfWeight = FW_BOLD;
  94                 _tcscpy(lf.lfFaceName, _T("Arial"));
  95                 m_hfont = CreateFontIndirect(&lf);
  96         }
  97
  98         theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Hint"), _T("The first three are fixed, but you can add more up to ten entries."));
  99         theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path0"), _T("."));
 100         theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path1"), _T("c:\\subtitles"));
 101         theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path2"), _T(".\\subtitles"));
 102
 103         m_fLoading = true;
 104
 105         m_hSystrayThread = 0;
 106         m_tbid.hSystrayWnd = NULL;
 107         m_tbid.graph = NULL;
 108         m_tbid.fRunOnce = false;
 109         m_tbid.fShowIcon = (theApp.m_AppName.Find(_T("zplayer"), 0) < 0 || !!theApp.GetProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_ENABLEZPICON), 0));
 110
 111         HRESULT hr = S_OK;
 112         m_pTextInput.Add(new CTextInputPin(this, m_pLock, &m_csSubLock, &hr));
 113         ASSERT(SUCCEEDED(hr));
 114
 115         CAMThread::Create();
 116         m_frd.EndThreadEvent.Create(0, FALSE, FALSE, 0);
 117         m_frd.RefreshEvent.Create(0, FALSE, FALSE, 0);
 118
 119         memset(&m_CurrentVIH2, 0, sizeof(VIDEOINFOHEADER2));
 120
 121     m_donot_follow_upstream_preferred_order = !m_fFollowUpstreamPreferredOrder;
 122
 123         m_time_alphablt = m_time_rasterization = 0;
 124 }
 125
 126 CDirectVobSubFilter::~CDirectVobSubFilter()
 127 {
 128         CAutoLock cAutoLock(&m_csQueueLock);
 129         if(m_pSubPicQueue)
 130         {
 131                 DbgLog((LOG_TRACE, 3, "~CDirectVobSubFilter::Invalidate"));
 132                 m_pSubPicQueue->Invalidate();
 133         }
 134         m_pSubPicQueue = NULL;
 135
 136         if(m_hfont) {DeleteObject(m_hfont); m_hfont = 0;}
 137         if(m_hbm) {DeleteObject(m_hbm); m_hbm = 0;}
 138         if(m_hdc) {DeleteObject(m_hdc); m_hdc = 0;}
 139
 140         for(int i = 0; i < m_pTextInput.GetCount(); i++)
 141                 delete m_pTextInput[i];
 142
 143         m_frd.EndThreadEvent.Set();
 144         CAMThread::Close();
 145
 146         DbgLog((LOG_TRACE, 3, _T("CDirectVobSubFilter::~CDirectVobSubFilter")));
 147
 148         //Trace(_T("CDirectVobSubFilter::~CDirectVobSubFilter"));
 149         //ReleaseTracer;
 150 }
 151
 152 STDMETHODIMP CDirectVobSubFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
 153 {
 154     CheckPointer(ppv, E_POINTER);
 155
 156     return
 157                 QI(IDirectVobSub)
 158                 QI(IDirectVobSub2)
 159                 QI(IFilterVersion)
 160                 QI(ISpecifyPropertyPages)
 161                 QI(IAMStreamSelect)
 162                 __super::NonDelegatingQueryInterface(riid, ppv);
 163 }
 164
 165 // CBaseVideoFilter
 166
 167 void CDirectVobSubFilter::GetOutputSize(int& w, int& h, int& arx, int& ary)
 168 {
 169         CSize s(w, h), os = s;
 170         AdjustFrameSize(s);
 171         w = s.cx;
 172         h = s.cy;
 173
 174         if(w != os.cx)
 175         {
 176                 while(arx < 100) arx *= 10, ary *= 10;
 177                 arx = arx * w / os.cx;
 178         }
 179
 180         if(h != os.cy)
 181         {
 182                 while(ary < 100) arx *= 10, ary *= 10;
 183                 ary = ary * h / os.cy;
 184         }
 185 }
 186
 187 HRESULT CDirectVobSubFilter::TryNotCopy(IMediaSample* pIn, const CMediaType& mt, const BITMAPINFOHEADER& bihIn )
 188 {
 189     CSize sub(m_w, m_h);
 190     CSize in(bihIn.biWidth, bihIn.biHeight);
 191     BYTE* pDataIn = NULL;
 192     if(FAILED(pIn->GetPointer(&pDataIn)) || !pDataIn)
 193         return S_FALSE;
 194     if( sub==in )
 195     {
 196         m_spd.bits = pDataIn;
 197     }
 198     else
 199     {
 200         m_spd.bits = static_cast<BYTE*>(m_pTempPicBuff);
 201         bool fYV12 = (mt.subtype == MEDIASUBTYPE_YV12 || mt.subtype == MEDIASUBTYPE_I420 || mt.subtype == MEDIASUBTYPE_IYUV);
 202         bool fNV12 = (mt.subtype == MEDIASUBTYPE_NV12 || mt.subtype == MEDIASUBTYPE_NV21);
 203         bool fP010 = (mt.subtype == MEDIASUBTYPE_P010 || mt.subtype == MEDIASUBTYPE_P016);
 204
 205         int bpp = fP010 ? 16 : (fYV12||fNV12) ? 8 : bihIn.biBitCount;
 206         DWORD black = fP010 ? 0x10001000 : (fYV12||fNV12) ? 0x10101010 : (bihIn.biCompression == '2YUY') ? 0x80108010 : 0;
 207
 208
 209         if(FAILED(Copy((BYTE*)m_pTempPicBuff, pDataIn, sub, in, bpp, mt.subtype, black)))
 210             return E_FAIL;
 211
 212         if(fYV12)
 213         {
 214             BYTE* pSubV = (BYTE*)m_pTempPicBuff + (sub.cx*bpp>>3)*sub.cy;
 215             BYTE* pInV = pDataIn + (in.cx*bpp>>3)*in.cy;
 216             sub.cx >>= 1; sub.cy >>= 1; in.cx >>= 1; in.cy >>= 1;
 217             BYTE* pSubU = pSubV + (sub.cx*bpp>>3)*sub.cy;
 218             BYTE* pInU = pInV + (in.cx*bpp>>3)*in.cy;
 219             if(FAILED(Copy(pSubV, pInV, sub, in, bpp, mt.subtype, 0x80808080)))
 220                 return E_FAIL;
 221             if(FAILED(Copy(pSubU, pInU, sub, in, bpp, mt.subtype, 0x80808080)))
 222                 return E_FAIL;
 223         }
 224         else if (fP010)
 225         {
 226             BYTE* pSubUV = (BYTE*)m_pTempPicBuff + (sub.cx*bpp>>3)*sub.cy;
 227             BYTE* pInUV = pDataIn + (in.cx*bpp>>3)*in.cy;
 228             sub.cy >>= 1; in.cy >>= 1;
 229             if(FAILED(Copy(pSubUV, pInUV, sub, in, bpp, mt.subtype, 0x80008000)))
 230                 return E_FAIL;
 231         }
 232         else if(fNV12) {
 233             BYTE* pSubUV = (BYTE*)m_pTempPicBuff + (sub.cx*bpp>>3)*sub.cy;
 234             BYTE* pInUV = pDataIn + (in.cx*bpp>>3)*in.cy;
 235             sub.cy >>= 1;
 236             in.cy >>= 1;
 237             if(FAILED(Copy(pSubUV, pInUV, sub, in, bpp, mt.subtype, 0x80808080)))
 238                 return E_FAIL;
 239         }
 240     }
 241     return S_OK;
 242 }
 243
 244 HRESULT CDirectVobSubFilter::Transform(IMediaSample* pIn)
 245 {
 246         XY_LOG_ONCE(0, _T("CDirectVobSubFilter::Transform"));
 247         HRESULT hr;
 248
 249
 250         REFERENCE_TIME rtStart, rtStop;
 251         if(SUCCEEDED(pIn->GetTime(&rtStart, &rtStop)))
 252         {
 253                 double dRate = m_pInput->CurrentRate();
 254
 255                 m_tPrev = m_pInput->CurrentStartTime() + dRate*rtStart;
 256
 257                 REFERENCE_TIME rtAvgTimePerFrame = rtStop - rtStart;
 258                 if(CComQIPtr<ISubClock2> pSC2 = m_pSubClock)
 259                 {
 260                         REFERENCE_TIME rt;
 261                          if(S_OK == pSC2->GetAvgTimePerFrame(&rt))
 262                                  rtAvgTimePerFrame = rt;
 263                 }
 264
 265                 m_fps = 10000000.0/rtAvgTimePerFrame / dRate;
 266         }
 267
 268         //
 269
 270         {
 271                 CAutoLock cAutoLock(&m_csQueueLock);
 272
 273                 if(m_pSubPicQueue)
 274                 {
 275                         m_pSubPicQueue->SetTime(CalcCurrentTime());
 276                         m_pSubPicQueue->SetFPS(m_fps);
 277                 }
 278         }
 279
 280         //
 281
 282
 283         const CMediaType& mt = m_pInput->CurrentMediaType();
 284
 285         BITMAPINFOHEADER bihIn;
 286         ExtractBIH(&mt, &bihIn);
 287
 288     hr = TryNotCopy(pIn, mt, bihIn);
 289     if( hr!=S_OK )
 290     {
 291         //fix me: log error
 292         return hr;
 293     }
 294         //
 295
 296         SubPicDesc spd = m_spd;
 297
 298         CComPtr<IMediaSample> pOut;
 299         BYTE* pDataOut = NULL;
 300         if(FAILED(hr = GetDeliveryBuffer(spd.w, spd.h, &pOut))
 301         || FAILED(hr = pOut->GetPointer(&pDataOut)))
 302                 return hr;
 303         pOut->SetTime(&rtStart, &rtStop);
 304         pOut->SetMediaTime(NULL, NULL);
 305         pOut->SetDiscontinuity(pIn->IsDiscontinuity() == S_OK);
 306         pOut->SetSyncPoint(pIn->IsSyncPoint() == S_OK);
 307         pOut->SetPreroll(pIn->IsPreroll() == S_OK);
 308         //
 309
 310         BITMAPINFOHEADER bihOut;
 311         ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
 312
 313         bool fInputFlipped = bihIn.biHeight >= 0 && bihIn.biCompression <= 3;
 314         bool fOutputFlipped = bihOut.biHeight >= 0 && bihOut.biCompression <= 3;
 315
 316         bool fFlip = fInputFlipped != fOutputFlipped;
 317         if(m_fFlipPicture) fFlip = !fFlip;
 318         if(m_fMSMpeg4Fix) fFlip = !fFlip;
 319
 320         bool fFlipSub = fOutputFlipped;
 321         if(m_fFlipSubtitles) fFlipSub = !fFlipSub;
 322
 323         //
 324
 325         {
 326                 CAutoLock cAutoLock(&m_csQueueLock);
 327
 328                 if(m_pSubPicQueue)
 329                 {
 330                         CComPtr<ISubPicEx> pSubPic;
 331
 332                         //int timeStamp1 = GetTickCount();
 333                         bool lookupResult = SUCCEEDED(m_pSubPicQueue->LookupSubPicEx(CalcCurrentTime(), &pSubPic));
 334                         //int timeStamp2 = GetTickCount();
 335                         //m_time_rasterization += timeStamp2-timeStamp1;
 336
 337                         if(lookupResult && pSubPic)
 338                         {
 339                                 //CRect r;
 340                                 //pSubPic->GetDirtyRect(r);
 341                                 CAtlList<const CRect> rectList;
 342                                 pSubPic->GetDirtyRects(rectList);
 343
 344                                 if(fFlip ^ fFlipSub)
 345                                         spd.h = -spd.h;
 346
 347                                 POSITION pos = rectList.GetHeadPosition();
 348                                 while(pos!=NULL)
 349                                 {
 350                                         const CRect& cRect = rectList.GetNext(pos);
 351                                         pSubPic->AlphaBlt(cRect, cRect, &spd);
 352                                         //pSubPic->AlphaBlt(r, r, &spd);
 353                                 }
 354
 355                                 //m_time_alphablt += GetTickCount() - timeStamp2;
 356
 357                                 DbgLog((LOG_TRACE,3,"AlphaBlt time:%lu", (ULONG)(CalcCurrentTime()/10000)));
 358                         }
 359                 }
 360         }
 361         CopyBuffer(pDataOut, (BYTE*)spd.bits, spd.w, abs(spd.h)*(fFlip?-1:1), spd.pitch, mt.subtype);
 362
 363         PrintMessages(pDataOut);
 364         return m_pOutput->Deliver(pOut);
 365 }
 366
 367 // CBaseFilter
 368
 369 CBasePin* CDirectVobSubFilter::GetPin(int n)
 370 {
 371         if(n < __super::GetPinCount())
 372                 return __super::GetPin(n);
 373
 374         n -= __super::GetPinCount();
 375
 376         if(n >= 0 && n < m_pTextInput.GetCount())
 377                 return m_pTextInput[n];
 378
 379         n -= m_pTextInput.GetCount();
 380
 381         return NULL;
 382 }
 383
 384 int CDirectVobSubFilter::GetPinCount()
 385 {
 386         return __super::GetPinCount() + m_pTextInput.GetCount();
 387 }
 388
 389 HRESULT CDirectVobSubFilter::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR pName)
 390 {
 391         if(pGraph)
 392         {
 393                 AFX_MANAGE_STATE(AfxGetStaticModuleState());
 394
 395                 if(!theApp.GetProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_SEENDIVXWARNING), 0))
 396                 {
 397                         unsigned __int64 ver = GetFileVersion(_T("divx_c32.ax"));
 398                         if(((ver >> 48)&0xffff) == 4 && ((ver >> 32)&0xffff) == 2)
 399                         {
 400                                 DWORD dwVersion = GetVersion();
 401                                 DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
 402                                 DWORD dwWindowsMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
 403
 404                                 if(dwVersion < 0x80000000 && dwWindowsMajorVersion >= 5)
 405                                 {
 406                                         AfxMessageBox(IDS_DIVX_WARNING);
 407                                         theApp.WriteProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_SEENDIVXWARNING), 1);
 408                                 }
 409                         }
 410                 }
 411
 412                 /*removeme*/
 413                 if(!g_RegOK)
 414                 {
 415                         DllRegisterServer();
 416                         g_RegOK = true;
 417                 }
 418         }
 419         else
 420         {
 421                 if(m_hSystrayThread)
 422                 {
 423                         SendMessage(m_tbid.hSystrayWnd, WM_CLOSE, 0, 0);
 424
 425                         if(WaitForSingleObject(m_hSystrayThread, 10000) != WAIT_OBJECT_0)
 426                         {
 427                                 DbgLog((LOG_TRACE, 0, _T("CALL THE AMBULANCE!!!")));
 428                                 TerminateThread(m_hSystrayThread, (DWORD)-1);
 429                         }
 430
 431                         m_hSystrayThread = 0;
 432                 }
 433         }
 434
 435         return __super::JoinFilterGraph(pGraph, pName);
 436 }
 437
 438 STDMETHODIMP CDirectVobSubFilter::QueryFilterInfo(FILTER_INFO* pInfo)
 439 {
 440     CheckPointer(pInfo, E_POINTER);
 441     ValidateReadWritePtr(pInfo, sizeof(FILTER_INFO));
 442
 443         if(!get_Forced())
 444                 return __super::QueryFilterInfo(pInfo);
 445
 446         wcscpy(pInfo->achName, L"DirectVobSub (forced auto-loading version)");
 447         if(pInfo->pGraph = m_pGraph) m_pGraph->AddRef();
 448
 449         return S_OK;
 450 }
 451
 452 // CTransformFilter
 453
 454 HRESULT CDirectVobSubFilter::SetMediaType(PIN_DIRECTION dir, const CMediaType* pmt)
 455 {
 456         HRESULT hr = __super::SetMediaType(dir, pmt);
 457         if(FAILED(hr)) return hr;
 458
 459         if(dir == PINDIR_INPUT)
 460         {
 461                 CAutoLock cAutoLock(&m_csReceive);
 462
 463                 REFERENCE_TIME atpf =
 464                         pmt->formattype == FORMAT_VideoInfo ? ((VIDEOINFOHEADER*)pmt->Format())->AvgTimePerFrame :
 465                         pmt->formattype == FORMAT_VideoInfo2 ? ((VIDEOINFOHEADER2*)pmt->Format())->AvgTimePerFrame :
 466                         0;
 467
 468                 m_fps = atpf ? 10000000.0 / atpf : 25;
 469
 470                 if (pmt->formattype == FORMAT_VideoInfo2)
 471                         m_CurrentVIH2 = *(VIDEOINFOHEADER2*)pmt->Format();
 472
 473                 DbgLog((LOG_TRACE, 3, "SetMediaType => InitSubPicQueue"));
 474                 InitSubPicQueue();
 475         }
 476         else if(dir == PINDIR_OUTPUT)
 477         {
 478
 479         }
 480
 481         return hr;
 482 }
 483
 484 HRESULT CDirectVobSubFilter::CheckConnect(PIN_DIRECTION dir, IPin* pPin)
 485 {
 486         if(dir == PINDIR_INPUT)
 487         {
 488         }
 489         else if(dir == PINDIR_OUTPUT)
 490         {
 491                 /*removeme*/
 492                 if(HmGyanusVagyTeNekem(pPin)) return(E_FAIL);
 493         }
 494
 495         return __super::CheckConnect(dir, pPin);
 496 }
 497
 498 HRESULT CDirectVobSubFilter::CompleteConnect(PIN_DIRECTION dir, IPin* pReceivePin)
 499 {
 500     bool reconnected = false;
 501         if(dir == PINDIR_INPUT)
 502         {
 503         DbgLog((LOG_TRACE, 3, TEXT("connect input")));
 504         DumpGraph(m_pGraph,0);
 505                 CComPtr<IBaseFilter> pFilter;
 506
 507                 // needed when we have a decoder with a version number of 3.x
 508                 if(SUCCEEDED(m_pGraph->FindFilterByName(L"DivX MPEG-4 DVD Video Decompressor ", &pFilter))
 509                         && (GetFileVersion(_T("divx_c32.ax")) >> 48) <= 4
 510                 || SUCCEEDED(m_pGraph->FindFilterByName(L"Microcrap MPEG-4 Video Decompressor", &pFilter))
 511                 || SUCCEEDED(m_pGraph->FindFilterByName(L"Microsoft MPEG-4 Video Decompressor", &pFilter))
 512                         && (GetFileVersion(_T("mpg4ds32.ax")) >> 48) <= 3)
 513                 {
 514                         m_fMSMpeg4Fix = true;
 515                 }
 516         }
 517         else if(dir == PINDIR_OUTPUT)
 518         {
 519         DbgLog((LOG_TRACE, 3, TEXT("connect output")));
 520         DumpGraph(m_pGraph,0);
 521         const CMediaType* mtIn = &(m_pInput->CurrentMediaType());
 522         const CMediaType* mtOut = &(m_pOutput->CurrentMediaType());
 523         CMediaType desiredMt;
 524         int position = 0;
 525         HRESULT hr;
 526
 527         bool can_reconnect = false;
 528         bool can_transform = (DoCheckTransform(mtIn, mtOut, true)==S_OK);
 529         if( mtIn->subtype!=mtOut->subtype )
 530         {
 531             position = GetOutputSubtypePosition(mtOut->subtype);
 532             if(position>=0)
 533             {
 534                 hr = GetMediaType(position, &desiredMt);
 535                 if (hr!=S_OK)
 536                 {
 537                     DbgLog((LOG_ERROR, 3, TEXT("Unexpected error when GetMediaType, position:%d"), position));
 538                 }
 539                 else
 540                 {
 541                     hr = DoCheckTransform(&desiredMt, mtOut, true);
 542                     if (hr!=S_OK)
 543                     {
 544                         DbgLog((LOG_TRACE, 3, TEXT("Transform not accept:")));
 545                         DisplayType(0,&desiredMt);
 546                         DisplayType(0,mtOut);
 547                     }
 548                     else
 549                     {
 550                         hr = m_pInput->GetConnected()->QueryAccept(&desiredMt);
 551                         if(hr!=S_OK)
 552                         {
 553                             DbgLog((LOG_TRACE, 3, TEXT("Upstream not accept:")));
 554                             DisplayType(0, &desiredMt);
 555                         }
 556                         else
 557                         {
 558                             can_reconnect = true;
 559                             DbgLog((LOG_ERROR, 3, TEXT("Can use the same subtype!")));
 560                         }
 561                     }
 562                 }
 563             }
 564             else
 565             {
 566                 DbgLog((LOG_ERROR, 3, TEXT("Cannot use the same subtype!")));
 567             }
 568         }
 569         if(!can_reconnect && !can_transform)
 570         {
 571             position = 0;
 572             do
 573             {
 574                 hr = GetMediaType(position, &desiredMt);
 575                 ++position;
 576                 //if( FAILED(hr) )
 577                 if( hr!=S_OK )
 578                     break;
 579
 580                 DbgLog((LOG_TRACE, 3, TEXT("Checking reconnect with media type:")));
 581                 DisplayType(0, &desiredMt);
 582
 583                 if( DoCheckTransform(&desiredMt, mtOut, true)!=S_OK ||
 584                     m_pInput->GetConnected()->QueryAccept(&desiredMt)!=S_OK )
 585                 {
 586                     continue;
 587                 }
 588                 else
 589                 {
 590                     can_reconnect = true;
 591                     break;
 592                 }
 593             } while ( true );
 594         }
 595         if ( can_reconnect )
 596         {
 597             if (SUCCEEDED(ReconnectPin(m_pInput, &desiredMt)))
 598             {
 599                 reconnected = true;
 600                 DumpGraph(m_pGraph,0);
 601                 //m_pInput->SetMediaType(&desiredMt);
 602                 DbgLog((LOG_TRACE, 3, TEXT("reconnected succeed!")));
 603             }
 604         }
 605         else if(!can_transform)
 606         {
 607             DbgLog((LOG_TRACE, 3, TEXT("Failed to agree reconnect type!")));
 608             if(m_pInput->IsConnected())
 609             {
 610                 m_pInput->GetConnected()->Disconnect();
 611                 m_pInput->Disconnect();
 612             }
 613             if(m_pOutput->IsConnected())
 614             {
 615                 m_pOutput->GetConnected()->Disconnect();
 616                 m_pOutput->Disconnect();
 617             }
 618             return VFW_E_TYPE_NOT_ACCEPTED;
 619         }
 620         }
 621     if (!reconnected && m_pOutput->IsConnected())
 622     {
 623         if(!m_hSystrayThread)
 624         {
 625             m_tbid.graph = m_pGraph;
 626             m_tbid.dvs = static_cast<IDirectVobSub*>(this);
 627
 628             DWORD tid;
 629             m_hSystrayThread = CreateThread(0, 0, SystrayThreadProc, &m_tbid, 0, &tid);
 630         }
 631         m_pInput->SetMediaType( &m_pInput->CurrentMediaType() );
 632     }
 633
 634     HRESULT hr = __super::CompleteConnect(dir, pReceivePin);
 635     DbgLog((LOG_TRACE, 3, TEXT("connect fininshed!")));
 636     DumpGraph(m_pGraph,0);
 637         return hr;
 638 }
 639
 640 HRESULT CDirectVobSubFilter::BreakConnect(PIN_DIRECTION dir)
 641 {
 642         if(dir == PINDIR_INPUT)
 643         {
 644                 //if(m_pOutput->IsConnected())
 645                 //{
 646                 //      m_pOutput->GetConnected()->Disconnect();
 647                 //      m_pOutput->Disconnect();
 648                 //}
 649         }
 650         else if(dir == PINDIR_OUTPUT)
 651         {
 652                 // not really needed, but may free up a little memory
 653                 CAutoLock cAutoLock(&m_csQueueLock);
 654                 m_pSubPicQueue = NULL;
 655         }
 656
 657         return __super::BreakConnect(dir);
 658 }
 659
 660 HRESULT CDirectVobSubFilter::StartStreaming()
 661 {
 662         /* WARNING: calls to m_pGraph member functions from within this function will generate deadlock with Haali
 663          * Video Renderer in MPC. Reason is that CAutoLock's variables in IFilterGraph functions are overriden by
 664          * CFGManager class.
 665          */
 666
 667         m_fLoading = false;
 668
 669         DbgLog((LOG_TRACE, 3, "StartStreaming => InitSubPicQueue"));
 670         InitSubPicQueue();
 671
 672         m_tbid.fRunOnce = true;
 673
 674         put_MediaFPS(m_fMediaFPSEnabled, m_MediaFPS);
 675
 676         return __super::StartStreaming();
 677 }
 678
 679 HRESULT CDirectVobSubFilter::StopStreaming()
 680 {
 681         InvalidateSubtitle();
 682
 683         //xy Timing
 684         //FILE * timingFile = fopen("C:\\vsfilter_timing.txt", "at");
 685         //fprintf(timingFile, "%s:%ld %s:%ld\n", "m_time_alphablt", m_time_alphablt, "m_time_rasterization", m_time_rasterization);
 686         //fclose(timingFile);
 687
 688         return __super::StopStreaming();
 689 }
 690
 691 HRESULT CDirectVobSubFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 692 {
 693         m_tPrev = tStart;
 694     return __super::NewSegment(tStart, tStop, dRate);
 695 }
 696
 697 //
 698
 699 REFERENCE_TIME CDirectVobSubFilter::CalcCurrentTime()
 700 {
 701         REFERENCE_TIME rt = m_pSubClock ? m_pSubClock->GetTime() : m_tPrev;
 702         return (rt - 10000i64*m_SubtitleDelay) * m_SubtitleSpeedMul / m_SubtitleSpeedDiv; // no, it won't overflow if we use normal parameters (__int64 is enough for about 2000 hours if we multiply it by the max: 65536 as m_SubtitleSpeedMul)
 703 }
 704
 705 void CDirectVobSubFilter::InitSubPicQueue()
 706 {
 707         CAutoLock cAutoLock(&m_csQueueLock);
 708     switch(m_colourSpace)
 709     {
 710     case CDirectVobSub::BT_601:
 711         ColorConvTable::SetDefaultYUVType(ColorConvTable::BT601);
 712         break;
 713     case CDirectVobSub::BT_709:
 714         ColorConvTable::SetDefaultYUVType(ColorConvTable::BT709);
 715         break;
 716     case CDirectVobSub::AUTO_GUESS:
 717         ColorConvTable::SetDefaultYUVType( (m_w > m_bt601Width || m_h > m_bt601Height) ?
 718             ColorConvTable::BT709 : ColorConvTable::BT601 );
 719         break;
 720     }
 721     CacheManager::GetPathDataMruCache()->SetMaxItemNum(m_path_data_cache_max_item_num);
 722     CacheManager::GetScanLineDataMruCache()->SetMaxItemNum(m_scan_line_data_cache_max_item_num);
 723     CacheManager::GetOverlayNoBlurMruCache()->SetMaxItemNum(m_overlay_no_blur_cache_max_item_num);
 724     CacheManager::GetOverlayMruCache()->SetMaxItemNum(m_overlay_cache_max_item_num);
 725     SubpixelPositionControler::GetGlobalControler().SetSubpixelLevel( static_cast<SubpixelPositionControler::SUBPIXEL_LEVEL>(m_subpixel_pos_level) );
 726
 727         m_pSubPicQueue = NULL;
 728
 729         const GUID& subtype = m_pInput->CurrentMediaType().subtype;
 730
 731         BITMAPINFOHEADER bihIn;
 732         ExtractBIH(&m_pInput->CurrentMediaType(), &bihIn);
 733
 734         m_spd.type = -1;
 735
 736         if(subtype == MEDIASUBTYPE_YV12) m_spd.type = MSP_YV12;
 737     else if(subtype == MEDIASUBTYPE_P010) m_spd.type = MSP_P010;
 738     else if(subtype == MEDIASUBTYPE_P016) m_spd.type = MSP_P016;
 739         else if(subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV) m_spd.type = MSP_IYUV;
 740         else if(subtype == MEDIASUBTYPE_YUY2) m_spd.type = MSP_YUY2;
 741         else if(subtype == MEDIASUBTYPE_RGB32) m_spd.type = MSP_RGB32;
 742         else if(subtype == MEDIASUBTYPE_RGB24) m_spd.type = MSP_RGB24;
 743         else if(subtype == MEDIASUBTYPE_RGB565) m_spd.type = MSP_RGB16;
 744         else if(subtype == MEDIASUBTYPE_RGB555) m_spd.type = MSP_RGB15;
 745     else if(subtype == MEDIASUBTYPE_NV12) m_spd.type = MSP_NV12;
 746     else if(subtype == MEDIASUBTYPE_NV21) m_spd.type = MSP_NV21;
 747
 748         m_spd.w = m_w;
 749         m_spd.h = m_h;
 750         m_spd.bpp = (m_spd.type == MSP_P010 || m_spd.type == MSP_P016) ? 16 :
 751         (m_spd.type == MSP_YV12 || m_spd.type == MSP_IYUV || m_spd.type == MSP_NV12 || m_spd.type == MSP_NV21) ? 8 : bihIn.biBitCount;
 752         m_spd.pitch = m_spd.w*m_spd.bpp>>3;
 753
 754     m_pTempPicBuff.Free();
 755     if(m_spd.type == MSP_YV12 || m_spd.type == MSP_IYUV)
 756         m_pTempPicBuff.Allocate(4*m_spd.pitch*m_spd.h);
 757     else if(m_spd.type == MSP_P010 || m_spd.type == MSP_P016)
 758         m_pTempPicBuff.Allocate(m_spd.pitch*m_spd.h+m_spd.pitch*m_spd.h/2);
 759     else
 760         m_pTempPicBuff.Allocate(m_spd.pitch*m_spd.h);
 761         m_spd.bits = (void*)m_pTempPicBuff;
 762
 763         //CComPtr<ISubPicExAllocator> pSubPicAllocator = new CMemSubPicAllocator(m_spd.type, CSize(m_w, m_h));
 764         CComPtr<ISubPicExAllocator> pSubPicAllocator = new CPooledSubPicAllocator(m_spd.type, CSize(m_w, m_h), MAX_SUBPIC_QUEUE_LENGTH + 1);
 765     if(pSubPicAllocator==NULL)
 766     {
 767         //fix me: log error
 768     }
 769
 770         CSize video(bihIn.biWidth, bihIn.biHeight), window = video;
 771         if(AdjustFrameSize(window)) video += video;
 772         ASSERT(window == CSize(m_w, m_h));
 773
 774         pSubPicAllocator->SetCurSize(window);
 775         pSubPicAllocator->SetCurVidRect(CRect(CPoint((window.cx - video.cx)/2, (window.cy - video.cy)/2), video));
 776
 777         HRESULT hr = S_OK;
 778         //m_pSubPicQueue = m_fDoPreBuffering
 779         //      ? (ISubPicQueue*)new CSubPicQueue(MAX_SUBPIC_QUEUE_LENGTH, pSubPicAllocator, &hr)
 780         //      : (ISubPicQueue*)new CSubPicQueueNoThread(pSubPicAllocator, &hr);
 781     m_pSubPicQueue = new CSubPicQueueNoThread(pSubPicAllocator, &hr);
 782
 783         if(FAILED(hr)) m_pSubPicQueue = NULL;
 784
 785         UpdateSubtitle(false);
 786
 787         if(m_hbm) {DeleteObject(m_hbm); m_hbm = NULL;}
 788         if(m_hdc) {DeleteDC(m_hdc); m_hdc = NULL;}
 789
 790         struct {BITMAPINFOHEADER bih; DWORD mask[3];} b = {{sizeof(BITMAPINFOHEADER), m_w, -(int)m_h, 1, 32, BI_BITFIELDS, 0, 0, 0, 0, 0}, 0xFF0000, 0x00FF00, 0x0000FF};
 791         m_hdc = CreateCompatibleDC(NULL);
 792         m_hbm = CreateDIBSection(m_hdc, (BITMAPINFO*)&b, DIB_RGB_COLORS, NULL, NULL, 0);
 793
 794         BITMAP bm;
 795         GetObject(m_hbm, sizeof(bm), &bm);
 796         memsetd(bm.bmBits, 0xFF000000, bm.bmHeight*bm.bmWidthBytes);
 797 }
 798
 799 bool CDirectVobSubFilter::AdjustFrameSize(CSize& s)
 800 {
 801         int horizontal, vertical, resx2, resx2minw, resx2minh;
 802         get_ExtendPicture(&horizontal, &vertical, &resx2, &resx2minw, &resx2minh);
 803
 804         bool fRet = (resx2 == 1) || (resx2 == 2 && s.cx*s.cy <= resx2minw*resx2minh);
 805
 806         if(fRet)
 807         {
 808                 s.cx <<= 1;
 809                 s.cy <<= 1;
 810         }
 811
 812         int h;
 813         switch(vertical&0x7f)
 814         {
 815         case 1:
 816                 h = s.cx * 9 / 16;
 817                 if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
 818                 break;
 819         case 2:
 820                 h = s.cx * 3 / 4;
 821                 if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
 822                 break;
 823         case 3:
 824                 h = 480;
 825                 if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
 826                 break;
 827         case 4:
 828                 h = 576;
 829                 if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
 830                 break;
 831         }
 832
 833         if(horizontal == 1)
 834         {
 835                 s.cx = (s.cx + 31) & ~31;
 836                 s.cy = (s.cy + 1) & ~1;
 837         }
 838
 839         return(fRet);
 840 }
 841
 842 STDMETHODIMP CDirectVobSubFilter::Count(DWORD* pcStreams)
 843 {
 844         if(!pcStreams) return E_POINTER;
 845
 846         *pcStreams = 0;
 847
 848         int nLangs = 0;
 849         if(SUCCEEDED(get_LanguageCount(&nLangs)))
 850                 (*pcStreams) += nLangs;
 851
 852         (*pcStreams) += 2; // enable ... disable
 853
 854         (*pcStreams) += 2; // normal flipped
 855
 856         return S_OK;
 857 }
 858
 859 #define MAXPREFLANGS 5
 860
 861 int CDirectVobSubFilter::FindPreferedLanguage(bool fHideToo)
 862 {
 863         AFX_MANAGE_STATE(AfxGetStaticModuleState());
 864
 865         int nLangs;
 866         get_LanguageCount(&nLangs);
 867
 868         if(nLangs <= 0) return(0);
 869
 870         for(int i = 0; i < MAXPREFLANGS; i++)
 871         {
 872                 CString tmp;
 873                 tmp.Format(IDS_RL_LANG, i);
 874
 875                 CString lang = theApp.GetProfileString(ResStr(IDS_R_PREFLANGS), tmp);
 876
 877                 if(!lang.IsEmpty())
 878                 {
 879                         for(int ret = 0; ret < nLangs; ret++)
 880                         {
 881                                 CString l;
 882                                 WCHAR* pName = NULL;
 883                                 get_LanguageName(ret, &pName);
 884                                 l = pName;
 885                                 CoTaskMemFree(pName);
 886
 887                                 if(!l.CompareNoCase(lang)) return(ret);
 888                         }
 889                 }
 890         }
 891
 892         return(0);
 893 }
 894
 895 void CDirectVobSubFilter::UpdatePreferedLanguages(CString l)
 896 {
 897         AFX_MANAGE_STATE(AfxGetStaticModuleState());
 898
 899         CString langs[MAXPREFLANGS+1];
 900
 901         int i = 0, j = 0, k = -1;
 902         for(; i < MAXPREFLANGS; i++)
 903         {
 904                 CString tmp;
 905                 tmp.Format(IDS_RL_LANG, i);
 906
 907                 langs[j] = theApp.GetProfileString(ResStr(IDS_R_PREFLANGS), tmp);
 908
 909                 if(!langs[j].IsEmpty())
 910                 {
 911                         if(!langs[j].CompareNoCase(l)) k = j;
 912                         j++;
 913                 }
 914         }
 915
 916         if(k == -1)
 917         {
 918                 langs[k = j] = l;
 919                 j++;
 920         }
 921
 922         // move the selected to the top of the list
 923
 924         while(k > 0)
 925         {
 926                 CString tmp = langs[k]; langs[k] = langs[k-1]; langs[k-1] = tmp;
 927                 k--;
 928         }
 929
 930         // move "Hide subtitles" to the last position if it wasn't our selection
 931
 932         CString hidesubs;
 933         hidesubs.LoadString(IDS_M_HIDESUBTITLES);
 934
 935         for(k = 1; k < j; k++)
 936         {
 937                 if(!langs[k].CompareNoCase(hidesubs)) break;
 938         }
 939
 940         while(k < j-1)
 941         {
 942                 CString tmp = langs[k]; langs[k] = langs[k+1]; langs[k+1] = tmp;
 943                 k++;
 944         }
 945
 946         for(i = 0; i < j; i++)
 947         {
 948                 CString tmp;
 949                 tmp.Format(IDS_RL_LANG, i);
 950
 951                 theApp.WriteProfileString(ResStr(IDS_R_PREFLANGS), tmp, langs[i]);
 952         }
 953 }
 954
 955 STDMETHODIMP CDirectVobSubFilter::Enable(long lIndex, DWORD dwFlags)
 956 {
 957         if(!(dwFlags & AMSTREAMSELECTENABLE_ENABLE))
 958                 return E_NOTIMPL;
 959
 960         int nLangs = 0;
 961         get_LanguageCount(&nLangs);
 962
 963         if(!(lIndex >= 0 && lIndex < nLangs+2+2))
 964                 return E_INVALIDARG;
 965
 966         int i = lIndex-1;
 967
 968         if(i == -1 && !m_fLoading) // we need this because when loading something stupid media player pushes the first stream it founds, which is "enable" in our case
 969         {
 970                 put_HideSubtitles(false);
 971         }
 972         else if(i >= 0 && i < nLangs)
 973         {
 974                 put_HideSubtitles(false);
 975                 put_SelectedLanguage(i);
 976
 977                 WCHAR* pName = NULL;
 978                 if(SUCCEEDED(get_LanguageName(i, &pName)))
 979                 {
 980                         UpdatePreferedLanguages(CString(pName));
 981                         if(pName) CoTaskMemFree(pName);
 982                 }
 983         }
 984         else if(i == nLangs && !m_fLoading)
 985         {
 986                 put_HideSubtitles(true);
 987         }
 988         else if((i == nLangs+1 || i == nLangs+2) && !m_fLoading)
 989         {
 990                 put_Flip(i == nLangs+2, m_fFlipSubtitles);
 991         }
 992
 993         return S_OK;
 994 }
 995
 996 STDMETHODIMP CDirectVobSubFilter::Info(long lIndex, AM_MEDIA_TYPE** ppmt, DWORD* pdwFlags, LCID* plcid, DWORD* pdwGroup, WCHAR** ppszName, IUnknown** ppObject, IUnknown** ppUnk)
 997 {
 998         AFX_MANAGE_STATE(AfxGetStaticModuleState());
 999
1000         int nLangs = 0;
1001         get_LanguageCount(&nLangs);
1002
1003         if(!(lIndex >= 0 && lIndex < nLangs+2+2))
1004                 return E_INVALIDARG;
1005
1006         int i = lIndex-1;
1007
1008         if(ppmt) *ppmt = CreateMediaType(&m_pInput->CurrentMediaType());
1009
1010         if(pdwFlags)
1011         {
1012                 *pdwFlags = 0;
1013
1014                 if(i == -1 && !m_fHideSubtitles
1015                 || i >= 0 && i < nLangs && i == m_iSelectedLanguage
1016                 || i == nLangs && m_fHideSubtitles
1017                 || i == nLangs+1 && !m_fFlipPicture
1018                 || i == nLangs+2 && m_fFlipPicture)
1019                 {
1020                         *pdwFlags |= AMSTREAMSELECTINFO_ENABLED;
1021                 }
1022         }
1023
1024         if(plcid) *plcid = 0;
1025
1026         if(pdwGroup) *pdwGroup = 0x648E51;
1027
1028         if(ppszName)
1029         {
1030                 *ppszName = NULL;
1031
1032                 CStringW str;
1033                 if(i == -1) str = ResStr(IDS_M_SHOWSUBTITLES);
1034                 else if(i >= 0 && i < nLangs) get_LanguageName(i, ppszName);
1035                 else if(i == nLangs) str = ResStr(IDS_M_HIDESUBTITLES);
1036                 else if(i == nLangs+1) {str = ResStr(IDS_M_ORIGINALPICTURE); if(pdwGroup) (*pdwGroup)++;}
1037                 else if(i == nLangs+2) {str = ResStr(IDS_M_FLIPPEDPICTURE); if(pdwGroup) (*pdwGroup)++;}
1038
1039                 if(!str.IsEmpty())
1040                 {
1041                         *ppszName = (WCHAR*)CoTaskMemAlloc((str.GetLength()+1)*sizeof(WCHAR));
1042                         if(*ppszName == NULL) return S_FALSE;
1043                         wcscpy(*ppszName, str);
1044                 }
1045         }
1046
1047         if(ppObject) *ppObject = NULL;
1048
1049         if(ppUnk) *ppUnk = NULL;
1050
1051         return S_OK;
1052 }
1053
1054 STDMETHODIMP CDirectVobSubFilter::GetClassID(CLSID* pClsid)
1055 {
1056     if(pClsid == NULL) return E_POINTER;
1057         *pClsid = m_clsid;
1058     return NOERROR;
1059 }
1060
1061 STDMETHODIMP CDirectVobSubFilter::GetPages(CAUUID* pPages)
1062 {
1063     CheckPointer(pPages, E_POINTER);
1064
1065         pPages->cElems = 8;
1066     pPages->pElems = (GUID*)CoTaskMemAlloc(sizeof(GUID)*pPages->cElems);
1067
1068         if(pPages->pElems == NULL) return E_OUTOFMEMORY;
1069
1070         int i = 0;
1071     pPages->pElems[i++] = __uuidof(CDVSMainPPage);
1072     pPages->pElems[i++] = __uuidof(CDVSGeneralPPage);
1073     pPages->pElems[i++] = __uuidof(CDVSMiscPPage);
1074     pPages->pElems[i++] = __uuidof(CDVSMorePPage);
1075     pPages->pElems[i++] = __uuidof(CDVSTimingPPage);
1076     pPages->pElems[i++] = __uuidof(CDVSColorPPage);
1077     pPages->pElems[i++] = __uuidof(CDVSPathsPPage);
1078     pPages->pElems[i++] = __uuidof(CDVSAboutPPage);
1079
1080     return NOERROR;
1081 }
1082
1083 // IDirectVobSub
1084
1085 STDMETHODIMP CDirectVobSubFilter::put_FileName(WCHAR* fn)
1086 {
1087     AMTRACE((TEXT(__FUNCTION__),0));
1088         HRESULT hr = CDirectVobSub::put_FileName(fn);
1089
1090         if(hr == S_OK && !Open())
1091         {
1092                 m_FileName.Empty();
1093                 hr = E_FAIL;
1094         }
1095
1096         return hr;
1097 }
1098
1099 STDMETHODIMP CDirectVobSubFilter::get_LanguageCount(int* nLangs)
1100 {
1101         HRESULT hr = CDirectVobSub::get_LanguageCount(nLangs);
1102
1103         if(hr == NOERROR && nLangs)
1104         {
1105         CAutoLock cAutolock(&m_csQueueLock);
1106
1107                 *nLangs = 0;
1108                 POSITION pos = m_pSubStreams.GetHeadPosition();
1109                 while(pos) (*nLangs) += m_pSubStreams.GetNext(pos)->GetStreamCount();
1110         }
1111
1112         return hr;
1113 }
1114
1115 STDMETHODIMP CDirectVobSubFilter::get_LanguageName(int iLanguage, WCHAR** ppName)
1116 {
1117         HRESULT hr = CDirectVobSub::get_LanguageName(iLanguage, ppName);
1118
1119         if(!ppName) return E_POINTER;
1120
1121         if(hr == NOERROR)
1122         {
1123         CAutoLock cAutolock(&m_csQueueLock);
1124
1125                 hr = E_INVALIDARG;
1126
1127                 int i = iLanguage;
1128
1129                 POSITION pos = m_pSubStreams.GetHeadPosition();
1130                 while(i >= 0 && pos)
1131                 {
1132                         CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
1133
1134                         if(i < pSubStream->GetStreamCount())
1135                         {
1136                                 pSubStream->GetStreamInfo(i, ppName, NULL);
1137                                 hr = NOERROR;
1138                                 break;
1139                         }
1140
1141                         i -= pSubStream->GetStreamCount();
1142                 }
1143         }
1144
1145         return hr;
1146 }
1147
1148 STDMETHODIMP CDirectVobSubFilter::put_SelectedLanguage(int iSelected)
1149 {
1150         HRESULT hr = CDirectVobSub::put_SelectedLanguage(iSelected);
1151
1152         if(hr == NOERROR)
1153         {
1154                 UpdateSubtitle(false);
1155         }
1156
1157         return hr;
1158 }
1159
1160 STDMETHODIMP CDirectVobSubFilter::put_HideSubtitles(bool fHideSubtitles)
1161 {
1162         HRESULT hr = CDirectVobSub::put_HideSubtitles(fHideSubtitles);
1163
1164         if(hr == NOERROR)
1165         {
1166                 UpdateSubtitle(false);
1167         }
1168
1169         return hr;
1170 }
1171
1172 STDMETHODIMP CDirectVobSubFilter::put_PreBuffering(bool fDoPreBuffering)
1173 {
1174         HRESULT hr = CDirectVobSub::put_PreBuffering(fDoPreBuffering);
1175
1176         if(hr == NOERROR)
1177         {
1178                 DbgLog((LOG_TRACE, 3, "put_PreBuffering => InitSubPicQueue"));
1179                 InitSubPicQueue();
1180         }
1181
1182         return hr;
1183 }
1184
1185 STDMETHODIMP CDirectVobSubFilter::put_ColourSpace(int colourSpace)
1186 {
1187     CAutoLock cAutolock(&m_csQueueLock);
1188     HRESULT hr = CDirectVobSub::put_ColourSpace(colourSpace);
1189
1190     if(hr == NOERROR)
1191     {
1192         switch(m_colourSpace)
1193         {
1194         case ColourSpaceOption::BT_601:
1195             ColorConvTable::SetDefaultYUVType(ColorConvTable::BT601);
1196             break;
1197         case ColourSpaceOption::BT_709:
1198             ColorConvTable::SetDefaultYUVType(ColorConvTable::BT709);
1199             break;
1200         case ColourSpaceOption::AUTO_GUESS:
1201             ColorConvTable::SetDefaultYUVType( (m_w > m_bt601Width || m_h > m_bt601Height) ?
1202                 ColorConvTable::BT709 : ColorConvTable::BT601 );
1203             break;
1204         }
1205     }
1206
1207     return hr;
1208 }
1209
1210 STDMETHODIMP CDirectVobSubFilter::put_Placement(bool fOverridePlacement, int xperc, int yperc)
1211 {
1212         DbgLog((LOG_TRACE, 3, "%s(%d) %s", __FILE__, __LINE__, __FUNCTION__));
1213         HRESULT hr = CDirectVobSub::put_Placement(fOverridePlacement, xperc, yperc);
1214
1215         if(hr == NOERROR)
1216         {
1217                 //DbgLog((LOG_TRACE, 3, "%d %s:UpdateSubtitle(true)", __LINE__, __FUNCTION__));
1218                 //UpdateSubtitle(true);
1219                 UpdateSubtitle(false);
1220         }
1221
1222         return hr;
1223 }
1224
1225 STDMETHODIMP CDirectVobSubFilter::put_VobSubSettings(bool fBuffer, bool fOnlyShowForcedSubs, bool fReserved)
1226 {
1227         HRESULT hr = CDirectVobSub::put_VobSubSettings(fBuffer, fOnlyShowForcedSubs, fReserved);
1228
1229         if(hr == NOERROR)
1230         {
1231 //              UpdateSubtitle(false);
1232                 InvalidateSubtitle();
1233         }
1234
1235         return hr;
1236 }
1237
1238 STDMETHODIMP CDirectVobSubFilter::put_TextSettings(void* lf, int lflen, COLORREF color, bool fShadow, bool fOutline, bool fAdvancedRenderer)
1239 {
1240         HRESULT hr = CDirectVobSub::put_TextSettings(lf, lflen, color, fShadow, fOutline, fAdvancedRenderer);
1241
1242         if(hr == NOERROR)
1243         {
1244 //              UpdateSubtitle(true);
1245                 InvalidateSubtitle();
1246         }
1247
1248         return hr;
1249 }
1250
1251 STDMETHODIMP CDirectVobSubFilter::put_SubtitleTiming(int delay, int speedmul, int speeddiv)
1252 {
1253         HRESULT hr = CDirectVobSub::put_SubtitleTiming(delay, speedmul, speeddiv);
1254
1255         if(hr == NOERROR)
1256         {
1257                 InvalidateSubtitle();
1258         }
1259
1260         return hr;
1261 }
1262
1263 STDMETHODIMP CDirectVobSubFilter::put_OverlayCacheMaxItemNum( int overlay_cache_max_item_num )
1264 {
1265     CAutoLock cAutolock(&m_csQueueLock);
1266     HRESULT hr = CDirectVobSub::put_OverlayCacheMaxItemNum(overlay_cache_max_item_num);
1267
1268     if(hr == NOERROR)
1269     {
1270         CacheManager::GetOverlayMruCache()->SetMaxItemNum(m_overlay_cache_max_item_num);
1271     }
1272
1273     return hr;
1274 }
1275
1276 STDMETHODIMP CDirectVobSubFilter::put_ScanLineDataCacheMaxItemNum( int scan_line_data_cache_max_item_num )
1277 {
1278     CAutoLock cAutolock(&m_csQueueLock);
1279     HRESULT hr = CDirectVobSub::put_ScanLineDataCacheMaxItemNum(scan_line_data_cache_max_item_num);
1280
1281     if(hr == NOERROR)
1282     {
1283         CacheManager::GetScanLineDataMruCache()->SetMaxItemNum(m_scan_line_data_cache_max_item_num);
1284     }
1285
1286     return hr;
1287 }
1288
1289 STDMETHODIMP CDirectVobSubFilter::put_PathDataCacheMaxItemNum(int path_data_cache_max_item_num)
1290 {
1291     CAutoLock cAutolock(&m_csQueueLock);
1292     HRESULT hr = CDirectVobSub::put_PathDataCacheMaxItemNum(path_data_cache_max_item_num);
1293
1294     if(hr == NOERROR)
1295     {
1296         CacheManager::GetPathDataMruCache()->SetMaxItemNum(m_path_data_cache_max_item_num);
1297     }
1298
1299     return hr;
1300 }
1301
1302 STDMETHODIMP CDirectVobSubFilter::put_OverlayNoBlurCacheMaxItemNum(int overlay_no_blur_cache_max_item_num)
1303 {
1304     CAutoLock cAutolock(&m_csQueueLock);
1305     HRESULT hr = CDirectVobSub::put_OverlayNoBlurCacheMaxItemNum(overlay_no_blur_cache_max_item_num);
1306
1307     if(hr == NOERROR)
1308     {
1309         CacheManager::GetOverlayNoBlurMruCache()->SetMaxItemNum(m_overlay_no_blur_cache_max_item_num);
1310     }
1311
1312     return hr;
1313 }
1314
1315 STDMETHODIMP CDirectVobSubFilter::get_CachesInfo(CachesInfo* caches_info)
1316 {
1317     CAutoLock cAutoLock(&m_csQueueLock);
1318     HRESULT hr = CDirectVobSub::get_CachesInfo(caches_info);
1319
1320     caches_info->path_cache_cur_item_num    = CacheManager::GetPathDataMruCache()->GetCurItemNum();
1321     caches_info->path_cache_hit_count       = CacheManager::GetPathDataMruCache()->GetCacheHitCount();
1322     caches_info->path_cache_query_count     = CacheManager::GetPathDataMruCache()->GetQueryCount();
1323     caches_info->scanline_cache_cur_item_num= CacheManager::GetScanLineDataMruCache()->GetCurItemNum();
1324     caches_info->scanline_cache_hit_count   = CacheManager::GetScanLineDataMruCache()->GetCacheHitCount();
1325     caches_info->scanline_cache_query_count = CacheManager::GetScanLineDataMruCache()->GetQueryCount();
1326     caches_info->non_blur_cache_cur_item_num= CacheManager::GetOverlayNoBlurMruCache()->GetCurItemNum();
1327     caches_info->non_blur_cache_hit_count   = CacheManager::GetOverlayNoBlurMruCache()->GetCacheHitCount();
1328     caches_info->non_blur_cache_query_count = CacheManager::GetOverlayNoBlurMruCache()->GetQueryCount();
1329     caches_info->overlay_cache_cur_item_num = CacheManager::GetOverlayMruCache()->GetCurItemNum();
1330     caches_info->overlay_cache_hit_count    = CacheManager::GetOverlayMruCache()->GetCacheHitCount();
1331     caches_info->overlay_cache_query_count  = CacheManager::GetOverlayMruCache()->GetQueryCount();
1332
1333     caches_info->interpolate_cache_cur_item_num = CacheManager::GetSubpixelVarianceCache()->GetCurItemNum();
1334     caches_info->interpolate_cache_hit_count    = CacheManager::GetSubpixelVarianceCache()->GetCacheHitCount();
1335     caches_info->interpolate_cache_query_count  = CacheManager::GetSubpixelVarianceCache()->GetQueryCount();
1336     caches_info->text_info_cache_cur_item_num   = CacheManager::GetTextInfoCache()->GetCurItemNum();
1337     caches_info->text_info_cache_hit_count      = CacheManager::GetTextInfoCache()->GetCacheHitCount();
1338     caches_info->text_info_cache_query_count    = CacheManager::GetTextInfoCache()->GetQueryCount();
1339
1340     caches_info->word_info_cache_cur_item_num   = CacheManager::GetAssTagListMruCache()->GetCurItemNum();
1341     caches_info->word_info_cache_hit_count      = CacheManager::GetAssTagListMruCache()->GetCacheHitCount();
1342     caches_info->word_info_cache_query_count    = CacheManager::GetAssTagListMruCache()->GetQueryCount();
1343
1344     return hr;
1345 }
1346
1347 STDMETHODIMP CDirectVobSubFilter::put_SubpixelPositionLevel(int subpixel_pos_level)
1348 {
1349     CAutoLock cAutolock(&m_csQueueLock);
1350     HRESULT hr = CDirectVobSub::put_SubpixelPositionLevel(subpixel_pos_level);
1351
1352     if(hr == NOERROR)
1353     {
1354         SubpixelPositionControler::GetGlobalControler().SetSubpixelLevel( static_cast<SubpixelPositionControler::SUBPIXEL_LEVEL>(subpixel_pos_level) );
1355     }
1356
1357     return hr;
1358 }
1359
1360 STDMETHODIMP CDirectVobSubFilter::put_FollowUpstreamPreferredOrder( bool fFollowUpstreamPreferredOrder )
1361 {
1362     CAutoLock cAutolock(&m_csQueueLock);
1363     HRESULT hr = CDirectVobSub::put_FollowUpstreamPreferredOrder(fFollowUpstreamPreferredOrder);
1364
1365     if(hr == NOERROR)
1366     {
1367         m_donot_follow_upstream_preferred_order = !m_fFollowUpstreamPreferredOrder;
1368     }
1369
1370     return hr;
1371 }
1372
1373 STDMETHODIMP CDirectVobSubFilter::get_MediaFPS(bool* fEnabled, double* fps)
1374 {
1375         HRESULT hr = CDirectVobSub::get_MediaFPS(fEnabled, fps);
1376
1377         CComQIPtr<IMediaSeeking> pMS = m_pGraph;
1378         double rate;
1379         if(pMS && SUCCEEDED(pMS->GetRate(&rate)))
1380         {
1381                 m_MediaFPS = rate * m_fps;
1382                 if(fps) *fps = m_MediaFPS;
1383         }
1384
1385         return hr;
1386 }
1387
1388 STDMETHODIMP CDirectVobSubFilter::put_MediaFPS(bool fEnabled, double fps)
1389 {
1390         HRESULT hr = CDirectVobSub::put_MediaFPS(fEnabled, fps);
1391
1392         CComQIPtr<IMediaSeeking> pMS = m_pGraph;
1393         if(pMS)
1394         {
1395                 if(hr == NOERROR)
1396                 {
1397                         hr = pMS->SetRate(m_fMediaFPSEnabled ? m_MediaFPS / m_fps : 1.0);
1398                 }
1399
1400                 double dRate;
1401                 if(SUCCEEDED(pMS->GetRate(&dRate)))
1402                         m_MediaFPS = dRate * m_fps;
1403         }
1404
1405         return hr;
1406 }
1407
1408 STDMETHODIMP CDirectVobSubFilter::get_ZoomRect(NORMALIZEDRECT* rect)
1409 {
1410         return E_NOTIMPL;
1411 }
1412
1413 STDMETHODIMP CDirectVobSubFilter::put_ZoomRect(NORMALIZEDRECT* rect)
1414 {
1415         return E_NOTIMPL;
1416 }
1417
1418 // IDirectVobSub2
1419
1420 STDMETHODIMP CDirectVobSubFilter::put_TextSettings(STSStyle* pDefStyle)
1421 {
1422         HRESULT hr = CDirectVobSub::put_TextSettings(pDefStyle);
1423
1424         if(hr == NOERROR)
1425         {
1426                 //DbgLog((LOG_TRACE, 3, "%d %s:UpdateSubtitle(true)", __LINE__, __FUNCTION__));
1427                 //UpdateSubtitle(true);
1428                 UpdateSubtitle(false);
1429         }
1430
1431         return hr;
1432 }
1433
1434 STDMETHODIMP CDirectVobSubFilter::put_AspectRatioSettings(CSimpleTextSubtitle::EPARCompensationType* ePARCompensationType)
1435 {
1436         HRESULT hr = CDirectVobSub::put_AspectRatioSettings(ePARCompensationType);
1437
1438         if(hr == NOERROR)
1439         {
1440                 //DbgLog((LOG_TRACE, 3, "%d %s:UpdateSubtitle(true)", __LINE__, __FUNCTION__));
1441                 //UpdateSubtitle(true);
1442                 UpdateSubtitle(false);
1443         }
1444
1445         return hr;
1446 }
1447
1448 // IDirectVobSubFilterColor
1449
1450 STDMETHODIMP CDirectVobSubFilter::HasConfigDialog(int iSelected)
1451 {
1452         int nLangs;
1453         if(FAILED(get_LanguageCount(&nLangs))) return E_FAIL;
1454         return E_FAIL;
1455         // TODO: temporally disabled since we don't have a new textsub/vobsub editor dlg for dvs yet
1456 //      return(nLangs >= 0 && iSelected < nLangs ? S_OK : E_FAIL);
1457 }
1458
1459 STDMETHODIMP CDirectVobSubFilter::ShowConfigDialog(int iSelected, HWND hWndParent)
1460 {
1461         // TODO: temporally disabled since we don't have a new textsub/vobsub editor dlg for dvs yet
1462         return(E_FAIL);
1463 }
1464
1465 ///////////////////////////////////////////////////////////////////////////
1466
1467 CDirectVobSubFilter2::CDirectVobSubFilter2(LPUNKNOWN punk, HRESULT* phr, const GUID& clsid) :
1468         CDirectVobSubFilter(punk, phr, clsid)
1469 {
1470 }
1471
1472 HRESULT CDirectVobSubFilter2::CheckConnect(PIN_DIRECTION dir, IPin* pPin)
1473 {
1474         CPinInfo pi;
1475         if(FAILED(pPin->QueryPinInfo(&pi))) return E_FAIL;
1476
1477         if(CComQIPtr<IDirectVobSub>(pi.pFilter)) return E_FAIL;
1478
1479         if(dir == PINDIR_INPUT)
1480         {
1481                 CFilterInfo fi;
1482                 if(SUCCEEDED(pi.pFilter->QueryFilterInfo(&fi))
1483                 && !wcsnicmp(fi.achName, L"Overlay Mixer", 13))
1484                         return(E_FAIL);
1485         }
1486         else
1487         {
1488         }
1489
1490         return __super::CheckConnect(dir, pPin);
1491 }
1492
1493 HRESULT CDirectVobSubFilter2::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR pName)
1494 {
1495     XY_AUTO_TIMING(_T("CDirectVobSubFilter2::JoinFilterGraph"));
1496         if(pGraph)
1497         {
1498                 BeginEnumFilters(pGraph, pEF, pBF)
1499                 {
1500                         if(pBF != (IBaseFilter*)this && CComQIPtr<IDirectVobSub>(pBF))
1501                                 return E_FAIL;
1502                 }
1503                 EndEnumFilters
1504
1505                 // don't look... we will do some serious graph hacking again...
1506                 //
1507                 // we will add dvs2 to the filter graph cache
1508                 // - if the main app has already added some kind of renderer or overlay mixer (anything which accepts video on its input)
1509                 // and
1510                 // - if we have a reason to auto-load (we don't want to make any trouble when there is no need :)
1511                 //
1512                 // This whole workaround is needed because the video stream will always be connected
1513                 // to the pre-added filters first, no matter how high merit we have.
1514
1515                 if(!get_Forced())
1516                 {
1517                         BeginEnumFilters(pGraph, pEF, pBF)
1518                         {
1519                                 if(CComQIPtr<IDirectVobSub>(pBF))
1520                                         continue;
1521
1522                                 CComPtr<IPin> pInPin = GetFirstPin(pBF, PINDIR_INPUT);
1523                                 CComPtr<IPin> pOutPin = GetFirstPin(pBF, PINDIR_OUTPUT);
1524
1525                                 if(!pInPin)
1526                                         continue;
1527
1528                                 CComPtr<IPin> pPin;
1529                                 if(pInPin && SUCCEEDED(pInPin->ConnectedTo(&pPin))
1530                                 || pOutPin && SUCCEEDED(pOutPin->ConnectedTo(&pPin)))
1531                                         continue;
1532
1533                                 if(pOutPin && GetFilterName(pBF) == _T("Overlay Mixer"))
1534                                         continue;
1535
1536                                 bool fVideoInputPin = false;
1537
1538                                 do
1539                                 {
1540                                         BITMAPINFOHEADER bih = {sizeof(BITMAPINFOHEADER), 384, 288, 1, 16, '2YUY', 384*288*2, 0, 0, 0, 0};
1541
1542                                         CMediaType cmt;
1543                                         cmt.majortype = MEDIATYPE_Video;
1544                                         cmt.subtype = MEDIASUBTYPE_YUY2;
1545                                         cmt.formattype = FORMAT_VideoInfo;
1546                                         cmt.pUnk = NULL;
1547                                         cmt.bFixedSizeSamples = TRUE;
1548                                         cmt.bTemporalCompression = TRUE;
1549                                         cmt.lSampleSize = 384*288*2;
1550                                         VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)cmt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
1551                                         memset(vih, 0, sizeof(VIDEOINFOHEADER));
1552                                         memcpy(&vih->bmiHeader, &bih, sizeof(bih));
1553                                         vih->AvgTimePerFrame = 400000;
1554
1555                                         if(SUCCEEDED(pInPin->QueryAccept(&cmt)))
1556                                         {
1557                                                 fVideoInputPin = true;
1558                                                 break;
1559                                         }
1560
1561                                         VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)cmt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));
1562                                         memset(vih2, 0, sizeof(VIDEOINFOHEADER2));
1563                                         memcpy(&vih2->bmiHeader, &bih, sizeof(bih));
1564                                         vih2->AvgTimePerFrame = 400000;
1565                                         vih2->dwPictAspectRatioX = 384;
1566                                         vih2->dwPictAspectRatioY = 288;
1567
1568                                         if(SUCCEEDED(pInPin->QueryAccept(&cmt)))
1569                                         {
1570                                                 fVideoInputPin = true;
1571                                                 break;
1572                                         }
1573                                 }
1574                                 while(false);
1575
1576                                 if(fVideoInputPin)
1577                                 {
1578                                         CComPtr<IBaseFilter> pDVS;
1579                                         if(ShouldWeAutoload(pGraph) && SUCCEEDED(pDVS.CoCreateInstance(__uuidof(CDirectVobSubFilter2))))
1580                                         {
1581                                                 CComQIPtr<IDirectVobSub2>(pDVS)->put_Forced(true);
1582                                                 CComQIPtr<IGraphConfig>(pGraph)->AddFilterToCache(pDVS);
1583                                         }
1584
1585                                         break;
1586                                 }
1587                         }
1588                         EndEnumFilters
1589                 }
1590         }
1591         else
1592         {
1593         }
1594
1595         return __super::JoinFilterGraph(pGraph, pName);
1596 }
1597
1598 HRESULT CDirectVobSubFilter2::CheckInputType(const CMediaType* mtIn)
1599 {
1600     XY_AUTO_TIMING(_T("CDirectVobSubFilter2::CheckInputType"));
1601     HRESULT hr = __super::CheckInputType(mtIn);
1602
1603         if(FAILED(hr) || m_pInput->IsConnected()) return hr;
1604
1605         if(!ShouldWeAutoload(m_pGraph)) return VFW_E_TYPE_NOT_ACCEPTED;
1606
1607         GetRidOfInternalScriptRenderer();
1608
1609         return NOERROR;
1610 }
1611
1612 bool CDirectVobSubFilter2::ShouldWeAutoload(IFilterGraph* pGraph)
1613 {
1614     XY_AUTO_TIMING(_T("CDirectVobSubFilter2::ShouldWeAutoload"));
1615         TCHAR blacklistedapps[][32] =
1616         {
1617                 _T("WM8EUTIL."), // wmp8 encoder's dummy renderer releases the outputted media sample after calling Receive on its input pin (yes, even when dvobsub isn't registered at all)
1618                 _T("explorer."), // as some users reported thumbnail preview loads dvobsub, I've never experienced this yet...
1619                 _T("producer."), // this is real's producer
1620                 _T("GoogleDesktopIndex."), // Google Desktop
1621                 _T("GoogleDesktopDisplay."), // Google Desktop
1622                 _T("GoogleDesktopCrawl."), // Google Desktop
1623         };
1624
1625         for(int i = 0; i < countof(blacklistedapps); i++)
1626         {
1627                 if(theApp.m_AppName.Find(blacklistedapps[i]) >= 0)
1628                         return(false);
1629         }
1630
1631         int level;
1632         bool m_fExternalLoad, m_fWebLoad, m_fEmbeddedLoad;
1633         get_LoadSettings(&level, &m_fExternalLoad, &m_fWebLoad, &m_fEmbeddedLoad);
1634
1635         if(level < 0 || level >= 2) return(false);
1636
1637         bool fRet = false;
1638
1639         if(level == 1)
1640                 fRet = m_fExternalLoad = m_fWebLoad = m_fEmbeddedLoad = true;
1641
1642         // find text stream on known splitters
1643
1644         if(!fRet && m_fEmbeddedLoad)
1645         {
1646                 CComPtr<IBaseFilter> pBF;
1647                 if((pBF = FindFilter(CLSID_OggSplitter, pGraph)) || (pBF = FindFilter(CLSID_AviSplitter, pGraph))
1648                 || (pBF = FindFilter(L"{34293064-02F2-41D5-9D75-CC5967ACA1AB}", pGraph)) // matroska demux
1649                 || (pBF = FindFilter(L"{0A68C3B5-9164-4a54-AFAF-995B2FF0E0D4}", pGraph)) // matroska source
1650                 || (pBF = FindFilter(L"{149D2E01-C32E-4939-80F6-C07B81015A7A}", pGraph)) // matroska splitter
1651                 || (pBF = FindFilter(L"{55DA30FC-F16B-49fc-BAA5-AE59FC65F82D}", pGraph)) // Haali Media Splitter
1652                 || (pBF = FindFilter(L"{564FD788-86C9-4444-971E-CC4A243DA150}", pGraph)) // Haali Media Splitter (AR)
1653                 || (pBF = FindFilter(L"{8F43B7D9-9D6B-4F48-BE18-4D787C795EEA}", pGraph)) // Haali Simple Media Splitter
1654                 || (pBF = FindFilter(L"{52B63861-DC93-11CE-A099-00AA00479A58}", pGraph)) // 3ivx splitter
1655                 || (pBF = FindFilter(L"{6D3688CE-3E9D-42F4-92CA-8A11119D25CD}", pGraph)) // our ogg source
1656                 || (pBF = FindFilter(L"{9FF48807-E133-40AA-826F-9B2959E5232D}", pGraph)) // our ogg splitter
1657                 || (pBF = FindFilter(L"{803E8280-F3CE-4201-982C-8CD8FB512004}", pGraph)) // dsm source
1658                 || (pBF = FindFilter(L"{0912B4DD-A30A-4568-B590-7179EBB420EC}", pGraph)) // dsm splitter
1659                 || (pBF = FindFilter(L"{3CCC052E-BDEE-408a-BEA7-90914EF2964B}", pGraph)) // mp4 source
1660                 || (pBF = FindFilter(L"{61F47056-E400-43d3-AF1E-AB7DFFD4C4AD}", pGraph))) // mp4 splitter
1661                 {
1662                         BeginEnumPins(pBF, pEP, pPin)
1663                         {
1664                                 BeginEnumMediaTypes(pPin, pEM, pmt)
1665                                 {
1666                                         if(pmt->majortype == MEDIATYPE_Text || pmt->majortype == MEDIATYPE_Subtitle)
1667                                         {
1668                                                 fRet = true;
1669                                                 break;
1670                                         }
1671                                 }
1672                                 EndEnumMediaTypes(pmt)
1673                                 if(fRet) break;
1674                         }
1675                         EndEnumFilters
1676                 }
1677         }
1678
1679         // find file name
1680
1681         CStringW fn;
1682
1683         BeginEnumFilters(pGraph, pEF, pBF)
1684         {
1685                 if(CComQIPtr<IFileSourceFilter> pFSF = pBF)
1686                 {
1687                         LPOLESTR fnw = NULL;
1688                         if(!pFSF || FAILED(pFSF->GetCurFile(&fnw, NULL)) || !fnw)
1689                                 continue;
1690                         fn = CString(fnw);
1691                         CoTaskMemFree(fnw);
1692                         break;
1693                 }
1694         }
1695         EndEnumFilters
1696
1697         if((m_fExternalLoad || m_fWebLoad) && (m_fWebLoad || !(wcsstr(fn, L"http://") || wcsstr(fn, L"mms://"))))
1698         {
1699                 bool fTemp = m_fHideSubtitles;
1700                 fRet = !fn.IsEmpty() && SUCCEEDED(put_FileName((LPWSTR)(LPCWSTR)fn))
1701                         || SUCCEEDED(put_FileName(L"c:\\tmp.srt"))
1702                         || fRet;
1703                 if(fTemp) m_fHideSubtitles = true;
1704         }
1705
1706         return(fRet);
1707 }
1708
1709 void CDirectVobSubFilter2::GetRidOfInternalScriptRenderer()
1710 {
1711         while(CComPtr<IBaseFilter> pBF = FindFilter(L"{48025243-2D39-11CE-875D-00608CB78066}", m_pGraph))
1712         {
1713                 BeginEnumPins(pBF, pEP, pPin)
1714                 {
1715                         PIN_DIRECTION dir;
1716                         CComPtr<IPin> pPinTo;
1717
1718                         if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_INPUT
1719                         && SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
1720                         {
1721                                 m_pGraph->Disconnect(pPinTo);
1722                                 m_pGraph->Disconnect(pPin);
1723                                 m_pGraph->ConnectDirect(pPinTo, GetPin(2 + m_pTextInput.GetCount()-1), NULL);
1724                         }
1725                 }
1726                 EndEnumPins
1727
1728                 if(FAILED(m_pGraph->RemoveFilter(pBF)))
1729                         break;
1730         }
1731 }
1732
1733 ///////////////////////////////////////////////////////////////////////////////
1734
1735 bool CDirectVobSubFilter::Open()
1736 {
1737     AMTRACE((TEXT(__FUNCTION__),0));
1738     XY_AUTO_TIMING(TEXT("CDirectVobSubFilter::Open"));
1739
1740         AFX_MANAGE_STATE(AfxGetStaticModuleState());
1741
1742         CAutoLock cAutolock(&m_csQueueLock);
1743
1744         m_pSubStreams.RemoveAll();
1745
1746         m_frd.files.RemoveAll();
1747
1748         CAtlArray<CString> paths;
1749
1750         for(int i = 0; i < 10; i++)
1751         {
1752                 CString tmp;
1753                 tmp.Format(IDS_RP_PATH, i);
1754                 CString path = theApp.GetProfileString(ResStr(IDS_R_DEFTEXTPATHES), tmp);
1755                 if(!path.IsEmpty()) paths.Add(path);
1756         }
1757
1758         CAtlArray<SubFile> ret;
1759         GetSubFileNames(m_FileName, paths, ret);
1760
1761         for(int i = 0; i < ret.GetCount(); i++)
1762         {
1763                 if(m_frd.files.Find(ret[i].fn))
1764                         continue;
1765
1766                 CComPtr<ISubStream> pSubStream;
1767
1768         if(!pSubStream)
1769         {
1770 //            CAutoTiming t(TEXT("CRenderedTextSubtitle::Open"), 0);
1771             XY_AUTO_TIMING(TEXT("CRenderedTextSubtitle::Open"));
1772             CAutoPtr<CRenderedTextSubtitle> pRTS(new CRenderedTextSubtitle(&m_csSubLock));
1773             if(pRTS && pRTS->Open(ret[i].fn, DEFAULT_CHARSET) && pRTS->GetStreamCount() > 0)
1774             {
1775                 pSubStream = pRTS.Detach();
1776                 m_frd.files.AddTail(ret[i].fn + _T(".style"));
1777             }
1778         }
1779
1780                 if(!pSubStream)
1781                 {
1782             CAutoTiming t(TEXT("CVobSubFile::Open"), 0);
1783                         CAutoPtr<CVobSubFile> pVSF(new CVobSubFile(&m_csSubLock));
1784                         if(pVSF && pVSF->Open(ret[i].fn) && pVSF->GetStreamCount() > 0)
1785                         {
1786                                 pSubStream = pVSF.Detach();
1787                                 m_frd.files.AddTail(ret[i].fn.Left(ret[i].fn.GetLength()-4) + _T(".sub"));
1788                         }
1789                 }
1790
1791                 if(!pSubStream)
1792                 {
1793             CAutoTiming t(TEXT("ssf::CRenderer::Open"), 0);
1794                         CAutoPtr<ssf::CRenderer> pSSF(new ssf::CRenderer(&m_csSubLock));
1795                         if(pSSF && pSSF->Open(ret[i].fn) && pSSF->GetStreamCount() > 0)
1796                         {
1797                                 pSubStream = pSSF.Detach();
1798                         }
1799                 }
1800
1801                 if(pSubStream)
1802                 {
1803                         m_pSubStreams.AddTail(pSubStream);
1804                         m_frd.files.AddTail(ret[i].fn);
1805                 }
1806         }
1807
1808         for(int i = 0; i < m_pTextInput.GetCount(); i++)
1809         {
1810                 if(m_pTextInput[i]->IsConnected())
1811                         m_pSubStreams.AddTail(m_pTextInput[i]->GetSubStream());
1812         }
1813
1814         if(S_FALSE == put_SelectedLanguage(FindPreferedLanguage()))
1815         UpdateSubtitle(false); // make sure pSubPicProvider of our queue gets updated even if the stream number hasn't changed
1816
1817         m_frd.RefreshEvent.Set();
1818
1819         return(m_pSubStreams.GetCount() > 0);
1820 }
1821
1822 void CDirectVobSubFilter::UpdateSubtitle(bool fApplyDefStyle)
1823 {
1824         CAutoLock cAutolock(&m_csQueueLock);
1825
1826         if(!m_pSubPicQueue) return;
1827
1828         InvalidateSubtitle();
1829
1830         CComPtr<ISubStream> pSubStream;
1831
1832         if(!m_fHideSubtitles)
1833         {
1834                 int i = m_iSelectedLanguage;
1835
1836                 for(POSITION pos = m_pSubStreams.GetHeadPosition(); i >= 0 && pos; pSubStream = NULL)
1837                 {
1838                         pSubStream = m_pSubStreams.GetNext(pos);
1839
1840                         if(i < pSubStream->GetStreamCount())
1841                         {
1842                                 CAutoLock cAutoLock(&m_csSubLock);
1843                                 pSubStream->SetStream(i);
1844                                 break;
1845                         }
1846
1847                         i -= pSubStream->GetStreamCount();
1848                 }
1849         }
1850
1851         SetSubtitle(pSubStream, fApplyDefStyle);
1852 }
1853
1854 void CDirectVobSubFilter::SetSubtitle(ISubStream* pSubStream, bool fApplyDefStyle)
1855 {
1856         DbgLog((LOG_TRACE, 3, "%s(%d): %s", __FILE__, __LINE__, __FUNCTION__));
1857         DbgLog((LOG_TRACE, 3, "\tpSubStream:%x fApplyDefStyle:%d", pSubStream, (int)fApplyDefStyle));
1858     CAutoLock cAutolock(&m_csQueueLock);
1859
1860         if(pSubStream)
1861         {
1862                 CAutoLock cAutolock(&m_csSubLock);
1863
1864                 CLSID clsid;
1865                 pSubStream->GetClassID(&clsid);
1866
1867                 if(clsid == __uuidof(CVobSubFile))
1868                 {
1869                         CVobSubSettings* pVSS = dynamic_cast<CVobSubFile*>(pSubStream);
1870
1871                         if(fApplyDefStyle)
1872                         {
1873                                 pVSS->SetAlignment(m_fOverridePlacement, m_PlacementXperc, m_PlacementYperc, 1, 1);
1874                                 pVSS->m_fOnlyShowForcedSubs = m_fOnlyShowForcedVobSubs;
1875                         }
1876                 }
1877                 else if(clsid == __uuidof(CVobSubStream))
1878                 {
1879                         CVobSubSettings* pVSS = dynamic_cast<CVobSubStream*>(pSubStream);
1880
1881                         if(fApplyDefStyle)
1882                         {
1883                                 pVSS->SetAlignment(m_fOverridePlacement, m_PlacementXperc, m_PlacementYperc, 1, 1);
1884                                 pVSS->m_fOnlyShowForcedSubs = m_fOnlyShowForcedVobSubs;
1885                         }
1886                 }
1887                 else if(clsid == __uuidof(CRenderedTextSubtitle))
1888                 {
1889                         CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(pSubStream);
1890
1891                         if(fApplyDefStyle || pRTS->m_fUsingAutoGeneratedDefaultStyle)
1892                         {
1893                                 STSStyle s = m_defStyle;
1894
1895                                 if(m_fOverridePlacement)
1896                                 {
1897                                         s.scrAlignment = 2;
1898                                         int w = pRTS->m_dstScreenSize.cx;
1899                                         int h = pRTS->m_dstScreenSize.cy;
1900                     CRect tmp_rect = s.marginRect.get();
1901                                         int mw = w - tmp_rect.left - tmp_rect.right;
1902                                         tmp_rect.bottom = h - MulDiv(h, m_PlacementYperc, 100);
1903                                         tmp_rect.left = MulDiv(w, m_PlacementXperc, 100) - mw/2;
1904                                         tmp_rect.right = w - (tmp_rect.left + mw);
1905                     s.marginRect = tmp_rect;
1906                                 }
1907
1908                                 pRTS->SetDefaultStyle(s);
1909                         }
1910
1911                         pRTS->m_ePARCompensationType = m_ePARCompensationType;
1912                         if (m_CurrentVIH2.dwPictAspectRatioX != 0 && m_CurrentVIH2.dwPictAspectRatioY != 0&& m_CurrentVIH2.bmiHeader.biWidth != 0 && m_CurrentVIH2.bmiHeader.biHeight != 0)
1913                         {
1914                                 pRTS->m_dPARCompensation = ((double)abs(m_CurrentVIH2.bmiHeader.biWidth) / (double)abs(m_CurrentVIH2.bmiHeader.biHeight)) /
1915                                         ((double)abs((long)m_CurrentVIH2.dwPictAspectRatioX) / (double)abs((long)m_CurrentVIH2.dwPictAspectRatioY));
1916
1917                         }
1918                         else
1919                         {
1920                                 pRTS->m_dPARCompensation = 1.00;
1921                         }
1922
1923                         pRTS->Deinit();
1924                 }
1925         }
1926
1927         if(!fApplyDefStyle)
1928         {
1929                 int i = 0;
1930
1931                 POSITION pos = m_pSubStreams.GetHeadPosition();
1932                 while(pos)
1933                 {
1934                         CComPtr<ISubStream> pSubStream2 = m_pSubStreams.GetNext(pos);
1935
1936                         if(pSubStream == pSubStream2)
1937                         {
1938                                 m_iSelectedLanguage = i + pSubStream2->GetStream();
1939                                 break;
1940                         }
1941
1942                         i += pSubStream2->GetStreamCount();
1943                 }
1944         }
1945
1946         m_nSubtitleId = reinterpret_cast<DWORD_PTR>(pSubStream);
1947
1948         if(m_pSubPicQueue)
1949                 m_pSubPicQueue->SetSubPicProviderEx(CComQIPtr<ISubPicProviderEx>(pSubStream));
1950 }
1951
1952 void CDirectVobSubFilter::InvalidateSubtitle(REFERENCE_TIME rtInvalidate, DWORD_PTR nSubtitleId)
1953 {
1954     CAutoLock cAutolock(&m_csQueueLock);
1955
1956         if(m_pSubPicQueue)
1957         {
1958                 if(nSubtitleId == -1 || nSubtitleId == m_nSubtitleId)
1959                 {
1960                         DbgLog((LOG_TRACE, 3, "InvalidateSubtitle::Invalidate"));
1961                         m_pSubPicQueue->Invalidate(rtInvalidate);
1962                 }
1963         }
1964 }
1965
1966 //////////////////////////////////////////////////////////////////////////////////////////
1967
1968 void CDirectVobSubFilter::AddSubStream(ISubStream* pSubStream)
1969 {
1970         CAutoLock cAutoLock(&m_csQueueLock);
1971
1972         POSITION pos = m_pSubStreams.Find(pSubStream);
1973         if(!pos) m_pSubStreams.AddTail(pSubStream);
1974
1975         int len = m_pTextInput.GetCount();
1976         for(int i = 0; i < m_pTextInput.GetCount(); i++)
1977                 if(m_pTextInput[i]->IsConnected()) len--;
1978
1979         if(len == 0)
1980         {
1981                 HRESULT hr = S_OK;
1982                 m_pTextInput.Add(new CTextInputPin(this, m_pLock, &m_csSubLock, &hr));
1983         }
1984 }
1985
1986 void CDirectVobSubFilter::RemoveSubStream(ISubStream* pSubStream)
1987 {
1988         CAutoLock cAutoLock(&m_csQueueLock);
1989
1990         POSITION pos = m_pSubStreams.Find(pSubStream);
1991         if(pos) m_pSubStreams.RemoveAt(pos);
1992 }
1993
1994 void CDirectVobSubFilter::Post_EC_OLE_EVENT(CString str, DWORD_PTR nSubtitleId)
1995 {
1996         if(nSubtitleId != -1 && nSubtitleId != m_nSubtitleId)
1997                 return;
1998
1999         CComQIPtr<IMediaEventSink> pMES = m_pGraph;
2000         if(!pMES) return;
2001
2002         CComBSTR bstr1("Text"), bstr2(" ");
2003
2004         str.Trim();
2005         if(!str.IsEmpty()) bstr2 = CStringA(str);
2006
2007         pMES->Notify(EC_OLE_EVENT, (LONG_PTR)bstr1.Detach(), (LONG_PTR)bstr2.Detach());
2008 }
2009
2010 ////////////////////////////////////////////////////////////////
2011
2012 void CDirectVobSubFilter::SetupFRD(CStringArray& paths, CAtlArray<HANDLE>& handles)
2013 {
2014     CAutoLock cAutolock(&m_csSubLock);
2015
2016         for(int i = 2; i < handles.GetCount(); i++)
2017         {
2018                 FindCloseChangeNotification(handles[i]);
2019         }
2020
2021         paths.RemoveAll();
2022         handles.RemoveAll();
2023
2024         handles.Add(m_frd.EndThreadEvent);
2025         handles.Add(m_frd.RefreshEvent);
2026
2027         m_frd.mtime.SetCount(m_frd.files.GetCount());
2028
2029         POSITION pos = m_frd.files.GetHeadPosition();
2030         for(int i = 0; pos; i++)
2031         {
2032                 CString fn = m_frd.files.GetNext(pos);
2033
2034                 CFileStatus status;
2035                 if(CFileGetStatus(fn, status))
2036                         m_frd.mtime[i] = status.m_mtime;
2037
2038                 fn.Replace('\\', '/');
2039                 fn = fn.Left(fn.ReverseFind('/')+1);
2040
2041                 bool fFound = false;
2042
2043                 for(int j = 0; !fFound && j < paths.GetCount(); j++)
2044                 {
2045                         if(paths[j] == fn) fFound = true;
2046                 }
2047
2048                 if(!fFound)
2049                 {
2050                         paths.Add(fn);
2051
2052                         HANDLE h = FindFirstChangeNotification(fn, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE);
2053                         if(h != INVALID_HANDLE_VALUE) handles.Add(h);
2054                 }
2055         }
2056 }
2057
2058 DWORD CDirectVobSubFilter::ThreadProc()
2059 {
2060         SetThreadPriority(m_hThread, THREAD_PRIORITY_LOWEST/*THREAD_PRIORITY_BELOW_NORMAL*/);
2061
2062         CStringArray paths;
2063         CAtlArray<HANDLE> handles;
2064
2065         SetupFRD(paths, handles);
2066
2067         while(1)
2068         {
2069                 DWORD idx = WaitForMultipleObjects(handles.GetCount(), handles.GetData(), FALSE, INFINITE);
2070
2071                 if(idx == (WAIT_OBJECT_0 + 0)) // m_frd.hEndThreadEvent
2072                 {
2073                         break;
2074                 }
2075                 if(idx == (WAIT_OBJECT_0 + 1)) // m_frd.hRefreshEvent
2076                 {
2077                         SetupFRD(paths, handles);
2078                 }
2079                 else if(idx >= (WAIT_OBJECT_0 + 2) && idx < (WAIT_OBJECT_0 + handles.GetCount()))
2080                 {
2081                         bool fLocked = true;
2082                         IsSubtitleReloaderLocked(&fLocked);
2083                         if(fLocked) continue;
2084
2085                         if(FindNextChangeNotification(handles[idx - WAIT_OBJECT_0]) == FALSE)
2086                                 break;
2087
2088                         int j = 0;
2089
2090                         POSITION pos = m_frd.files.GetHeadPosition();
2091                         for(int i = 0; pos && j == 0; i++)
2092                         {
2093                                 CString fn = m_frd.files.GetNext(pos);
2094
2095                                 CFileStatus status;
2096                                 if(CFileGetStatus(fn, status) && m_frd.mtime[i] != status.m_mtime)
2097                                 {
2098                                         for(j = 0; j < 10; j++)
2099                                         {
2100                                                 if(FILE* f = _tfopen(fn, _T("rb+")))
2101                                                 {
2102                                                         fclose(f);
2103                                                         j = 0;
2104                                                         break;
2105                                                 }
2106                                                 else
2107                                                 {
2108                                                         Sleep(100);
2109                                                         j++;
2110                                                 }
2111                                         }
2112                                 }
2113                         }
2114
2115                         if(j > 0)
2116                         {
2117                                 SetupFRD(paths, handles);
2118                         }
2119                         else
2120                         {
2121                                 Sleep(500);
2122
2123                                 POSITION pos = m_frd.files.GetHeadPosition();
2124                                 for(int i = 0; pos; i++)
2125                                 {
2126                                         CFileStatus status;
2127                                         if(CFileGetStatus(m_frd.files.GetNext(pos), status)
2128                                                 && m_frd.mtime[i] != status.m_mtime)
2129                                         {
2130                                                 Open();
2131                                                 SetupFRD(paths, handles);
2132                                                 break;
2133                                         }
2134                                 }
2135                         }
2136                 }
2137                 else
2138                 {
2139                         break;
2140                 }
2141         }
2142
2143         for(int i = 2; i < handles.GetCount(); i++)
2144         {
2145                 FindCloseChangeNotification(handles[i]);
2146         }
2147
2148         return 0;
2149 }
2150
2151 void CDirectVobSubFilter::GetInputColorspaces( ColorSpaceId *preferredOrder, UINT *count )
2152 {
2153     ColorSpaceId colorspace[MAX_COLOR_SPACE_NUM];
2154     bool selected[MAX_COLOR_SPACE_NUM];
2155     UINT tempCount;
2156     if( get_InputColorFormat(colorspace, selected, &tempCount)==S_OK )
2157     {
2158         *count = 0;
2159         for (int i=0;i<tempCount;i++)
2160         {
2161             if(selected[i])
2162             {
2163                 preferredOrder[*count] = colorspace[i];
2164                 (*count)++;
2165             }
2166         }
2167     }
2168     else
2169     {
2170         CBaseVideoFilter::GetInputColorspaces(preferredOrder, count);
2171     }
2172 }
2173
2174 void CDirectVobSubFilter::GetOutputColorspaces( ColorSpaceId *preferredOrder, UINT *count )
2175 {
2176     ColorSpaceId colorspace[MAX_COLOR_SPACE_NUM];
2177     bool selected[MAX_COLOR_SPACE_NUM];
2178     UINT tempCount;
2179     if( get_OutputColorFormat(colorspace, selected, &tempCount)==S_OK )
2180     {
2181         *count = 0;
2182         for (int i=0;i<tempCount;i++)
2183         {
2184             if(selected[i])
2185             {
2186                 preferredOrder[*count] = colorspace[i];
2187                 (*count)++;
2188             }
2189         }
2190     }
2191     else
2192     {
2193         CBaseVideoFilter::GetInputColorspaces(preferredOrder, count);
2194     }
2195 }