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