src/subtitles/cache_manager.cpp

   1 /************************************************************************/
   2 /* author: xy                                                           */
   3 /* date: 20110926                                                       */
   4 /************************************************************************/
   5 #include "StdAfx.h"
   6 #include "cache_manager.h"
   7
   8 ULONG TextInfoCacheKeyTraits::Hash( const TextInfoCacheKey& key )
   9 {
  10     ULONG hash = CStringElementTraits<CString>::Hash(key.m_str);
  11     hash += (hash<<5);
  12     hash += hash_value( static_cast<const STSStyleBase&>(key.m_style.get()) );
  13     hash += (hash<<5);
  14     hash += hash_value( key.m_style.get().fontScaleX );
  15     hash += (hash<<5);
  16     hash += hash_value( key.m_style.get().fontScaleY );
  17     hash += (hash<<5);
  18     hash += hash_value( key.m_style.get().fontSpacing );
  19     return hash;
  20 }
  21
  22 ULONG CWordCacheKeyTraits::Hash( const CWordCacheKey& key )
  23 {
  24     return( CStringElementTraits<CString>::Hash(key.m_str) );//fix me
  25 }
  26
  27 ULONG PathDataCacheKeyTraits::Hash( const PathDataCacheKey& key )
  28 {
  29     return( CStringElementTraits<CString>::Hash(key.m_str) );
  30 }
  31
  32 ULONG ScanLineData2CacheKeyTraits::Hash( const ScanLineData2CacheKey& key )
  33 {
  34     //return hash_value(static_cast<PathDataCacheKey>(key)) ^ key.m_org.x ^ key.m_org.y;
  35     size_t hash = PathDataCacheKeyTraits::Hash(static_cast<const PathDataCacheKey&>(key));
  36     hash += (hash<<5);
  37     hash += key.m_org.x;
  38     hash += (hash<<5);
  39     hash += key.m_org.y;
  40     return  hash;
  41 }
  42
  43 ULONG OverlayNoBlurKeyTraits::Hash( const OverlayNoBlurKey& key )
  44 {
  45     ULONG hash = ScanLineData2CacheKeyTraits::Hash(static_cast<const ScanLineData2CacheKey&>(key));
  46     hash += (hash<<5);
  47     hash += key.m_p.x;
  48     hash += (hash<<5);
  49     hash += key.m_p.y;
  50     return  hash;
  51 }
  52
  53 ULONG OverlayKeyTraits::Hash( const OverlayKey& key )
  54 {
  55     ULONG hash = OverlayNoBlurKeyTraits::Hash(static_cast<const OverlayNoBlurKey&>(key));
  56     hash += (hash<<5);
  57     hash += key.m_style.get().fBlur;
  58     hash += (hash<<5);
  59     hash += hash_value(key.m_style.get().fGaussianBlur);
  60     return  hash;
  61 }
  62
  63
  64 ULONG PathDataTraits::Hash( const PathData& key )
  65 {
  66     ULONG hash = 515;
  67     hash += (hash<<5);
  68     hash += key.mPathPoints;
  69     for (int i=0;i<key.mPathPoints;i++)
  70     {
  71         hash += (hash<<5);
  72         hash += key.mpPathTypes[i];
  73     }
  74     for (int i=0;i<key.mPathPoints;i++)
  75     {
  76         hash += (hash<<5);
  77         hash += key.mpPathPoints[i].x;
  78         hash += (hash<<5);
  79         hash += key.mpPathPoints[i].y;
  80     }
  81     return hash;
  82 }
  83
  84 ULONG ScanLineDataCacheKeyTraits::Hash( const ScanLineDataCacheKey& key )
  85 {
  86     return PathDataTraits::Hash(*key.m_path_data);
  87 }
  88
  89 ULONG ClipperAlphaMaskCacheKeyTraits::Hash( const ClipperAlphaMaskCacheKey& key )
  90 {
  91     return Hash(*key.m_clipper);
  92 }
  93
  94 ULONG ClipperAlphaMaskCacheKeyTraits::Hash( const CClipper& key )
  95 {
  96     ULONG hash = CStringElementTraits<CString>::Hash(key.m_polygon->m_str);;
  97     hash += (hash<<5);
  98     hash += key.m_inverse;
  99     hash += (hash<<5);
 100     hash += key.m_effectType;
 101     hash += (hash<<5);
 102     hash += key.m_size.cx;
 103     hash += (hash<<5);
 104     hash += key.m_size.cy;
 105     hash += (hash<<5);
 106     hash += hash_value(key.m_polygon->m_scalex);
 107     hash += (hash<<5);
 108     hash += hash_value(key.m_polygon->m_scaley);
 109
 110     for (int i=0;i<sizeof(key.m_effect.param)/sizeof(key.m_effect.param[0]);i++)
 111     {
 112         hash += (hash<<5);
 113         hash += key.m_effect.param[i];
 114     }
 115     for (int i=0;i<sizeof(key.m_effect.t)/sizeof(key.m_effect.t[0]);i++)
 116     {
 117         hash += (hash<<5);
 118         hash += key.m_effect.t[i];
 119     }
 120     return hash;
 121 }
 122
 123 //////////////////////////////////////////////////////////////////////////////////////////////
 124
 125 // TextInfoCacheKey
 126
 127 bool TextInfoCacheKey::operator==( const TextInfoCacheKey& key ) const
 128 {
 129     return m_str == key.m_str
 130         && static_cast<const STSStyleBase&>(m_style).operator==(key.m_style)
 131         && m_style.get().fontScaleX == key.m_style.get().fontScaleX
 132         && m_style.get().fontScaleY == key.m_style.get().fontScaleY
 133         && m_style.get().fontSpacing == key.m_style.get().fontSpacing;
 134 }
 135
 136 //////////////////////////////////////////////////////////////////////////////////////////////
 137
 138 // CWordCacheKey
 139
 140 CWordCacheKey::CWordCacheKey( const CWord& word )
 141 {
 142     m_str = word.m_str;
 143     m_style = word.m_style;
 144     m_ktype = word.m_ktype;
 145     m_kstart = word.m_kstart;
 146     m_kend = word.m_kend;
 147 }
 148
 149 CWordCacheKey::CWordCacheKey( const CWordCacheKey& key )
 150 {
 151     m_str = key.m_str;
 152     m_style = key.m_style;
 153     m_ktype = key.m_ktype;
 154     m_kstart = key.m_kstart;
 155     m_kend = key.m_kend;
 156 }
 157
 158 CWordCacheKey::CWordCacheKey( const FwSTSStyle& style, const CStringW& str, int ktype, int kstart, int kend )
 159     :m_style(style),m_str(str),m_ktype(ktype),m_kstart(kstart),m_kend(m_kend)
 160 {
 161
 162 }
 163
 164 bool CWordCacheKey::operator==( const CWordCacheKey& key ) const
 165 {
 166     return (m_str == key.m_str &&
 167         m_style == key.m_style &&
 168         m_ktype == key.m_ktype &&
 169         m_kstart == key.m_kstart &&
 170         m_kend == key.m_kend);
 171 }
 172
 173 bool CWordCacheKey::operator==(const CWord& key)const
 174 {
 175     return (m_str == key.m_str &&
 176         m_style == key.m_style &&
 177         m_ktype == key.m_ktype &&
 178         m_kstart == key.m_kstart &&
 179         m_kend == key.m_kend);
 180 }
 181
 182 //////////////////////////////////////////////////////////////////////////////////////////////
 183
 184 // PathDataCacheKey
 185
 186 bool PathDataCacheKey::CompareSTSStyle( const STSStyle& lhs, const STSStyle& rhs )
 187 {
 188     return lhs.charSet==rhs.charSet &&
 189         lhs.fontName==rhs.fontName &&
 190         lhs.fontSize==rhs.fontSize &&
 191         lhs.fontSpacing==rhs.fontSpacing &&
 192         lhs.fontWeight==rhs.fontWeight &&
 193         lhs.fItalic==rhs.fItalic &&
 194         lhs.fUnderline==rhs.fUnderline &&
 195         lhs.fStrikeOut==rhs.fStrikeOut;
 196 }
 197
 198 //////////////////////////////////////////////////////////////////////////////////////////////
 199
 200 // ScanLineData2CacheKey
 201
 202 bool ScanLineData2CacheKey::operator==( const ScanLineData2CacheKey& key ) const
 203 {
 204     return //(static_cast<PathDataCacheKey>(*this)==static_cast<PathDataCacheKey>(key))
 205         PathDataCacheKey::operator==(key) //static_cast will call copy constructer to construct a tmp obj
 206         && this->m_style.get().borderStyle == key.m_style.get().borderStyle
 207         && fabs(this->m_style.get().outlineWidthX - key.m_style.get().outlineWidthX) < 0.000001
 208         && fabs(this->m_style.get().outlineWidthY - key.m_style.get().outlineWidthY) < 0.000001
 209         && fabs(this->m_style.get().fontScaleX - key.m_style.get().fontScaleX) < 0.000001
 210         && fabs(this->m_style.get().fontScaleY - key.m_style.get().fontScaleY) < 0.000001
 211         && fabs(this->m_style.get().fontAngleX - key.m_style.get().fontAngleX) < 0.000001
 212         && fabs(this->m_style.get().fontAngleY - key.m_style.get().fontAngleY) < 0.000001
 213         && fabs(this->m_style.get().fontAngleZ - key.m_style.get().fontAngleZ) < 0.000001
 214         && fabs(this->m_style.get().fontShiftX - key.m_style.get().fontShiftX) < 0.000001
 215         && fabs(this->m_style.get().fontShiftY - key.m_style.get().fontShiftY) < 0.000001
 216         && (m_org.x==key.m_org.x) && (m_org.y==key.m_org.y);
 217 }
 218
 219 //////////////////////////////////////////////////////////////////////////////////////////////
 220
 221 // OverlayNoBlurKey
 222
 223 bool OverlayNoBlurKey::operator==( const OverlayNoBlurKey& key ) const
 224 {
 225     //static_cast will call copy constructer to construct a tmp obj
 226     //return (static_cast<ScanLineDataCacheKey>(*this)==static_cast<ScanLineDataCacheKey>(key))
 227     //    && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y);
 228     return ScanLineData2CacheKey::operator==(key) && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y);
 229 }
 230
 231 //////////////////////////////////////////////////////////////////////////////////////////////
 232
 233 // OverlayKey
 234
 235 bool OverlayKey::operator==( const OverlayKey& key ) const
 236 {
 237     return OverlayNoBlurKey::operator==(key)
 238         && fabs(this->m_style.get().fGaussianBlur - key.m_style.get().fGaussianBlur) < 0.000001
 239         && this->m_style.get().fBlur == key.m_style.get().fBlur;
 240     //static_cast will call copy constructer to construct a tmp obj
 241     //return ((CWordCacheKey)(*this)==(CWordCacheKey)key) && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y)
 242     //        && (m_org.x==key.m_org.x) && (m_org.y==key.m_org.y);
 243 }
 244
 245 //////////////////////////////////////////////////////////////////////////////////////////////
 246
 247 // ScanLineDataCacheKey
 248
 249 bool ScanLineDataCacheKey::operator==( const ScanLineDataCacheKey& key ) const
 250 {
 251     return (m_path_data && key.m_path_data) ? *m_path_data==*key.m_path_data : m_path_data==key.m_path_data;
 252 }
 253
 254 //////////////////////////////////////////////////////////////////////////////////////////////
 255
 256 // ClipperAlphaMaskCacheKey
 257
 258 bool ClipperAlphaMaskCacheKey::operator==( const ClipperAlphaMaskCacheKey& key ) const
 259 {
 260     bool result = false;
 261     if (m_clipper==key.m_clipper)
 262     {
 263         result = true;
 264     }
 265     else if ( m_clipper!=NULL && key.m_clipper!=NULL )
 266     {
 267         const CClipper& lhs = *m_clipper;
 268         const CClipper& rhs = *key.m_clipper;
 269         result = (lhs.m_polygon->m_str == rhs.m_polygon->m_str
 270             && fabs(lhs.m_polygon->m_scalex - rhs.m_polygon->m_scalex) < 0.000001
 271             && fabs(lhs.m_polygon->m_scaley - rhs.m_polygon->m_scaley) < 0.000001
 272             && lhs.m_size == rhs.m_size
 273             && lhs.m_inverse == rhs.m_inverse
 274             && lhs.m_effectType == rhs.m_effectType
 275             && lhs.m_effect == rhs.m_effect);//fix me: unsafe code
 276     }
 277     return result;
 278 }
 279
 280 //////////////////////////////////////////////////////////////////////////////////////////////
 281
 282 // CacheManager
 283
 284 struct Caches
 285 {
 286 public:
 287     Caches()
 288     {
 289         s_clipper_alpha_mask_cache = NULL;
 290
 291         s_text_info_cache = NULL;
 292         s_word_mru_cache = NULL;
 293         s_path_data_mru_cache = NULL;
 294         s_scan_line_data_2_mru_cache = NULL;
 295         s_overlay_no_blur_mru_cache = NULL;
 296         s_overlay_mru_cache = NULL;
 297
 298         s_scan_line_data_mru_cache = NULL;
 299
 300         s_subpixel_variance_cache = NULL;
 301         s_ass_tag_list_cache = NULL;
 302     }
 303     ~Caches()
 304     {
 305         delete s_clipper_alpha_mask_cache;
 306
 307         delete s_text_info_cache;
 308         delete s_word_mru_cache;
 309         delete s_path_data_mru_cache;
 310         delete s_scan_line_data_2_mru_cache;
 311         delete s_overlay_no_blur_mru_cache;
 312         delete s_overlay_mru_cache;
 313
 314         delete s_scan_line_data_mru_cache;
 315
 316         delete s_subpixel_variance_cache;
 317         delete s_ass_tag_list_cache;
 318     }
 319 public:
 320     ClipperAlphaMaskMruCache* s_clipper_alpha_mask_cache;
 321
 322     TextInfoMruCache* s_text_info_cache;
 323     AssTagListMruCache* s_ass_tag_list_cache;
 324
 325     ScanLineDataMruCache* s_scan_line_data_mru_cache;
 326
 327     OverlayMruCache* s_subpixel_variance_cache;
 328     OverlayMruCache* s_overlay_mru_cache;
 329     OverlayNoBlurMruCache* s_overlay_no_blur_mru_cache;
 330     PathDataMruCache* s_path_data_mru_cache;
 331     ScanLineData2MruCache* s_scan_line_data_2_mru_cache;
 332     CWordMruCache* s_word_mru_cache;
 333 };
 334
 335 static Caches s_caches;
 336
 337 OverlayMruCache* CacheManager::GetOverlayMruCache()
 338 {
 339     if(s_caches.s_overlay_mru_cache==NULL)
 340     {
 341         s_caches.s_overlay_mru_cache = new OverlayMruCache(OVERLAY_CACHE_ITEM_NUM);
 342     }
 343     return s_caches.s_overlay_mru_cache;
 344 }
 345
 346 PathDataMruCache* CacheManager::GetPathDataMruCache()
 347 {
 348     if (s_caches.s_path_data_mru_cache==NULL)
 349     {
 350         s_caches.s_path_data_mru_cache = new PathDataMruCache(PATH_CACHE_ITEM_NUM);
 351     }
 352     return s_caches.s_path_data_mru_cache;
 353 }
 354
 355 CWordMruCache* CacheManager::GetCWordMruCache()
 356 {
 357     if(s_caches.s_word_mru_cache==NULL)
 358     {
 359         s_caches.s_word_mru_cache = new CWordMruCache(WORD_CACHE_ITEM_NUM);
 360     }
 361     return s_caches.s_word_mru_cache;
 362 }
 363
 364 OverlayNoBlurMruCache* CacheManager::GetOverlayNoBlurMruCache()
 365 {
 366     if(s_caches.s_overlay_no_blur_mru_cache==NULL)
 367     {
 368         s_caches.s_overlay_no_blur_mru_cache = new OverlayNoBlurMruCache(OVERLAY_NO_BLUR_CACHE_ITEM_NUM);
 369     }
 370     return s_caches.s_overlay_no_blur_mru_cache;
 371 }
 372
 373 ScanLineData2MruCache* CacheManager::GetScanLineData2MruCache()
 374 {
 375     if(s_caches.s_scan_line_data_2_mru_cache==NULL)
 376     {
 377         s_caches.s_scan_line_data_2_mru_cache = new ScanLineData2MruCache(SCAN_LINE_DATA_CACHE_ITEM_NUM);
 378     }
 379     return s_caches.s_scan_line_data_2_mru_cache;
 380 }
 381
 382 OverlayMruCache* CacheManager::GetSubpixelVarianceCache()
 383 {
 384     if(s_caches.s_subpixel_variance_cache==NULL)
 385     {
 386         s_caches.s_subpixel_variance_cache = new OverlayMruCache(SUBPIXEL_VARIANCE_CACHE_ITEM_NUM);
 387     }
 388     return s_caches.s_subpixel_variance_cache;
 389 }
 390
 391 ScanLineDataMruCache* CacheManager::GetScanLineDataMruCache()
 392 {
 393     if(s_caches.s_scan_line_data_mru_cache==NULL)
 394     {
 395         s_caches.s_scan_line_data_mru_cache = new ScanLineDataMruCache(SCAN_LINE_DATA_CACHE_ITEM_NUM);
 396     }
 397     return s_caches.s_scan_line_data_mru_cache;
 398 }
 399
 400 AssTagListMruCache* CacheManager::GetAssTagListMruCache()
 401 {
 402     if(s_caches.s_ass_tag_list_cache==NULL)
 403     {
 404         s_caches.s_ass_tag_list_cache = new AssTagListMruCache(ASS_TAG_LIST_CACHE_ITEM_NUM);
 405     }
 406     return s_caches.s_ass_tag_list_cache;
 407 }
 408
 409 TextInfoMruCache* CacheManager::GetTextInfoCache()
 410 {
 411     if(s_caches.s_text_info_cache==NULL)
 412     {
 413         s_caches.s_text_info_cache = new TextInfoMruCache(TEXT_INFO_CACHE_ITEM_NUM);
 414     }
 415     return s_caches.s_text_info_cache;
 416 }
 417
 418 ClipperAlphaMaskMruCache* CacheManager::GetClipperAlphaMaskMruCache()
 419 {
 420     if(s_caches.s_clipper_alpha_mask_cache==NULL)
 421     {
 422         s_caches.s_clipper_alpha_mask_cache = new ClipperAlphaMaskMruCache(CLIPPER_ALPHA_MASK_MRU_CACHE);
 423     }
 424     return s_caches.s_clipper_alpha_mask_cache;
 425 }