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