src/subtitles/cache_manager.cpp

   1 /************************************************************************/
   2 /* author: xy                                                           */
   3 /* date: 20110926                                                       */
   4 /************************************************************************/
   5 #include "StdAfx.h"
   6 #include "cache_manager.h"
   7 #include "draw_item.h"
   8 #include "xy_overlay_paint_machine.h"
   9 #include "xy_clipper_paint_machine.h"
  10
  11 ULONG PathDataTraits::Hash( const PathData& key )
  12 {
  13     ULONG hash = 515;
  14     hash += (hash<<5);
  15     hash += key.mPathPoints;
  16     for (int i=0;i<key.mPathPoints;i++)
  17     {
  18         hash += (hash<<5);
  19         hash += key.mpPathTypes[i];
  20     }
  21     for (int i=0;i<key.mPathPoints;i++)
  22     {
  23         hash += (hash<<5);
  24         hash += key.mpPathPoints[i].x;
  25         hash += (hash<<5);
  26         hash += key.mpPathPoints[i].y;
  27     }
  28     return hash;
  29 }
  30
  31 ULONG ClipperTraits::Hash( const CClipper& key )
  32 {
  33     ULONG hash = CStringElementTraits<CString>::Hash(key.m_polygon->m_str);;
  34     hash += (hash<<5);
  35     hash += key.m_inverse;
  36     hash += (hash<<5);
  37     hash += key.m_effectType;
  38     hash += (hash<<5);
  39     hash += key.m_size.cx;
  40     hash += (hash<<5);
  41     hash += key.m_size.cy;
  42     hash += (hash<<5);
  43     hash += hash_value(key.m_polygon->m_scalex);
  44     hash += (hash<<5);
  45     hash += hash_value(key.m_polygon->m_scaley);
  46
  47     for (int i=0;i<sizeof(key.m_effect.param)/sizeof(key.m_effect.param[0]);i++)
  48     {
  49         hash += (hash<<5);
  50         hash += key.m_effect.param[i];
  51     }
  52     for (int i=0;i<sizeof(key.m_effect.t)/sizeof(key.m_effect.t[0]);i++)
  53     {
  54         hash += (hash<<5);
  55         hash += key.m_effect.t[i];
  56     }
  57     return hash;
  58 }
  59
  60 //////////////////////////////////////////////////////////////////////////////////////////////
  61
  62 // TextInfoCacheKey
  63
  64 bool TextInfoCacheKey::operator==( const TextInfoCacheKey& key ) const
  65 {
  66     return m_str == key.m_str
  67         && static_cast<const STSStyleBase&>(m_style).operator==(key.m_style)
  68         && m_style.get().fontScaleX == key.m_style.get().fontScaleX
  69         && m_style.get().fontScaleY == key.m_style.get().fontScaleY
  70         && m_style.get().fontSpacing == key.m_style.get().fontSpacing;
  71 }
  72
  73 ULONG TextInfoCacheKey::UpdateHashValue()
  74 {
  75     m_hash_value = CStringElementTraits<CString>::Hash(m_str);
  76     m_hash_value += (m_hash_value<<5);
  77     m_hash_value += hash_value( static_cast<const STSStyleBase&>(m_style.get()) );
  78     m_hash_value += (m_hash_value<<5);
  79     m_hash_value += hash_value( m_style.get().fontScaleX );
  80     m_hash_value += (m_hash_value<<5);
  81     m_hash_value += hash_value( m_style.get().fontScaleY );
  82     m_hash_value += (m_hash_value<<5);
  83     m_hash_value += hash_value( m_style.get().fontSpacing );
  84     return m_hash_value;
  85 }
  86
  87 //////////////////////////////////////////////////////////////////////////////////////////////
  88
  89 // PathDataCacheKey
  90
  91 bool PathDataCacheKey::CompareSTSStyle( const STSStyle& lhs, const STSStyle& rhs )
  92 {
  93     return lhs.charSet==rhs.charSet &&
  94         lhs.fontName==rhs.fontName &&
  95         lhs.fontSize==rhs.fontSize &&
  96         lhs.fontSpacing==rhs.fontSpacing &&
  97         lhs.fontWeight==rhs.fontWeight &&
  98         lhs.fItalic==rhs.fItalic &&
  99         lhs.fUnderline==rhs.fUnderline &&
 100         lhs.fStrikeOut==rhs.fStrikeOut;
 101 }
 102
 103 ULONG PathDataCacheKey::UpdateHashValue()
 104 {
 105     const STSStyle& style = m_style.get();
 106     m_hash_value = CStringElementTraits<CString>::Hash(m_str);
 107     m_hash_value += (m_hash_value<<5);
 108     m_hash_value += style.charSet;
 109     m_hash_value += (m_hash_value<<5);
 110     m_hash_value += CStringElementTraits<CString>::Hash(style.fontName);
 111     m_hash_value += (m_hash_value<<5);
 112     m_hash_value += style.fontSize;
 113     m_hash_value += (m_hash_value<<5);
 114     m_hash_value += style.fontSpacing;
 115     m_hash_value += (m_hash_value<<5);
 116     m_hash_value += style.fontWeight;
 117     m_hash_value += (m_hash_value<<5);
 118     m_hash_value += style.fItalic;
 119     m_hash_value += (m_hash_value<<5);
 120     m_hash_value += style.fUnderline;
 121     m_hash_value += (m_hash_value<<5);
 122     m_hash_value += style.fStrikeOut;
 123     return m_hash_value;
 124 }
 125
 126
 127 //////////////////////////////////////////////////////////////////////////////////////////////
 128
 129 // ScanLineData2CacheKey
 130
 131 bool ScanLineData2CacheKey::operator==( const ScanLineData2CacheKey& key ) const
 132 {
 133     return //(static_cast<PathDataCacheKey>(*this)==static_cast<PathDataCacheKey>(key))
 134         PathDataCacheKey::operator==(key) //static_cast will call copy constructer to construct a tmp obj
 135         && this->m_style.get().borderStyle == key.m_style.get().borderStyle
 136         && fabs(this->m_style.get().outlineWidthX - key.m_style.get().outlineWidthX) < 0.000001
 137         && fabs(this->m_style.get().outlineWidthY - key.m_style.get().outlineWidthY) < 0.000001
 138         && fabs(this->m_style.get().fontScaleX - key.m_style.get().fontScaleX) < 0.000001
 139         && fabs(this->m_style.get().fontScaleY - key.m_style.get().fontScaleY) < 0.000001
 140         && fabs(this->m_style.get().fontAngleX - key.m_style.get().fontAngleX) < 0.000001
 141         && fabs(this->m_style.get().fontAngleY - key.m_style.get().fontAngleY) < 0.000001
 142         && fabs(this->m_style.get().fontAngleZ - key.m_style.get().fontAngleZ) < 0.000001
 143         && fabs(this->m_style.get().fontShiftX - key.m_style.get().fontShiftX) < 0.000001
 144         && fabs(this->m_style.get().fontShiftY - key.m_style.get().fontShiftY) < 0.000001
 145         && (m_org.x==key.m_org.x) && (m_org.y==key.m_org.y);
 146 }
 147
 148 ULONG ScanLineData2CacheKey::UpdateHashValue()
 149 {
 150     m_hash_value = __super::UpdateHashValue();
 151     m_hash_value += (m_hash_value<<5);
 152     m_hash_value += m_org.x;
 153     m_hash_value += (m_hash_value<<5);
 154     m_hash_value += m_org.y;//fix me: fontScale and fontAngle are not take into account
 155     return  m_hash_value;
 156 }
 157
 158 //////////////////////////////////////////////////////////////////////////////////////////////
 159
 160 // OverlayNoBlurKey
 161
 162 bool OverlayNoBlurKey::operator==( const OverlayNoBlurKey& key ) const
 163 {
 164     //static_cast will call copy constructer to construct a tmp obj
 165     //return (static_cast<ScanLineDataCacheKey>(*this)==static_cast<ScanLineDataCacheKey>(key))
 166     //    && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y);
 167     return ScanLineData2CacheKey::operator==(key) && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y);
 168 }
 169
 170 ULONG OverlayNoBlurKey::UpdateHashValue()
 171 {
 172     m_hash_value = __super::UpdateHashValue();
 173     m_hash_value += (m_hash_value<<5);
 174     m_hash_value += m_p.x;
 175     m_hash_value += (m_hash_value<<5);
 176     m_hash_value += m_p.y;
 177     return  m_hash_value;
 178 }
 179
 180
 181 //////////////////////////////////////////////////////////////////////////////////////////////
 182
 183 // OverlayKey
 184
 185 bool OverlayKey::operator==( const OverlayKey& key ) const
 186 {
 187     return OverlayNoBlurKey::operator==(key)
 188         && fabs(this->m_style.get().fGaussianBlur - key.m_style.get().fGaussianBlur) < 0.000001
 189         && this->m_style.get().fBlur == key.m_style.get().fBlur;
 190     //static_cast will call copy constructer to construct a tmp obj
 191     //return ((CWordCacheKey)(*this)==(CWordCacheKey)key) && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y)
 192     //        && (m_org.x==key.m_org.x) && (m_org.y==key.m_org.y);
 193 }
 194
 195 ULONG OverlayKey::UpdateHashValue()
 196 {
 197     m_hash_value = __super::UpdateHashValue();
 198     m_hash_value += (m_hash_value<<5);
 199     m_hash_value += m_style.get().fBlur;
 200     m_hash_value += (m_hash_value<<5);
 201     m_hash_value += hash_value(m_style.get().fGaussianBlur);
 202     return  m_hash_value;
 203 }
 204
 205
 206 //////////////////////////////////////////////////////////////////////////////////////////////
 207
 208 // ScanLineDataCacheKey
 209
 210 bool ScanLineDataCacheKey::operator==( const ScanLineDataCacheKey& key ) const
 211 {
 212     return (m_path_data && key.m_path_data) ? *m_path_data==*key.m_path_data : m_path_data==key.m_path_data;
 213 }
 214
 215 ULONG ScanLineDataCacheKey::UpdateHashValue()
 216 {
 217     m_hash_value = PathDataTraits::Hash(*m_path_data);
 218     return m_hash_value;
 219 }
 220
 221 //////////////////////////////////////////////////////////////////////////////////////////////
 222
 223 // OverlayNoOffsetKey
 224
 225 bool OverlayNoOffsetKey::operator==( const OverlayNoOffsetKey& key ) const
 226 {
 227     return (this==&key) || ( this->m_border == key.m_border && this->m_rasterize_sub == key.m_rasterize_sub &&
 228         ScanLineDataCacheKey::operator==(key) );
 229 }
 230
 231 ULONG OverlayNoOffsetKey::UpdateHashValue()
 232 {
 233     m_hash_value = __super::UpdateHashValue();
 234     m_hash_value += (m_hash_value<<5);
 235     m_hash_value += m_border;
 236     m_hash_value += (m_hash_value<<5);
 237     m_hash_value += m_rasterize_sub;
 238     return m_hash_value;
 239 }
 240
 241
 242 //////////////////////////////////////////////////////////////////////////////////////////////
 243
 244 // ClipperAlphaMaskCacheKey
 245
 246 bool ClipperAlphaMaskCacheKey::operator==( const ClipperAlphaMaskCacheKey& key ) const
 247 {
 248     bool result = false;
 249     if (m_clipper==key.m_clipper)
 250     {
 251         result = true;
 252     }
 253     else if ( m_clipper!=NULL && key.m_clipper!=NULL )
 254     {
 255         const CClipper& lhs = *m_clipper;
 256         const CClipper& rhs = *key.m_clipper;
 257         result = (lhs.m_polygon->m_str == rhs.m_polygon->m_str
 258             && fabs(lhs.m_polygon->m_scalex - rhs.m_polygon->m_scalex) < 0.000001
 259             && fabs(lhs.m_polygon->m_scaley - rhs.m_polygon->m_scaley) < 0.000001
 260             && lhs.m_size == rhs.m_size
 261             && lhs.m_inverse == rhs.m_inverse
 262             && lhs.m_effectType == rhs.m_effectType
 263             && lhs.m_effect == rhs.m_effect);//fix me: unsafe code
 264     }
 265     return result;
 266 }
 267
 268 ULONG ClipperAlphaMaskCacheKey::UpdateHashValue()
 269 {
 270     if(m_clipper)
 271         m_hash_value = ClipperTraits::Hash(*m_clipper);
 272     else
 273         m_hash_value = 0;
 274     return m_hash_value;
 275 }
 276
 277
 278 //////////////////////////////////////////////////////////////////////////////////////////////
 279
 280 // DrawItemHashKey
 281
 282 ULONG DrawItemHashKey::UpdateHashValue()
 283 {
 284     m_hash_value = m_overlay_key->GetHashValue();
 285     m_hash_value += (m_hash_value<<5);
 286     m_hash_value += m_clipper_key.GetHashValue();
 287     m_hash_value += (m_hash_value<<5);
 288     m_hash_value += hash_value(m_clip_rect);
 289     m_hash_value += (m_hash_value<<5);
 290     m_hash_value += m_fBorder;
 291     m_hash_value += (m_hash_value<<5);
 292     m_hash_value += m_fBody;
 293     m_hash_value += m_switchpts[0];
 294     return m_hash_value;
 295 }
 296
 297 DrawItemHashKey::DrawItemHashKey( const DrawItem& draw_item)
 298     : m_overlay_key( draw_item.overlay_paint_machine->GetHashKey() )
 299     , m_clipper_key( draw_item.clipper->GetHashKey() )
 300     , m_clip_rect(draw_item.clip_rect)
 301     , m_xsub(draw_item.xsub)
 302     , m_ysub(draw_item.ysub)
 303     , m_fBody(draw_item.fBody)
 304     , m_fBorder(draw_item.fBorder)
 305 {
 306     for(int i=0;i<countof(m_switchpts);i++)
 307         m_switchpts[i] = draw_item.switchpts[i];
 308 }
 309
 310 bool DrawItemHashKey::operator==( const DrawItemHashKey& key ) const
 311 {
 312     return (this==&key) || (
 313         *m_overlay_key==*key.m_overlay_key &&
 314         m_clipper_key==key.m_clipper_key &&
 315         (m_clip_rect == key.m_clip_rect)==TRUE &&
 316         m_xsub == key.m_xsub &&
 317         m_ysub == key.m_ysub &&
 318         m_fBody == key.m_fBody &&
 319         m_fBorder == key.m_fBorder &&
 320         !memcmp(m_switchpts, key.m_switchpts, sizeof(m_switchpts)));
 321 }
 322
 323 //////////////////////////////////////////////////////////////////////////////////////////////
 324
 325 // GroupedDrawItemsHashKey
 326
 327 ULONG GroupedDrawItemsHashKey::UpdateHashValue()
 328 {
 329     m_hash_value = hash_value(m_clip_rect);
 330     ASSERT(m_key);
 331     for( unsigned i=0;i<m_key->GetCount();i++)
 332     {
 333         m_hash_value += (m_hash_value<<5);
 334         m_hash_value += m_key->GetAt(i)->GetHashValue();
 335     }
 336     return m_hash_value;
 337 }
 338
 339 bool GroupedDrawItemsHashKey::operator==( const GroupedDrawItemsHashKey& key ) const
 340 {
 341     if (this==&key)
 342     {
 343         return true;
 344     }
 345     else if ( m_key->GetCount()!=key.m_key->GetCount() || m_clip_rect!=key.m_clip_rect)
 346     {
 347         return false;
 348     }
 349     else
 350     {
 351         for( unsigned i=0;i<m_key->GetCount();i++)
 352         {
 353             if( !(*m_key->GetAt(i) == *key.m_key->GetAt(i)) )
 354                 return false;
 355         }
 356         return true;
 357     }
 358     return true;
 359 }
 360
 361
 362 //////////////////////////////////////////////////////////////////////////////////////////////
 363
 364 // CacheManager
 365
 366 struct Caches
 367 {
 368 public:
 369     Caches()
 370     {
 371         s_bitmap_cache = NULL;
 372         s_clipper_alpha_mask_cache = NULL;
 373
 374         s_text_info_cache = NULL;
 375         s_path_data_mru_cache = NULL;
 376         s_scan_line_data_2_mru_cache = NULL;
 377         s_overlay_no_blur_mru_cache = NULL;
 378         s_overlay_mru_cache = NULL;
 379
 380         s_scan_line_data_mru_cache = NULL;
 381         s_overlay_no_offset_mru_cache = NULL;
 382
 383         s_subpixel_variance_cache = NULL;
 384         s_ass_tag_list_cache = NULL;
 385     }
 386     ~Caches()
 387     {
 388         delete s_bitmap_cache;
 389         delete s_clipper_alpha_mask_cache;
 390
 391         delete s_text_info_cache;
 392         delete s_path_data_mru_cache;
 393         delete s_scan_line_data_2_mru_cache;
 394         delete s_overlay_no_blur_mru_cache;
 395         delete s_overlay_mru_cache;
 396
 397         delete s_scan_line_data_mru_cache;
 398         delete s_overlay_no_offset_mru_cache;
 399
 400         delete s_subpixel_variance_cache;
 401         delete s_ass_tag_list_cache;
 402     }
 403 public:
 404     BitmapMruCache* s_bitmap_cache;
 405     ClipperAlphaMaskMruCache* s_clipper_alpha_mask_cache;
 406
 407     TextInfoMruCache* s_text_info_cache;
 408     AssTagListMruCache* s_ass_tag_list_cache;
 409
 410     ScanLineDataMruCache* s_scan_line_data_mru_cache;
 411     OverlayNoOffsetMruCache* s_overlay_no_offset_mru_cache;
 412
 413     OverlayMruCache* s_subpixel_variance_cache;
 414     OverlayMruCache* s_overlay_mru_cache;
 415     OverlayNoBlurMruCache* s_overlay_no_blur_mru_cache;
 416     PathDataMruCache* s_path_data_mru_cache;
 417     ScanLineData2MruCache* s_scan_line_data_2_mru_cache;
 418 };
 419
 420 static Caches s_caches;
 421
 422 OverlayMruCache* CacheManager::GetOverlayMruCache()
 423 {
 424     if(s_caches.s_overlay_mru_cache==NULL)
 425     {
 426         s_caches.s_overlay_mru_cache = new OverlayMruCache(OVERLAY_CACHE_ITEM_NUM);
 427     }
 428     return s_caches.s_overlay_mru_cache;
 429 }
 430
 431 PathDataMruCache* CacheManager::GetPathDataMruCache()
 432 {
 433     if (s_caches.s_path_data_mru_cache==NULL)
 434     {
 435         s_caches.s_path_data_mru_cache = new PathDataMruCache(PATH_CACHE_ITEM_NUM);
 436     }
 437     return s_caches.s_path_data_mru_cache;
 438 }
 439
 440 OverlayNoBlurMruCache* CacheManager::GetOverlayNoBlurMruCache()
 441 {
 442     if(s_caches.s_overlay_no_blur_mru_cache==NULL)
 443     {
 444         s_caches.s_overlay_no_blur_mru_cache = new OverlayNoBlurMruCache(OVERLAY_NO_BLUR_CACHE_ITEM_NUM);
 445     }
 446     return s_caches.s_overlay_no_blur_mru_cache;
 447 }
 448
 449 ScanLineData2MruCache* CacheManager::GetScanLineData2MruCache()
 450 {
 451     if(s_caches.s_scan_line_data_2_mru_cache==NULL)
 452     {
 453         s_caches.s_scan_line_data_2_mru_cache = new ScanLineData2MruCache(SCAN_LINE_DATA_CACHE_ITEM_NUM);
 454     }
 455     return s_caches.s_scan_line_data_2_mru_cache;
 456 }
 457
 458 OverlayMruCache* CacheManager::GetSubpixelVarianceCache()
 459 {
 460     if(s_caches.s_subpixel_variance_cache==NULL)
 461     {
 462         s_caches.s_subpixel_variance_cache = new OverlayMruCache(SUBPIXEL_VARIANCE_CACHE_ITEM_NUM);
 463     }
 464     return s_caches.s_subpixel_variance_cache;
 465 }
 466
 467 ScanLineDataMruCache* CacheManager::GetScanLineDataMruCache()
 468 {
 469     if(s_caches.s_scan_line_data_mru_cache==NULL)
 470     {
 471         s_caches.s_scan_line_data_mru_cache = new ScanLineDataMruCache(SCAN_LINE_DATA_CACHE_ITEM_NUM);
 472     }
 473     return s_caches.s_scan_line_data_mru_cache;
 474 }
 475
 476 OverlayNoOffsetMruCache* CacheManager::GetOverlayNoOffsetMruCache()
 477 {
 478     if(s_caches.s_overlay_no_offset_mru_cache==NULL)
 479     {
 480         s_caches.s_overlay_no_offset_mru_cache = new OverlayNoOffsetMruCache(OVERLAY_NO_BLUR_CACHE_ITEM_NUM);
 481     }
 482     return s_caches.s_overlay_no_offset_mru_cache;
 483 }
 484
 485 AssTagListMruCache* CacheManager::GetAssTagListMruCache()
 486 {
 487     if(s_caches.s_ass_tag_list_cache==NULL)
 488     {
 489         s_caches.s_ass_tag_list_cache = new AssTagListMruCache(ASS_TAG_LIST_CACHE_ITEM_NUM);
 490     }
 491     return s_caches.s_ass_tag_list_cache;
 492 }
 493
 494 TextInfoMruCache* CacheManager::GetTextInfoCache()
 495 {
 496     if(s_caches.s_text_info_cache==NULL)
 497     {
 498         s_caches.s_text_info_cache = new TextInfoMruCache(TEXT_INFO_CACHE_ITEM_NUM);
 499     }
 500     return s_caches.s_text_info_cache;
 501 }
 502
 503 ClipperAlphaMaskMruCache* CacheManager::GetClipperAlphaMaskMruCache()
 504 {
 505     if(s_caches.s_clipper_alpha_mask_cache==NULL)
 506     {
 507         s_caches.s_clipper_alpha_mask_cache = new ClipperAlphaMaskMruCache(CLIPPER_MRU_CACHE_ITEM_NUM);
 508     }
 509     return s_caches.s_clipper_alpha_mask_cache;
 510 }
 511
 512 BitmapMruCache* CacheManager::GetBitmapMruCache()
 513 {
 514     if (s_caches.s_bitmap_cache==NULL)
 515     {
 516         s_caches.s_bitmap_cache = new BitmapMruCache(BITMAP_MRU_CACHE_ITEM_NUM);
 517     }
 518     return s_caches.s_bitmap_cache;
 519 }