src/subpic/PooledSubPic.cpp

   1 #include "PooledSubPic.h"
   2 #include "../subtitles/xy_malloc.h"
   3
   4
   5 STDMETHODIMP_(void) CPooledSubPicAllocator::ReleaseItem( void* Item )
   6 {
   7         //DbgLog((LOG_TRACE, 3, "ReleaseItem::free:%d", _free.GetCount()));
   8         CAutoLock lock(&_poolLock);
   9         POSITION pos = _using.Find((CPooledSubPic*)Item);
  10         if(pos!=NULL)
  11         {
  12                 _using.RemoveAt(pos);
  13                 _free.AddTail((CPooledSubPic*)Item);
  14         }
  15 }
  16
  17 STDMETHODIMP_(void) CPooledSubPicAllocator::OnItemDestruct( void* Item )
  18 {
  19         //DbgLog((LOG_TRACE, 3, "OnItemDestruct::free:%d", _free.GetCount()));
  20         CAutoLock lock(&_poolLock);
  21         //CPooledSubPic* typedItem = (CPooledSubPic*)Item;
  22         POSITION pos = _using.Find((CPooledSubPic*)Item);
  23         if(pos!=NULL)
  24         {
  25                 _using.RemoveAt(pos);
  26                 _capacity--;
  27         }
  28         ASSERT(_free.Find((CPooledSubPic*)Item)==NULL);
  29 }
  30
  31 bool STDMETHODCALLTYPE CPooledSubPicAllocator::InitPool( int capacity )
  32 {
  33         DbgLog((LOG_TRACE, 3, "%s(%d), %s", __FILE__, __LINE__, __FUNCTION__));
  34         CAutoLock lock(&_poolLock);
  35         CPooledSubPic* temp;
  36
  37         if(capacity<0)
  38                 capacity = 0;
  39
  40         //while(capacity<_capacity)
  41     while(_capacity>0)
  42         {
  43                 if(!_free.IsEmpty())
  44                 {
  45                         temp = _free.RemoveTail();
  46                         _capacity--;
  47                         temp->_pool = NULL;
  48                         temp->Release();
  49                 }
  50                 else if(!_using.IsEmpty())
  51                 {
  52                         temp = _using.RemoveTail();
  53                         _capacity--;
  54                         temp->_pool = NULL;
  55                         temp->Release();
  56                 }
  57         }
  58
  59         while(_capacity<capacity)
  60         {
  61                 if(!(temp = DoAlloc()))
  62                 {
  63                         ASSERT(0);
  64                         return(false);
  65                 }
  66
  67                 _free.AddTail(temp);
  68                 _capacity++;
  69                 temp->AddRef();
  70         }
  71         //DbgLog((LOG_TRACE, 3, "InitPool::free:%d", _free.GetCount()));
  72         return true;
  73 }
  74
  75 CPooledSubPicAllocator::CPooledSubPicAllocator( int alpha_blt_dst_type, SIZE maxsize, int capacity, int type/*=-1*/ )
  76         :CSubPicExAllocatorImpl(maxsize, false, false)
  77     , _alpha_blt_dst_type(alpha_blt_dst_type)
  78         , _maxsize(maxsize)
  79     , _type(type)
  80 {
  81     if(_type==-1)
  82     {
  83         switch(alpha_blt_dst_type)
  84         {
  85         case MSP_YUY2:
  86             _type = MSP_XY_AUYV;
  87             break;
  88         case MSP_AYUV:
  89             _type = MSP_AYUV;
  90             break;
  91         case MSP_IYUV:
  92         case MSP_YV12:
  93         case MSP_P010:
  94         case MSP_P016:
  95         case MSP_NV12:
  96         case MSP_NV21:
  97             _type = MSP_AYUV_PLANAR;
  98             break;
  99         default:
 100             _type = MSP_RGBA;
 101             break;
 102         }
 103     }
 104         _capacity = 0;
 105         InitPool(capacity);
 106 }
 107
 108
 109 bool CPooledSubPicAllocator::AllocEx( bool fStatic, ISubPicEx** ppSubPic )
 110 {
 111         if(!ppSubPic)
 112     {
 113                 return(false);
 114     }
 115         {
 116                 CAutoLock lock(&_poolLock);
 117         CollectUnUsedItem();
 118                 if(!_free.IsEmpty())
 119                 {
 120                         CPooledSubPic *item = _free.RemoveHead();
 121             if(item->m_type!=_type)
 122             {
 123                 item->_pool = NULL;
 124                 item->Release();
 125                 item = DoAlloc();
 126                 item->AddRef();
 127             }
 128                         _using.AddTail(item);
 129                         *ppSubPic = item;
 130                         item->AddRef();
 131                 }
 132         }
 133         if(*ppSubPic!=NULL)
 134         {
 135                 return true;
 136         }
 137         else
 138         {
 139                 return false;
 140         }
 141 }
 142
 143 CPooledSubPicAllocator::~CPooledSubPicAllocator()
 144 {
 145         CPooledSubPic* item = NULL;
 146         CAutoLock lock(&_poolLock);
 147         for(POSITION pos = _free.GetHeadPosition(); pos!=NULL; )
 148         {
 149                 item = _free.GetNext(pos);
 150         if(item!=NULL)
 151         {
 152                     item->_pool = NULL;
 153                     item->Release();
 154         }
 155         }
 156         for(POSITION pos = _using.GetHeadPosition(); pos!=NULL; )
 157         {
 158                 item = _using.GetNext(pos);
 159         if(item!=NULL)
 160         {
 161                     item->_pool = NULL;
 162                     item->Release();
 163         }
 164         }
 165 }
 166
 167 STDMETHODIMP_(int) CPooledSubPicAllocator::SetSpdColorType( int color_type )
 168 {
 169     if(_type!=color_type)
 170     {
 171         m_pStatic = NULL;
 172         _type = color_type;
 173     }
 174     return _type;
 175 }
 176
 177 STDMETHODIMP_(bool) CPooledSubPicAllocator::IsSpdColorTypeSupported( int type )
 178 {
 179     if( (type==MSP_RGBA)
 180         ||
 181         (type==MSP_XY_AUYV &&  _alpha_blt_dst_type == MSP_YUY2)
 182         ||
 183         (type==MSP_AYUV &&  _alpha_blt_dst_type == MSP_AYUV)
 184         ||
 185         (type==MSP_AYUV_PLANAR && (_alpha_blt_dst_type == MSP_IYUV ||
 186                             _alpha_blt_dst_type == MSP_YV12 ||
 187                             _alpha_blt_dst_type == MSP_P010 ||
 188                             _alpha_blt_dst_type == MSP_P016 ||
 189                             _alpha_blt_dst_type == MSP_NV12 ||
 190                             _alpha_blt_dst_type == MSP_NV21)) )
 191     {
 192         return true;
 193     }
 194     return false;
 195 }
 196
 197 CPooledSubPic* CPooledSubPicAllocator::DoAlloc()
 198 {
 199     SubPicDesc spd;
 200     spd.type = _type;
 201     spd.w = _maxsize.cx;
 202     spd.h = _maxsize.cy;
 203     //          spd.bpp = 32;
 204     spd.bpp = (_type == MSP_AYUV_PLANAR) ? 8 : 32;
 205     spd.pitch = (spd.w*spd.bpp)>>3;
 206
 207     //          if(!(spd.bits = new BYTE[spd.pitch*spd.h]))
 208     if(_type == MSP_AYUV_PLANAR)
 209     {
 210         spd.bits = xy_malloc(spd.pitch*spd.h*4);
 211     }
 212     else
 213     {
 214         spd.bits = xy_malloc(spd.pitch*spd.h);
 215     }
 216     if(!spd.bits)
 217     {
 218         ASSERT(0);
 219         return(NULL);
 220     }
 221     CPooledSubPic* temp = NULL;
 222     if(!(temp = DEBUG_NEW CPooledSubPic(spd, _alpha_blt_dst_type, this)))
 223     {
 224         xy_free(spd.bits);
 225         ASSERT(0);
 226         return(NULL);
 227     }
 228     return temp;
 229 }
 230
 231 void CPooledSubPicAllocator::CollectUnUsedItem()
 232 {
 233     POSITION pos = _using.GetHeadPosition();
 234     if(pos)
 235     {
 236         CPooledSubPic* item = _using.RemoveHead();
 237         if (item->m_cRef==1)
 238         {
 239             _free.AddTail(item);
 240         }
 241         else
 242         {
 243             _using.AddTail(item);
 244         }
 245     }
 246 }
 247
 248 CPooledSubPic::~CPooledSubPic()
 249 {
 250         if(_pool!=NULL)
 251                 _pool->OnItemDestruct(this);
 252     xy_free(m_spd.bits);
 253     m_spd.bits = NULL;
 254 }