src/subpic/SimpleSubPicProviderImpl.cpp

   1 #include "stdafx.h"
   2 #include "SimpleSubPicProviderImpl.h"
   3 #include "SimpleSubPicWrapper.h"
   4 #include "../subtitles/xy_bitmap.h"
   5
   6 //////////////////////////////////////////////////////////////////////////
   7 //
   8 // SimpleSubPicProvider
   9 //
  10
  11 SimpleSubPicProvider::SimpleSubPicProvider( ISubPicExAllocator* pAllocator, HRESULT* phr )
  12     : CUnknown(NAME("CSubPicQueueImpl"), NULL)
  13     , m_pAllocator(pAllocator)
  14     , m_rtNow(0)
  15     , m_fps(25.0)
  16 {
  17     if(phr) {
  18         *phr = S_OK;
  19     }
  20
  21     if(!m_pAllocator) {
  22         if(phr) {
  23             *phr = E_FAIL;
  24         }
  25         return;
  26     }
  27     if (m_pAllocator->IsDynamicWriteOnly())
  28     {
  29         int o=0;
  30         o = o/o;
  31         throw 0;
  32         exit(-1);
  33     }
  34     m_prefered_colortype.AddTail(MSP_AYUV_PLANAR);
  35     m_prefered_colortype.AddTail(MSP_AYUV);
  36     m_prefered_colortype.AddTail(MSP_XY_AUYV);
  37     m_prefered_colortype.AddTail(MSP_RGBA);
  38 }
  39
  40 SimpleSubPicProvider::~SimpleSubPicProvider()
  41 {
  42
  43 }
  44
  45 STDMETHODIMP SimpleSubPicProvider::NonDelegatingQueryInterface( REFIID riid, void** ppv )
  46 {
  47     return
  48         QI(ISimpleSubPicProvider)
  49         __super::NonDelegatingQueryInterface(riid, ppv);
  50 }
  51
  52 STDMETHODIMP SimpleSubPicProvider::SetSubPicProvider( IUnknown* subpic_provider )
  53 {
  54     CComQIPtr<ISubPicProviderEx2> tmp = subpic_provider;
  55     if (tmp)
  56     {
  57         CAutoLock cAutoLock(&m_csSubPicProvider);
  58         m_pSubPicProviderEx = tmp;
  59
  60         if(m_pSubPicProviderEx!=NULL && m_pAllocator!=NULL)
  61         {
  62             POSITION pos = m_prefered_colortype.GetHeadPosition();
  63             while(pos!=NULL)
  64             {
  65                 int color_type = m_prefered_colortype.GetNext(pos);
  66                 if( m_pSubPicProviderEx->IsColorTypeSupported( color_type ) &&
  67                     m_pAllocator->IsSpdColorTypeSupported( color_type ) )
  68                 {
  69                     m_pAllocator->SetSpdColorType(color_type);
  70                     break;
  71                 }
  72             }
  73         }
  74         Invalidate();
  75
  76         return S_OK;
  77     }
  78     return E_NOTIMPL;
  79 }
  80
  81 STDMETHODIMP SimpleSubPicProvider::GetSubPicProvider( IUnknown** subpic_provider )
  82 {
  83     if(!subpic_provider) {
  84         return E_POINTER;
  85     }
  86
  87     CAutoLock cAutoLock(&m_csSubPicProvider);
  88
  89     if(m_pSubPicProviderEx) {
  90         *subpic_provider = m_pSubPicProviderEx;
  91         (*subpic_provider)->AddRef();
  92     }
  93
  94     return !!*subpic_provider ? S_OK : E_FAIL;
  95 }
  96
  97 STDMETHODIMP SimpleSubPicProvider::SetFPS( double fps )
  98 {
  99     m_fps = fps;
 100
 101     return S_OK;
 102 }
 103
 104 STDMETHODIMP SimpleSubPicProvider::SetTime( REFERENCE_TIME rtNow )
 105 {
 106     m_rtNow = rtNow;
 107
 108     return S_OK;
 109 }
 110
 111 STDMETHODIMP SimpleSubPicProvider::Invalidate( REFERENCE_TIME rtInvalidate /*= -1*/ )
 112 {
 113     CAutoLock cQueueLock(&m_csLock);
 114
 115     if( m_pSubPic && m_pSubPic->GetStop() >= rtInvalidate)
 116     {
 117         m_pSubPic = NULL;
 118     }
 119     return S_OK;
 120 }
 121
 122 STDMETHODIMP_(bool) SimpleSubPicProvider::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic /*[out]*/ )
 123 {
 124     if(output_subpic!=NULL)
 125     {
 126         CComPtr<ISubPicEx> temp;
 127         bool result = LookupSubPicEx(now, &temp);
 128         (*output_subpic = new SimpleSubPicWrapper(temp))->AddRef();
 129         return result;
 130     }
 131     else
 132     {
 133         return LookupSubPicEx(now, NULL);
 134     }
 135 }
 136
 137 STDMETHODIMP SimpleSubPicProvider::GetStats( int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 138 {
 139     CAutoLock cAutoLock(&m_csLock);
 140
 141     nSubPics = 0;
 142     rtNow = m_rtNow;
 143     rtStart = rtStop = 0;
 144
 145     if(m_pSubPic)
 146     {
 147         nSubPics = 1;
 148         rtStart = m_pSubPic->GetStart();
 149         rtStop = m_pSubPic->GetStop();
 150     }
 151
 152     return S_OK;
 153 }
 154
 155 STDMETHODIMP SimpleSubPicProvider::GetStats( int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 156 {
 157     CAutoLock cAutoLock(&m_csLock);
 158
 159     if(!m_pSubPic || nSubPic != 0)
 160         return E_INVALIDARG;
 161
 162     rtStart = m_pSubPic->GetStart();
 163     rtStop = m_pSubPic->GetStop();
 164
 165     return S_OK;
 166 }
 167
 168 bool SimpleSubPicProvider::LookupSubPicEx(REFERENCE_TIME rtNow, ISubPicEx** ppSubPic)
 169 {
 170     if(!ppSubPic)
 171         return(false);
 172
 173     *ppSubPic = NULL;
 174
 175     CComPtr<ISubPicEx> pSubPic;
 176
 177     {
 178         CAutoLock cAutoLock(&m_csLock);
 179
 180         if(!m_pSubPic)
 181         {
 182             if(FAILED(m_pAllocator->AllocDynamicEx(&m_pSubPic))) {
 183                 return false;
 184             }
 185         }
 186
 187         pSubPic = m_pSubPic;
 188     }
 189
 190     if(m_subpic_start <= rtNow && rtNow < m_subpic_stop)
 191     {
 192         (*ppSubPic = pSubPic)->AddRef();
 193     }
 194     else
 195     {
 196         CComPtr<ISubPicProviderEx2> pSubPicProvider;
 197         if(SUCCEEDED(GetSubPicProviderEx(&pSubPicProvider)) && pSubPicProvider
 198             && SUCCEEDED(pSubPicProvider->Lock()))
 199         {
 200             double fps = m_fps;
 201
 202             if(POSITION pos = pSubPicProvider->GetStartPosition(rtNow, fps))
 203             {
 204                 REFERENCE_TIME rtStart = pSubPicProvider->GetStart(pos, fps);
 205                 REFERENCE_TIME rtStop = pSubPicProvider->GetStop(pos, fps);
 206
 207                 if(rtStart <= rtNow && rtNow < rtStop)
 208                 {
 209                     if(SUCCEEDED(RenderTo(m_pSubPic, rtNow, rtNow+1, fps, true)))
 210                         (*ppSubPic = pSubPic)->AddRef();
 211                 }
 212             }
 213
 214             pSubPicProvider->Unlock();
 215
 216             if(*ppSubPic)
 217             {
 218                 CAutoLock cAutoLock(&m_csLock);
 219
 220                 m_pSubPic = *ppSubPic;
 221             }
 222         }
 223     }
 224     return(!!*ppSubPic);
 225 }
 226
 227 HRESULT SimpleSubPicProvider::GetSubPicProviderEx( ISubPicProviderEx2** pSubPicProviderEx )
 228 {
 229     if(!pSubPicProviderEx) {
 230         return E_POINTER;
 231     }
 232
 233     CAutoLock cAutoLock(&m_csSubPicProvider);
 234
 235     if(m_pSubPicProviderEx) {
 236         *pSubPicProviderEx = m_pSubPicProviderEx;
 237         (*pSubPicProviderEx)->AddRef();
 238     }
 239
 240     return !!*pSubPicProviderEx ? S_OK : E_FAIL;
 241 }
 242
 243 HRESULT SimpleSubPicProvider::RenderTo( ISubPicEx* pSubPic, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double fps, BOOL bIsAnimated )
 244 {
 245     HRESULT hr = E_FAIL;
 246
 247     if(!pSubPic) {
 248         return hr;
 249     }
 250
 251     CComPtr<ISubPicProviderEx2> pSubPicProviderEx;
 252     if(FAILED(GetSubPicProviderEx(&pSubPicProviderEx)) || !pSubPicProviderEx) {
 253         return hr;
 254     }
 255
 256     if(FAILED(pSubPicProviderEx->Lock())) {
 257         return hr;
 258     }
 259
 260     SubPicDesc spd;
 261     if(SUCCEEDED(pSubPic->Lock(spd)))
 262     {
 263         DWORD color = 0xFF000000;
 264         if(SUCCEEDED(pSubPic->ClearDirtyRect(color)))
 265         {
 266             CAtlList<CRect> rectList;
 267             CSize output_size = CSize(spd.w,spd.h);
 268
 269             CComPtr<IXySubRenderFrame> sub_render_frame;
 270             hr = pSubPicProviderEx->RenderEx(&sub_render_frame, spd.type, output_size, spd.vidrect,
 271                 bIsAnimated ? rtStart : ((rtStart+rtStop)/2), fps);
 272             if (SUCCEEDED(hr) && sub_render_frame)
 273             {
 274                 int count = 0;
 275                 hr = sub_render_frame->GetBitmapCount(&count);
 276                 if(FAILED(hr))
 277                 {
 278                     return hr;
 279                 }
 280                 int color_space;
 281                 hr = sub_render_frame->GetXyColorSpace(&color_space);
 282                 if(FAILED(hr))
 283                 {
 284                     return hr;
 285                 }
 286                 for (int i=0;i<count;i++)
 287                 {
 288                     POINT pos;
 289                     SIZE size;
 290                     LPCVOID pixels;
 291                     int pitch;
 292                     hr = sub_render_frame->GetBitmap(i, NULL, &pos, &size, &pixels, &pitch );
 293                     if(FAILED(hr))
 294                     {
 295                         return hr;
 296                     }
 297                     rectList.AddTail(CRect(pos, size));
 298                     if (color_space==XY_CS_AYUV_PLANAR)
 299                     {
 300                         XyPlannerFormatExtra plans;
 301                         hr = sub_render_frame->GetBitmapExtra(i, &plans);
 302                         if(FAILED(hr))
 303                         {
 304                             return hr;
 305                         }
 306                         XyBitmap::BitBltPlannar(spd, pos, size, plans, pitch);
 307                     }
 308                     else
 309                     {
 310                         XyBitmap::BitBltPack(spd, pos, size, pixels, pitch);
 311                     }
 312                 }
 313             }
 314
 315             POSITION pos = pSubPicProviderEx->GetStartPosition(rtStart, fps);
 316
 317             pSubPicProviderEx->GetStartStop(pos, fps, m_subpic_start, m_subpic_stop);
 318
 319             pSubPic->Unlock(&rectList);
 320         }
 321     }
 322
 323     pSubPicProviderEx->Unlock();
 324
 325     return hr;
 326 }
 327
 328 //////////////////////////////////////////////////////////////////////////
 329 //
 330 // SimpleSubPicProvider2
 331 //
 332
 333 SimpleSubPicProvider2::SimpleSubPicProvider2( ISubPicExAllocator* pAllocator, HRESULT* phr, const int *prefered_colortype/*=NULL*/, int prefered_colortype_num/*=0*/ )
 334     : CUnknown(NAME("SimpleSubPicProvider2"), NULL)
 335     , m_ex_provider(pAllocator, phr)
 336     , m_old_provider(pAllocator, phr, prefered_colortype, prefered_colortype_num)
 337 {
 338     m_cur_provider = &m_ex_provider;
 339 }
 340
 341 SimpleSubPicProvider2::~SimpleSubPicProvider2()
 342 {
 343
 344 }
 345
 346 STDMETHODIMP SimpleSubPicProvider2::NonDelegatingQueryInterface( REFIID riid, void** ppv )
 347 {
 348     return
 349         QI(ISimpleSubPicProvider)
 350         __super::NonDelegatingQueryInterface(riid, ppv);
 351 }
 352
 353 STDMETHODIMP SimpleSubPicProvider2::SetSubPicProvider( IUnknown* subpic_provider )
 354 {
 355     CComQIPtr<ISubPicProviderEx2> tmp = subpic_provider;
 356     if (tmp)
 357     {
 358         m_cur_provider = &m_ex_provider;
 359     }
 360     else
 361     {
 362         m_cur_provider = &m_old_provider;
 363     }
 364     return m_cur_provider->SetSubPicProvider(subpic_provider);
 365 }
 366
 367 STDMETHODIMP SimpleSubPicProvider2::GetSubPicProvider( IUnknown** subpic_provider )
 368 {
 369     return m_cur_provider->GetSubPicProvider(subpic_provider);
 370 }
 371
 372 STDMETHODIMP SimpleSubPicProvider2::SetFPS( double fps )
 373 {
 374     return m_cur_provider->SetFPS(fps);
 375 }
 376
 377 STDMETHODIMP SimpleSubPicProvider2::SetTime( REFERENCE_TIME rtNow )
 378 {
 379     return m_cur_provider->SetTime(rtNow);
 380 }
 381
 382 STDMETHODIMP SimpleSubPicProvider2::Invalidate( REFERENCE_TIME rtInvalidate /*= -1*/ )
 383 {
 384     return m_cur_provider->Invalidate(rtInvalidate);
 385 }
 386
 387 STDMETHODIMP_(bool) SimpleSubPicProvider2::LookupSubPic( REFERENCE_TIME now /*[in]*/, ISimpleSubPic** output_subpic/*[out]*/ )
 388 {
 389     return m_cur_provider->LookupSubPic(now, output_subpic);
 390 }
 391
 392 STDMETHODIMP SimpleSubPicProvider2::GetStats( int& nSubPics, REFERENCE_TIME& rtNow, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 393 {
 394     return m_cur_provider->GetStats(nSubPics, rtNow, rtStart, rtStop);
 395 }
 396
 397 STDMETHODIMP SimpleSubPicProvider2::GetStats( int nSubPic, REFERENCE_TIME& rtStart, REFERENCE_TIME& rtStop )
 398 {
 399     return m_cur_provider->GetStats(nSubPic, rtStart, rtStop);
 400 }