src/subpic/SubPicQueueImpl.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 "SubPicQueueImpl.h"
  24 #include "../DSUtil/DSUtil.h"
  25 #include "CRect2.h"
  26
  27 #include "SubPicProviderExWrapper.h"
  28 #include "SimpleSubPicWrapper.h"
  29
  30 #define CSUBPICQUEUE_THREAD_PROC_WAIT_TIMEOUT   20
  31 #define CSUBPICQUEUE_LOOKUP_WAIT_TIMEOUT                40
  32 #define CSUBPICQUEUE_UPDATEQUEUE_WAIT_TIMEOUT   100
  33
  34 //
  35 // CSubPicQueueImpl
  36 //
  37
  38 CSubPicQueueImpl::CSubPicQueueImpl(ISubPicExAllocator* pAllocator, HRESULT* phr, const int *prefered_colortype/*=NULL*/, int prefered_colortype_num/*=0*/)
  39         : CUnknown(NAME("CSubPicQueueImpl"), NULL)
  40         , m_pAllocator(pAllocator)
  41         , m_rtNow(0)
  42         , m_rtNowLast(0)
  43         , m_fps(25.0)
  44 {
  45         if(phr) {
  46                 *phr = S_OK;
  47         }
  48
  49         if(!m_pAllocator) {
  50                 if(phr) {
  51                         *phr = E_FAIL;
  52                 }
  53                 return;
  54         }
  55     for (int i=0;i<prefered_colortype_num;i++)
  56     {
  57         m_prefered_colortype.AddTail(prefered_colortype[i]);
  58     }
  59     if(m_prefered_colortype.IsEmpty())
  60     {
  61         m_prefered_colortype.AddTail(MSP_AYUV_PLANAR);
  62         m_prefered_colortype.AddTail(MSP_AYUV);
  63         m_prefered_colortype.AddTail(MSP_XY_AUYV);
  64         m_prefered_colortype.AddTail(MSP_RGBA);
  65     }
  66 }
  67
  68 CSubPicQueueImpl::~CSubPicQueueImpl()
  69 {
  70 }
  71
  72 STDMETHODIMP CSubPicQueueImpl::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  73 {
  74         return
  75                 QI(ISubPicQueue)
  76         QI(ISimpleSubPicProvider)
  77                 __super::NonDelegatingQueryInterface(riid, ppv);
  78 }
  79
  80 // ISubPicQueue
  81
  82 STDMETHODIMP CSubPicQueueImpl::SetSubPicProvider(ISubPicProvider* pSubPicProvider)
  83 {
  84     return SetSubPicProviderEx( CSubPicProviderExWrapper::GetSubPicProviderExWrapper(pSubPicProvider) );
  85 }
  86
  87 STDMETHODIMP CSubPicQueueImpl::GetSubPicProvider(ISubPicProvider** pSubPicProvider)
  88 {
  89         if(!pSubPicProvider) {
  90                 return E_POINTER;
  91         }
  92
  93         CAutoLock cAutoLock(&m_csSubPicProvider);
  94
  95         if(m_pSubPicProviderEx) {
  96                 *pSubPicProvider = m_pSubPicProviderEx;
  97                 (*pSubPicProvider)->AddRef();
  98         }
  99
 100         return !!*pSubPicProvider ? S_OK : E_FAIL;
 101 }
 102
 103 STDMETHODIMP CSubPicQueueImpl::SetFPS(double fps)
 104 {
 105         m_fps = fps;
 106
 107         return S_OK;
 108 }
 109
 110 STDMETHODIMP CSubPicQueueImpl::SetTime(REFERENCE_TIME rtNow)
 111 {
 112         m_rtNow = rtNow;
 113
 114         return S_OK;
 115 }
 116
 117 // ISubPicQueueEx
 118
 119 STDMETHODIMP CSubPicQueueImpl::SetSubPicProvider( IUnknown* subpic_provider )
 120 {
 121     CComQIPtr<ISubPicProviderEx> tmp = subpic_provider;
 122     if (tmp)
 123     {
 124         return SetSubPicProviderEx(tmp);
 125     }
 126     else
 127     {
 128         CComQIPtr<ISubPicProvider> tmp2 = subpic_provider;
 129         if (tmp2)
 130         {
 131             return SetSubPicProvider(tmp);
 132         }
 133     }
 134     return E_NOTIMPL;
 135 }
 136
 137 STDMETHODIMP CSubPicQueueImpl::GetSubPicProvider( IUnknown** subpic_provider )
 138 {
 139     if(!subpic_provider) {
 140         return E_POINTER;
 141     }
 142
 143     CAutoLock cAutoLock(&m_csSubPicProvider);
 144
 145     if(m_pSubPicProviderEx) {
 146         *subpic_provider = m_pSubPicProviderEx;
 147         (*subpic_provider)->AddRef();
 148     }
 149
 150     return !!*subpic_provider ? S_OK : E_FAIL;
 151 }
 152
 153 // private
 154
 155 HRESULT CSubPicQueueImpl::SetSubPicProviderEx( ISubPicProviderEx* pSubPicProviderEx )
 156 {
 157     //  if(m_pSubPicProvider != pSubPicProvider)
 158     {
 159         CAutoLock cAutoLock(&m_csSubPicProvider);
 160         m_pSubPicProviderEx = pSubPicProviderEx;
 161
 162         if(m_pSubPicProviderEx!=NULL && m_pAllocator!=NULL)
 163         {
 164             POSITION pos = m_prefered_colortype.GetHeadPosition();
 165             while(pos!=NULL)
 166             {
 167                 int color_type = m_prefered_colortype.GetNext(pos);
 168                 if( m_pSubPicProviderEx->IsColorTypeSupported( color_type ) &&
 169                     m_pAllocator->IsSpdColorTypeSupported( color_type ) )
 170                 {
 171                     m_pAllocator->SetSpdColorType(color_type);
 172                     break;
 173                 }
 174             }
 175         }
 176     }
 177     Invalidate();
 178
 179     return S_OK;
 180 }
 181
 182 HRESULT CSubPicQueueImpl::GetSubPicProviderEx( ISubPicProviderEx** pSubPicProviderEx )
 183 {
 184     if(!pSubPicProviderEx) {
 185         return E_POINTER;
 186     }
 187
 188     CAutoLock cAutoLock(&m_csSubPicProvider);
 189
 190     if(m_pSubPicProviderEx) {
 191         *pSubPicProviderEx = m_pSubPicProviderEx;
 192         (*pSubPicProviderEx)->AddRef();
 193     }
 194
 195     return !!*pSubPicProviderEx ? S_OK : E_FAIL;
 196 }
 197
 198 HRESULT CSubPicQueueImpl::RenderTo(ISubPicEx* pSubPic, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double fps, BOOL bIsAnimated)
 199 {
 200         HRESULT hr = E_FAIL;
 201
 202         if(!pSubPic) {
 203                 return hr;
 204         }
 205
 206         CComPtr<ISubPicProviderEx> pSubPicProviderEx;
 207         if(FAILED(GetSubPicProviderEx(&pSubPicProviderEx)) || !pSubPicProviderEx) {
 208                 return hr;
 209     }
 210
 211         if(FAILED(pSubPicProviderEx->Lock())) {
 212                 return hr;
 213         }
 214
 215         SubPicDesc spd;
 216         if(SUCCEEDED(pSubPic->Lock(spd)))
 217         {
 218                 DWORD color = 0xFF000000;
 219 //              if(spd.type == MSP_YUY2 || spd.type == MSP_YV12 || spd.type == MSP_IYUV)
 220 //              {
 221 //                      color = 0xFF801080;
 222 //                      //color = 0xFF000000;
 223 //              }
 224 //              else if(spd.type == MSP_AYUV)
 225 //              {
 226 //                      color = 0xFF108080;
 227 //              }
 228 //              else
 229 //              {
 230 //                      color = 0xFF000000;
 231 //              }
 232                 if(SUCCEEDED(pSubPic->ClearDirtyRect(color)))
 233                 {
 234                         CAtlList<CRect> rectList;
 235
 236                         hr = pSubPicProviderEx->RenderEx(spd, bIsAnimated ? rtStart : ((rtStart+rtStop)/2), fps, rectList);
 237
 238                         DbgLog((LOG_TRACE, 3, "CSubPicQueueImpl::RenderTo => GetStartPosition"));
 239                         POSITION pos = pSubPicProviderEx->GetStartPosition(rtStart, fps);
 240
 241                         DbgLog((LOG_TRACE, 3, "CSubPicQueueImpl::RenderTo => GetStartStop rtStart:%lu", (ULONG)rtStart/10000));
 242                         pSubPicProviderEx->GetStartStop(pos, fps, rtStart, rtStop);
 243                         DbgLog((LOG_TRACE, 3, "rtStart:%lu", (ULONG)rtStart/10000));
 244
 245                         //DbgLog((LOG_TRACE, 3, TEXT("rtStart=%lu rtStop=%lu pos:%x fps:%f"), (ULONG)rtStart/10000, (ULONG)rtStop/10000, pos, fps));
 246
 247                         pSubPic->SetStart(rtStart);
 248                         pSubPic->SetStop(rtStop);
 249
 250                         pSubPic->Unlock(&rectList);
 251                 }
 252         }
 253
 254         pSubPicProviderEx->Unlock();
 255
 256         return hr;
 257 }
 258
 259 //
 260 // CSubPicQueue
 261 //
 262
 263 CSubPicQueue::CSubPicQueue(int nMaxSubPic, BOOL bDisableAnim, ISubPicExAllocator* pAllocator, HRESULT* phr)
 264         : CSubPicQueueImpl(pAllocator, phr)
 265         , m_nMaxSubPic(nMaxSubPic)
 266         , m_bDisableAnim(bDisableAnim)
 267         , m_rtQueueStart(0)
 268 {
 269         //InitTracer;
 270         DbgLog((LOG_TRACE, 3, "CSubPicQueue::CSubPicQueue"));
 271         //Trace(_T("SubPicQueue constructing\n"));
 272
 273         if(phr && FAILED(*phr))
 274                 return;
 275
 276         if(m_nMaxSubPic < 1)
 277                 {if(phr) *phr = E_INVALIDARG; return;}
 278
 279         m_fBreakBuffering = false;
 280         for(int i = 0; i < EVENT_COUNT; i++)
 281                 m_ThreadEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
 282         for(int i=0;i<QueueEvents_COUNT; i++)
 283                 m_QueueEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
 284         if(m_nMaxSubPic > 0)
 285         {
 286                 SetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 287         }
 288
 289
 290         //m_subPos = NULL;
 291
 292         CAMThread::Create();
 293 }
 294
 295 CSubPicQueue::~CSubPicQueue()
 296 {
 297         m_fBreakBuffering = true;
 298         //SetEvent(m_ThreadEvents[EVENT_EXIT]);
 299         CAMThread::CallWorker(EVENT_EXIT);
 300         CAMThread::Close();
 301         for(int i=0;i<QueueEvents_COUNT; i++)
 302                 CloseHandle(m_QueueEvents[i]);
 303         for(int i = 0; i < EVENT_COUNT; i++)
 304                 CloseHandle(m_ThreadEvents[i]);
 305         DbgLog((LOG_TRACE, 3, "CSubPicQueue::~CSubPicQueue"));
 306         //ReleaseTracer;
 307 }
 308
 309 // ISubPicQueue
 310
 311 STDMETHODIMP CSubPicQueue::SetFPS(double fps)
 312 {
 313         HRESULT hr = __super::SetFPS(fps);
 314         if(FAILED(hr)) return hr;
 315
 316         //SetEvent(m_ThreadEvents[EVENT_TIME]);
 317         //CallWorker(EVENT_TIME);
 318         UpdateQueue();
 319
 320         return S_OK;
 321 }
 322
 323 STDMETHODIMP CSubPicQueue::SetTime(REFERENCE_TIME rtNow)
 324 {
 325         HRESULT hr = __super::SetTime(rtNow);
 326         if(FAILED(hr)) return hr;
 327
 328         //SetEvent(m_ThreadEvents[EVENT_TIME]);
 329         //DbgLog((LOG_LOCKING, 3, "SetTime::CallWorker(EVENT_TIME)"));
 330         //CallWorker(EVENT_TIME);
 331         UpdateQueue();
 332
 333         return S_OK;
 334 }
 335
 336 STDMETHODIMP CSubPicQueue::Invalidate(REFERENCE_TIME rtInvalidate)
 337 {
 338         {
 339 //              CAutoLock cQueueLock(&m_csQueueLock);
 340 //              RemoveAll();
 341
 342                 m_rtInvalidate = rtInvalidate;
 343                 m_fBreakBuffering = true;
 344                 UpdateQueue();
 345         }
 346
 347         return S_OK;
 348 }
 349
 350 STDMETHODIMP_(bool) CSubPicQueue::LookupSubPic(REFERENCE_TIME rtNow, ISubPic** ppSubPic)
 351 {
 352     CComPtr<ISubPicProvider> pSubPicProvider;
 353     double fps = m_fps;
 354     *ppSubPic = NULL;
 355     //if(SUCCEEDED(GetSubPicProvider(&pSubPicProvider)) && pSubPicProvider)
 356     {
 357         //      if(pSubPicProvider->GetStartPosition(rtNow, fps))
 358         {
 359             CAutoLock cQueueLock(&m_csQueueLock);
 360             int count = m_Queue.GetCount();
 361             if(count>0)
 362                 if(WaitForSingleObject(m_QueueEvents[QueueEvents_NOTEMPTY], CSUBPICQUEUE_LOOKUP_WAIT_TIMEOUT)==WAIT_OBJECT_0)
 363                 {
 364                     POSITION pos = m_Queue.GetHeadPosition();
 365                     while(pos)
 366                     {
 367                         CComPtr<ISubPic> pSubPic = m_Queue.GetNext(pos);
 368                         //DbgLog((LOG_TRACE, 3, "picStart:%lu picStop:%lu rtNow:%lu", (ULONG)pSubPic->GetStart()/10000, (ULONG)pSubPic->GetStop()/10000, (ULONG)rtNow/10000));
 369                         if(pSubPic->GetStart() > rtNow)
 370                             break;
 371                         else if(rtNow < pSubPic->GetStop())
 372                         {
 373                             *ppSubPic = pSubPic.Detach();
 374                             break;
 375                         }
 376                     }
 377                     int count = m_Queue.GetCount();
 378                     if(count>0)
 379                         SetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 380                     else//important
 381                         ResetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 382                     if(count<m_nMaxSubPic)
 383                         SetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 384                     else//important
 385                         ResetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 386
 387                     //DbgLog((LOG_TRACE, 3, "CSubPicQueue LookupSubPic return"));
 388                 }
 389         }
 390     }
 391
 392     return(!!*ppSubPic);
 393 }
 394
 395 STDMETHODIMP_(bool) CSubPicQueue::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic/*[out]*/ )
 396 {
 397     //ToDo: fix me
 398     return false;
 399 }
 400
 401 STDMETHODIMP CSubPicQueue::GetStats(int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop)
 402 {
 403         CAutoLock cQueueLock(&m_csQueueLock);
 404
 405         nSubPics = m_Queue.GetCount();
 406         rtNow = m_rtNow;
 407         rtStart = m_rtQueueStart;
 408         rtStop = m_Queue.GetCount() > 0 ? m_Queue.GetTail()->GetStop() : rtStart;
 409
 410         return S_OK;
 411 }
 412
 413 STDMETHODIMP CSubPicQueue::GetStats(int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop)
 414 {
 415         CAutoLock cQueueLock(&m_csQueueLock);
 416
 417         rtStart = rtStop = -1;
 418
 419         if(nSubPic >= 0 && nSubPic < (int)m_Queue.GetCount())
 420         {
 421                 if(POSITION pos = m_Queue.FindIndex(nSubPic))
 422                 {
 423                         rtStart = m_Queue.GetAt(pos)->GetStart();
 424                         rtStop = m_Queue.GetAt(pos)->GetStop();
 425                 }
 426         }
 427         else
 428         {
 429                 return E_INVALIDARG;
 430         }
 431
 432         return S_OK;
 433 }
 434
 435 // private
 436
 437 REFERENCE_TIME CSubPicQueue::UpdateQueue()
 438 {
 439         //DbgLog((LOG_TRACE, 3, "CSubPicQueue UpdateQueue"));
 440         REFERENCE_TIME rtNow=0;
 441
 442
 443         //if(WaitForMultipleObjects(QueueEvents_COUNT, m_QueueEvents, true, CSUBPICQUEUE_UPDATEQUEUE_WAIT_TIMEOUT))
 444         {
 445                 CAutoLock cQueueLock(&m_csQueueLock);
 446                 rtNow = m_rtNow;
 447                 int count = m_Queue.GetCount();
 448                 if(rtNow < m_rtQueueStart)
 449                 {
 450                         m_Queue.RemoveAll();
 451                         count = 0;
 452                 }
 453                 else
 454                 {
 455                         while(count>0 && rtNow >= m_Queue.GetHead()->GetStop())
 456                         {
 457                                 m_Queue.RemoveHead();
 458                                 count--;
 459                         }
 460                 }
 461                 if(count>0)
 462                         rtNow = m_Queue.GetTail()->GetStop();
 463                 m_rtQueueStart = m_rtNow;
 464                 if(count>0)
 465                         SetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 466                 else//important
 467                         ResetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 468                 if(count<m_nMaxSubPic)
 469                         SetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 470                 else//important
 471                         ResetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 472         }
 473         return(rtNow);
 474 }
 475
 476 int CSubPicQueue::GetQueueCount()
 477 {
 478         CAutoLock cQueueLock(&m_csQueueLock);
 479
 480         return m_Queue.GetCount();
 481 }
 482 void CSubPicQueue::AppendQueue(ISubPic* pSubPic)
 483 {
 484         CAutoLock cQueueLock(&m_csQueueLock);
 485
 486         m_Queue.AddTail(pSubPic);
 487 }
 488
 489 // overrides
 490
 491 DWORD CSubPicQueue::ThreadProc()
 492 {
 493         BOOL bDisableAnim = m_bDisableAnim;
 494         SetThreadPriority(m_hThread, bDisableAnim ? THREAD_PRIORITY_LOWEST : THREAD_PRIORITY_ABOVE_NORMAL/*THREAD_PRIORITY_BELOW_NORMAL*/);
 495
 496         //Trace(_T("CSubPicQueue Thread Start\n"));
 497         DbgLog((LOG_TRACE, 3, "CSubPicQueue Thread Start"));
 498         //while((WaitForMultipleObjects(EVENT_COUNT, m_ThreadEvents, FALSE, INFINITE) - WAIT_OBJECT_0) == EVENT_TIME)
 499         DWORD request;
 500         while(true)
 501         {
 502                 if(CheckRequest(&request))
 503                 {
 504                         if(request==EVENT_EXIT)
 505                                 break;
 506
 507                 }
 508                 if(WaitForSingleObject(m_QueueEvents[QueueEvents_NOTFULL], CSUBPICQUEUE_THREAD_PROC_WAIT_TIMEOUT)!=WAIT_OBJECT_0)
 509                         continue;
 510
 511                 bool failed = true;
 512                 bool reachEnd = false;
 513                 CComPtr<ISubPicEx> pSubPic;
 514                 CComPtr<ISubPicEx> pStatic;
 515                 CComPtr<ISubPicProviderEx> pSubPicProviderEx;
 516
 517                 double fps = m_fps;
 518                 int nMaxSubPic = m_nMaxSubPic;
 519
 520                 m_csQueueLock.Lock();
 521                 REFERENCE_TIME rtNow = 0;
 522                 if(m_Queue.GetCount()>0)
 523                         rtNow = m_Queue.GetTail()->GetStop();
 524                 if(rtNow < m_rtNow)
 525                         rtNow = m_rtNow;
 526                 CComPtr<ISubPicExAllocator> pAllocator = m_pAllocator;
 527                 m_csQueueLock.Unlock();
 528
 529                 //for(int i=0;i<1;i++)
 530                 {
 531                         if(FAILED(pAllocator->AllocDynamicEx(&pSubPic))
 532                                 || (pAllocator->IsDynamicWriteOnly() && FAILED(pAllocator->GetStaticEx(&pStatic))))
 533                                 break;
 534
 535                         if(SUCCEEDED(GetSubPicProviderEx(&pSubPicProviderEx)) && pSubPicProviderEx
 536                                 && SUCCEEDED(pSubPicProviderEx->Lock()))
 537                         {
 538                                 REFERENCE_TIME rtStart, rtStop;
 539
 540                                 //DbgLog((LOG_TRACE, 3, "CSubPicQueue::ThreadProc => GetStartPosition"));
 541                                 POSITION pos = pSubPicProviderEx->GetStartPosition(rtNow, fps);
 542
 543                                 //DbgLog((LOG_TRACE, 3, "pos:%x, m_fBreakBuffering:%d GetCount():%d nMaxSubPic:%d", pos, m_fBreakBuffering, GetCount(), nMaxSubPic));
 544
 545                                 if(pos!=NULL)//!m_fBreakBuffering
 546                                 {
 547                                         reachEnd = false;
 548                                         ASSERT(m_Queue.GetCount() < (size_t)nMaxSubPic);
 549
 550                                         //DbgLog((LOG_TRACE, 3, "CSubPicQueue::ThreadProc => GetStartStop"));
 551                                         pSubPicProviderEx->GetStartStop(pos, fps, rtStart, rtStop);
 552
 553                                         //DbgLog((LOG_TRACE, 3, "rtStart=%lu rtStop=%lu fps=%f rtNow=%lu m_rtNow=%lu", (ULONG)rtStart/10000, (ULONG)rtStop/10000,
 554                                         //      fps, (ULONG)rtNow/10000, (ULONG)m_rtNow/10000));
 555
 556                                         if(m_rtNow >= rtStop)
 557                                                 break;
 558                                         //if(rtStart >= m_rtNow + 60*10000000i64) // we are already one minute ahead, this should be enough
 559                                         //      break;
 560
 561                                         if(rtNow < rtStop)
 562                                         {
 563                         bool bIsAnimated = pSubPicProviderEx->IsAnimated(pos) && !bDisableAnim;
 564                                                 if(pAllocator->IsDynamicWriteOnly())
 565                                                         //if(true)
 566                                                 {
 567                                                         HRESULT hr = RenderTo(pStatic, rtStart, rtStop, fps, bIsAnimated);
 568                                                         if(FAILED(hr)
 569                                                                 || S_OK != hr// subpic was probably empty
 570                                                                 || FAILED(pStatic->CopyTo(pSubPic))
 571                                                                 )
 572                                                                 break;
 573                                                 }
 574                                                 else
 575                                                 {
 576                                                         HRESULT hr = RenderTo(pSubPic, rtStart, rtStop, fps, bIsAnimated);
 577                                                         if(FAILED(hr)
 578                                                                 || S_OK != hr// subpic was probably empty
 579                                                                 )
 580                                                                 break;
 581                                                 }
 582                                                 /*DbgLog((LOG_TRACE, 3, "picStart:%lu picStop:%lu seg:%d idx:%d pos:%x",
 583                                                         (ULONG)pSubPic->GetStart()/10000,
 584                                                         (ULONG)pSubPic->GetStop()/10000,
 585                                                         (int)pos >> 16, (int)pos & ((1<<16)-1)));*/
 586                                                 failed = false;
 587                                         }
 588                                 }
 589                                 else
 590                                         reachEnd = true;
 591                                 pSubPicProviderEx->Unlock();
 592                                 pSubPicProviderEx = NULL;
 593                         }
 594                 }
 595
 596                 m_csQueueLock.Lock();
 597                 if(!failed)
 598                         m_Queue.AddTail(pSubPic);
 599                 int count = m_Queue.GetCount();
 600                 if(count>0)
 601                         SetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 602                 else//important
 603                         ResetEvent(m_QueueEvents[QueueEvents_NOTEMPTY]);
 604                 if(count<m_nMaxSubPic)
 605                         SetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 606                 else//important
 607                         ResetEvent(m_QueueEvents[QueueEvents_NOTFULL]);
 608                 m_csQueueLock.Unlock();
 609
 610                 if(reachEnd)
 611                     Sleep(CSUBPICQUEUE_THREAD_PROC_WAIT_TIMEOUT);
 612
 613                 //if(failed)
 614                 //{
 615                 //      if(pSubPicProvider!=NULL)
 616                 //              pSubPicProvider->Unlock();
 617                 //      ReleaseSemaphore(m_semNotFull, 1, NULL);
 618                 //}
 619                 //else
 620                 //      ReleaseSemaphore(m_semNotEmpty, 1, NULL);
 621
 622                 //DbgLog((LOG_LOCKING, 3, "ReleaseMutex m_mtxResetNotFull"));
 623                 //ReleaseMutex(m_mtxResetNotFull);
 624         }
 625
 626         //Trace(_T("CSubPicQueue Thread Return\n"));
 627         DbgLog((LOG_TRACE, 3, "CSubPicQueue Thread Return"));
 628         Reply(EVENT_EXIT);
 629         return(0);
 630 }
 631
 632 //
 633 // CSubPicQueueNoThread
 634 //
 635
 636 CSubPicQueueNoThread::CSubPicQueueNoThread(ISubPicExAllocator* pAllocator, HRESULT* phr, const int *prefered_colortype/*=NULL*/, int prefered_colortype_num/*=0*/)
 637         : CSubPicQueueImpl(pAllocator, phr, prefered_colortype, prefered_colortype_num)
 638 {
 639 }
 640
 641 CSubPicQueueNoThread::~CSubPicQueueNoThread()
 642 {
 643 }
 644
 645 // ISubPicQueue
 646
 647 STDMETHODIMP CSubPicQueueNoThread::Invalidate(REFERENCE_TIME rtInvalidate)
 648 {
 649         CAutoLock cQueueLock(&m_csLock);
 650
 651     if( m_pSubPic && m_pSubPic->GetStop() >= rtInvalidate)
 652     {
 653             m_pSubPic = NULL;
 654     }
 655         return S_OK;
 656 }
 657
 658 STDMETHODIMP_(bool) CSubPicQueueNoThread::LookupSubPic(REFERENCE_TIME rtNow, ISubPic** ppSubPic)
 659 {
 660     if(ppSubPic!=NULL)
 661     {
 662         ISubPicEx* temp;
 663         bool result = LookupSubPicEx(rtNow, &temp);
 664         *ppSubPic = temp;
 665         return result;
 666     }
 667     else
 668     {
 669         return LookupSubPicEx(rtNow, NULL);
 670     }
 671 }
 672
 673 STDMETHODIMP_(bool) CSubPicQueueNoThread::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic /*[out]*/ )
 674 {
 675     if(output_subpic!=NULL)
 676     {
 677         CComPtr<ISubPicEx> temp;
 678         bool result = LookupSubPicEx(now, &temp);
 679         (*output_subpic = new SimpleSubPicWrapper(temp))->AddRef();
 680         return result;
 681     }
 682     else
 683     {
 684         return LookupSubPicEx(now, NULL);
 685     }
 686 }
 687
 688
 689 bool CSubPicQueueNoThread::LookupSubPicEx(REFERENCE_TIME rtNow, ISubPicEx** ppSubPic)
 690 {
 691     if(!ppSubPic)
 692         return(false);
 693
 694     *ppSubPic = NULL;
 695
 696     CComPtr<ISubPicEx> pSubPic;
 697
 698     {
 699         CAutoLock cAutoLock(&m_csLock);
 700
 701         if(!m_pSubPic)
 702         {
 703             if(FAILED(m_pAllocator->AllocDynamicEx(&m_pSubPic))) {
 704                 return false;
 705             }
 706         }
 707
 708         pSubPic = m_pSubPic;
 709     }
 710
 711     if(pSubPic->GetStart() <= rtNow && rtNow < pSubPic->GetStop())
 712     {
 713         (*ppSubPic = pSubPic)->AddRef();
 714     }
 715     else
 716     {
 717         CComPtr<ISubPicProvider> pSubPicProvider;
 718         if(SUCCEEDED(GetSubPicProvider(&pSubPicProvider)) && pSubPicProvider
 719             && SUCCEEDED(pSubPicProvider->Lock()))
 720         {
 721             double fps = m_fps;
 722
 723             if(POSITION pos = pSubPicProvider->GetStartPosition(rtNow, fps))
 724             {
 725                 REFERENCE_TIME rtStart = pSubPicProvider->GetStart(pos, fps);
 726                 REFERENCE_TIME rtStop = pSubPicProvider->GetStop(pos, fps);
 727
 728                 if(rtStart <= rtNow && rtNow < rtStop)
 729                 {
 730                     SIZE        MaxTextureSize, VirtualSize;
 731                     POINT       VirtualTopLeft;
 732                     HRESULT     hr2;
 733                     if (SUCCEEDED (hr2 = pSubPicProvider->GetTextureSize(pos, MaxTextureSize, VirtualSize, VirtualTopLeft))) {
 734                         m_pAllocator->SetMaxTextureSize(MaxTextureSize);
 735                     }
 736                     if(m_pAllocator->IsDynamicWriteOnly())
 737                     {
 738                         CComPtr<ISubPicEx> pStatic;
 739                         if(SUCCEEDED(m_pAllocator->GetStaticEx(&pStatic))
 740                             && SUCCEEDED(RenderTo(pStatic, rtNow, rtNow+1, fps, true))
 741                             && SUCCEEDED(pStatic->CopyTo(pSubPic)))
 742                             (*ppSubPic = pSubPic)->AddRef();
 743                     }
 744                     else
 745                     {
 746                         if(SUCCEEDED(RenderTo(m_pSubPic, rtNow, rtNow+1, fps, true)))
 747                             (*ppSubPic = pSubPic)->AddRef();
 748                     }
 749                 }
 750             }
 751
 752             pSubPicProvider->Unlock();
 753
 754             if(*ppSubPic)
 755             {
 756                 CAutoLock cAutoLock(&m_csLock);
 757
 758                 m_pSubPic = *ppSubPic;
 759             }
 760         }
 761     }
 762     return(!!*ppSubPic);
 763 }
 764
 765 STDMETHODIMP CSubPicQueueNoThread::GetStats(int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop)
 766 {
 767         CAutoLock cAutoLock(&m_csLock);
 768
 769         nSubPics = 0;
 770         rtNow = m_rtNow;
 771         rtStart = rtStop = 0;
 772
 773         if(m_pSubPic)
 774         {
 775                 nSubPics = 1;
 776                 rtStart = m_pSubPic->GetStart();
 777                 rtStop = m_pSubPic->GetStop();
 778         }
 779
 780         return S_OK;
 781 }
 782
 783 STDMETHODIMP CSubPicQueueNoThread::GetStats(int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop)
 784 {
 785         CAutoLock cAutoLock(&m_csLock);
 786
 787         if(!m_pSubPic || nSubPic != 0)
 788                 return E_INVALIDARG;
 789
 790         rtStart = m_pSubPic->GetStart();
 791         rtStop = m_pSubPic->GetStop();
 792
 793         return S_OK;
 794 }