src/subpic/SimpleSubPicProviderImpl.cpp

   1 #include "stdafx.h"
   2 #include "SimpleSubPicProviderImpl.h"
   3 #include "SimpleSubPicWrapper.h"
   4 #include "../subtitles/xy_bitmap.h"
   5 #include "SimpleSubpicImpl.h"
   6 #include "PooledSubPic.h"
   7 #include "IDirectVobSubXy.h"
   8
   9 //////////////////////////////////////////////////////////////////////////
  10 //
  11 // SimpleSubPicProvider
  12 //
  13
  14
  15 SimpleSubPicProvider::SimpleSubPicProvider( int alpha_blt_dst_type, SIZE spd_size, RECT video_rect, IDirectVobSubXy *consumer
  16     , HRESULT* phr/*=NULL*/ )
  17     : CUnknown(NAME("CSubPicQueueImpl"), NULL)
  18     , m_alpha_blt_dst_type(alpha_blt_dst_type)
  19     , m_spd_size(spd_size)
  20     , m_video_rect(video_rect)
  21     , m_rtNow(0)
  22     , m_fps(25.0)
  23     , m_consumer(consumer)
  24 {
  25     if(phr) {
  26         *phr = consumer ? S_OK : E_INVALIDARG;
  27     }
  28
  29     m_prefered_colortype.AddTail(MSP_AYUV_PLANAR);
  30     m_prefered_colortype.AddTail(MSP_AYUV);
  31     m_prefered_colortype.AddTail(MSP_XY_AUYV);
  32     m_prefered_colortype.AddTail(MSP_RGBA);
  33 }
  34
  35 SimpleSubPicProvider::~SimpleSubPicProvider()
  36 {
  37
  38 }
  39
  40 STDMETHODIMP SimpleSubPicProvider::NonDelegatingQueryInterface( REFIID riid, void** ppv )
  41 {
  42     return
  43         QI(ISimpleSubPicProvider)
  44         __super::NonDelegatingQueryInterface(riid, ppv);
  45 }
  46
  47 STDMETHODIMP SimpleSubPicProvider::SetSubPicProvider( IUnknown* subpic_provider )
  48 {
  49     if (subpic_provider!=NULL)
  50     {
  51         CComQIPtr<ISubPicProviderEx2> tmp = subpic_provider;
  52         if (tmp)
  53         {
  54             CAutoLock cAutoLock(&m_csSubPicProvider);
  55             m_pSubPicProviderEx = tmp;
  56
  57             if(m_pSubPicProviderEx!=NULL)
  58             {
  59                 POSITION pos = m_prefered_colortype.GetHeadPosition();
  60                 while(pos!=NULL)
  61                 {
  62                     int color_type = m_prefered_colortype.GetNext(pos);
  63                     if( m_pSubPicProviderEx->IsColorTypeSupported( color_type ) &&
  64                         IsSpdColorTypeSupported( color_type ) )
  65                     {
  66                         m_spd_type = color_type;
  67                         break;
  68                     }
  69                 }
  70             }
  71             Invalidate();
  72
  73             return S_OK;
  74         }
  75
  76         return E_NOTIMPL;
  77     }
  78
  79     return S_OK;
  80 }
  81
  82 STDMETHODIMP SimpleSubPicProvider::GetSubPicProvider( IUnknown** subpic_provider )
  83 {
  84     if(!subpic_provider) {
  85         return E_POINTER;
  86     }
  87
  88     CAutoLock cAutoLock(&m_csSubPicProvider);
  89
  90     if(m_pSubPicProviderEx) {
  91         *subpic_provider = m_pSubPicProviderEx;
  92         (*subpic_provider)->AddRef();
  93     }
  94
  95     return !!*subpic_provider ? S_OK : E_FAIL;
  96 }
  97
  98 STDMETHODIMP SimpleSubPicProvider::SetFPS( double fps )
  99 {
 100     m_fps = fps;
 101
 102     return S_OK;
 103 }
 104
 105 STDMETHODIMP SimpleSubPicProvider::SetTime( REFERENCE_TIME rtNow )
 106 {
 107     m_rtNow = rtNow;
 108
 109     return S_OK;
 110 }
 111
 112 STDMETHODIMP SimpleSubPicProvider::Invalidate( REFERENCE_TIME rtInvalidate /*= -1*/ )
 113 {
 114     CAutoLock cQueueLock(&m_csLock);
 115
 116     if( m_pSubPic && m_subpic_stop >= rtInvalidate)
 117     {
 118         m_pSubPic = NULL;
 119     }
 120     return S_OK;
 121 }
 122
 123 STDMETHODIMP_(bool) SimpleSubPicProvider::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic /*[out]*/ )
 124 {
 125     if(output_subpic!=NULL)
 126     {
 127         *output_subpic = NULL;
 128         CComPtr<IXySubRenderFrame> temp = NULL;
 129         bool result = LookupSubPicEx(now, &temp);
 130         if (result && temp)
 131         {
 132             (*output_subpic = new SimpleSubpic(temp, m_alpha_blt_dst_type))->AddRef();
 133         }
 134         return result;
 135     }
 136     return false;
 137 }
 138
 139 STDMETHODIMP SimpleSubPicProvider::GetStats( int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 140 {
 141     CAutoLock cAutoLock(&m_csLock);
 142
 143     nSubPics = 0;
 144     rtNow = m_rtNow;
 145     rtStart = rtStop = 0;
 146
 147     if(m_pSubPic)
 148     {
 149         nSubPics = 1;
 150         rtStart = m_subpic_start;
 151         rtStop = m_subpic_stop;
 152     }
 153
 154     return S_OK;
 155 }
 156
 157 STDMETHODIMP SimpleSubPicProvider::GetStats( int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 158 {
 159     CAutoLock cAutoLock(&m_csLock);
 160
 161     if(!m_pSubPic || nSubPic != 0)
 162         return E_INVALIDARG;
 163
 164     rtStart = m_subpic_start;
 165     rtStop = m_subpic_stop;
 166
 167     return S_OK;
 168 }
 169
 170 bool SimpleSubPicProvider::LookupSubPicEx(REFERENCE_TIME rtNow, IXySubRenderFrame** sub_render_frame)
 171 {
 172     if(!sub_render_frame)
 173         return(false);
 174
 175     *sub_render_frame = NULL;
 176
 177     if(m_subpic_start <= rtNow && rtNow < m_subpic_stop && m_pSubPic)
 178     {
 179         (*sub_render_frame = m_pSubPic)->AddRef();
 180     }
 181     else
 182     {
 183         CComPtr<ISubPicProviderEx2> pSubPicProvider;
 184         if(SUCCEEDED(GetSubPicProviderEx(&pSubPicProvider)) && pSubPicProvider
 185             && SUCCEEDED(pSubPicProvider->Lock()))
 186         {
 187             double fps = m_fps;
 188
 189             if(POSITION pos = pSubPicProvider->GetStartPosition(rtNow, fps))
 190             {
 191                 REFERENCE_TIME rtStart = pSubPicProvider->GetStart(pos, fps);
 192                 REFERENCE_TIME rtStop = pSubPicProvider->GetStop(pos, fps);
 193
 194                 if(rtStart <= rtNow && rtNow < rtStop)
 195                 {
 196                     RenderTo(sub_render_frame, rtNow, rtNow+1, fps, true);
 197                 }
 198             }
 199
 200             pSubPicProvider->Unlock();
 201
 202             if(*sub_render_frame)
 203             {
 204                 CAutoLock cAutoLock(&m_csLock);
 205
 206                 m_pSubPic = *sub_render_frame;
 207             }
 208         }
 209     }
 210     return(!!*sub_render_frame);
 211 }
 212
 213 HRESULT SimpleSubPicProvider::GetSubPicProviderEx( ISubPicProviderEx2** pSubPicProviderEx )
 214 {
 215     if(!pSubPicProviderEx) {
 216         return E_POINTER;
 217     }
 218
 219     CAutoLock cAutoLock(&m_csSubPicProvider);
 220
 221     if(m_pSubPicProviderEx) {
 222         *pSubPicProviderEx = m_pSubPicProviderEx;
 223         (*pSubPicProviderEx)->AddRef();
 224     }
 225
 226     return !!*pSubPicProviderEx ? S_OK : E_FAIL;
 227 }
 228
 229 HRESULT SimpleSubPicProvider::RenderTo( IXySubRenderFrame** pSubPic, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double fps, BOOL bIsAnimated )
 230 {
 231     HRESULT hr = E_FAIL;
 232
 233     if(!pSubPic) {
 234         return hr;
 235     }
 236
 237     CComPtr<ISubPicProviderEx2> pSubPicProviderEx;
 238     if(FAILED(GetSubPicProviderEx(&pSubPicProviderEx)) || !pSubPicProviderEx) {
 239         return hr;
 240     }
 241
 242     if(FAILED(pSubPicProviderEx->Lock())) {
 243         return hr;
 244     }
 245
 246     CAtlList<CRect> rectList;
 247
 248     CComPtr<IXySubRenderFrame> sub_render_frame;
 249     SIZE size_render_with;
 250     ASSERT(m_consumer);
 251     hr = m_consumer->XyGetSize(DirectVobSubXyOptions::SIZE_LAYOUT_WITH, &size_render_with);
 252     if (FAILED(hr))
 253     {
 254         return hr;
 255     }
 256
 257     hr = pSubPicProviderEx->RenderEx(pSubPic, m_spd_type, m_spd_size,
 258         size_render_with, CRect(0,0,size_render_with.cx,size_render_with.cy),
 259         bIsAnimated ? rtStart : ((rtStart+rtStop)/2), fps);
 260
 261     POSITION pos = pSubPicProviderEx->GetStartPosition(rtStart, fps);
 262
 263     pSubPicProviderEx->GetStartStop(pos, fps, m_subpic_start, m_subpic_stop);
 264
 265     pSubPicProviderEx->Unlock();
 266
 267     return hr;
 268 }
 269
 270 bool SimpleSubPicProvider::IsSpdColorTypeSupported( int type )
 271 {
 272     if( (type==MSP_RGBA)
 273         ||
 274         (type==MSP_XY_AUYV &&  m_alpha_blt_dst_type == MSP_YUY2)
 275         ||
 276         (type==MSP_AYUV &&  m_alpha_blt_dst_type == MSP_AYUV)//ToDo: fix me MSP_AYUV
 277         ||
 278         (type==MSP_AYUV_PLANAR && (m_alpha_blt_dst_type == MSP_IYUV ||
 279                                     m_alpha_blt_dst_type == MSP_YV12 ||
 280                                     m_alpha_blt_dst_type == MSP_P010 ||
 281                                     m_alpha_blt_dst_type == MSP_P016 ||
 282                                     m_alpha_blt_dst_type == MSP_NV12 ||
 283                                     m_alpha_blt_dst_type == MSP_NV21)) )
 284     {
 285         return true;
 286     }
 287     return false;
 288 }
 289
 290 //////////////////////////////////////////////////////////////////////////
 291 //
 292 // SimpleSubPicProvider2
 293 //
 294
 295 SimpleSubPicProvider2::SimpleSubPicProvider2( int alpha_blt_dst_type, SIZE max_size, SIZE cur_size, RECT video_rect,
 296     IDirectVobSubXy *consumer, HRESULT* phr/*=NULL*/)
 297     : CUnknown(NAME("SimpleSubPicProvider2"), NULL)
 298     , m_alpha_blt_dst_type(alpha_blt_dst_type)
 299     , m_max_size(max_size)
 300     , m_cur_size(cur_size)
 301     , m_video_rect(video_rect)
 302     , m_now(0)
 303     , m_fps(25.0)
 304     , m_consumer(consumer)
 305 {
 306     if (phr)
 307     {
 308         *phr= consumer ? S_OK : E_INVALIDARG;
 309     }
 310     m_ex_provider = NULL;
 311     m_old_provider = NULL;
 312     m_cur_provider = NULL;
 313 }
 314
 315 SimpleSubPicProvider2::~SimpleSubPicProvider2()
 316 {
 317     delete m_ex_provider;
 318     delete m_old_provider;
 319 }
 320
 321 STDMETHODIMP SimpleSubPicProvider2::NonDelegatingQueryInterface( REFIID riid, void** ppv )
 322 {
 323     return
 324         QI(ISimpleSubPicProvider)
 325         __super::NonDelegatingQueryInterface(riid, ppv);
 326 }
 327
 328 STDMETHODIMP SimpleSubPicProvider2::SetSubPicProvider( IUnknown* subpic_provider )
 329 {
 330     const int MAX_SUBPIC_QUEUE_LENGTH = 1;
 331
 332     if (subpic_provider!=NULL)
 333     {
 334         HRESULT hr;
 335         CComQIPtr<ISubPicProviderEx2> tmp = subpic_provider;
 336         if (tmp)
 337         {
 338             m_cur_provider = NULL;
 339             delete m_old_provider;
 340             m_old_provider = NULL;
 341             if (!m_ex_provider)
 342             {
 343                 m_ex_provider = new SimpleSubPicProvider(m_alpha_blt_dst_type, m_cur_size, m_video_rect, m_consumer, &hr);
 344                 m_ex_provider->SetFPS(m_fps);
 345                 m_ex_provider->SetTime(m_now);
 346             }
 347             if (m_ex_provider==NULL)
 348             {
 349                 ASSERT(m_ex_provider!=NULL);
 350                 return E_FAIL;
 351             }
 352             m_cur_provider = m_ex_provider;
 353         }
 354         else
 355         {
 356             m_cur_provider = NULL;
 357             delete m_ex_provider;
 358             m_ex_provider = NULL;
 359             if (!m_old_provider)
 360             {
 361                 CComPtr<ISubPicExAllocator> pSubPicAllocator = new CPooledSubPicAllocator(m_alpha_blt_dst_type,
 362                     m_max_size, MAX_SUBPIC_QUEUE_LENGTH + 1);
 363                 ASSERT(pSubPicAllocator);
 364                 pSubPicAllocator->SetCurSize(m_cur_size);
 365                 pSubPicAllocator->SetCurVidRect(m_video_rect);
 366                 m_old_provider = new CSubPicQueueNoThread(pSubPicAllocator, &hr);
 367                 m_old_provider->SetFPS(m_fps);
 368                 m_old_provider->SetTime(m_now);
 369                 if (FAILED(hr) || m_old_provider==NULL)
 370                 {
 371                     ASSERT(SUCCEEDED(hr));
 372                     return hr;
 373                 }
 374             }
 375             m_cur_provider = m_old_provider;
 376         }
 377         return m_cur_provider->SetSubPicProvider(subpic_provider);
 378     }
 379     else
 380     {
 381         if (m_cur_provider!=NULL)
 382         {
 383             m_cur_provider->SetSubPicProvider(NULL);
 384         }
 385         m_cur_provider = NULL;
 386     }
 387     return S_OK;
 388 }
 389
 390 STDMETHODIMP SimpleSubPicProvider2::GetSubPicProvider( IUnknown** subpic_provider )
 391 {
 392     if (!m_cur_provider)
 393     {
 394         return S_FALSE;
 395     }
 396     return m_cur_provider->GetSubPicProvider(subpic_provider);
 397 }
 398
 399 STDMETHODIMP SimpleSubPicProvider2::SetFPS( double fps )
 400 {
 401     m_fps = fps;
 402     if (!m_cur_provider)
 403     {
 404         return S_FALSE;
 405     }
 406     return m_cur_provider->SetFPS(fps);
 407 }
 408
 409 STDMETHODIMP SimpleSubPicProvider2::SetTime( REFERENCE_TIME rtNow )
 410 {
 411     m_now = rtNow;
 412     if (!m_cur_provider)
 413     {
 414         return S_FALSE;
 415     }
 416     return m_cur_provider->SetTime(rtNow);
 417 }
 418
 419 STDMETHODIMP SimpleSubPicProvider2::Invalidate( REFERENCE_TIME rtInvalidate /*= -1*/ )
 420 {
 421     //ASSERT(m_cur_provider);
 422     if (!m_cur_provider)
 423     {
 424         return S_FALSE;
 425     }
 426     return m_cur_provider->Invalidate(rtInvalidate);
 427 }
 428
 429 STDMETHODIMP_(bool) SimpleSubPicProvider2::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic/*[out]*/ )
 430 {
 431     if (!m_cur_provider)
 432     {
 433         return false;
 434     }
 435     return m_cur_provider->LookupSubPic(now, output_subpic);
 436 }
 437
 438 STDMETHODIMP SimpleSubPicProvider2::GetStats( int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 439 {
 440     nSubPics = 0;
 441     if (!m_cur_provider)
 442     {
 443         return S_FALSE;
 444     }
 445     return m_cur_provider->GetStats(nSubPics, rtNow, rtStart, rtStop);
 446 }
 447
 448 STDMETHODIMP SimpleSubPicProvider2::GetStats( int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 449 {
 450     if (!m_cur_provider)
 451     {
 452         return S_FALSE;
 453     }
 454     return m_cur_provider->GetStats(nSubPic, rtStart, rtStop);
 455 }