src/subtitles/cache_manager.cpp

   1 /************************************************************************/
   2 /* author: xy                                                           */
   3 /* date: 20110926                                                       */
   4 /************************************************************************/
   5 #include "StdAfx.h"
   6 #include "cache_manager.h"
   7
   8 std::size_t hash_value(const CWord& key)
   9 {
  10     return( CStringElementTraits<CString>::Hash(key.m_str) );
  11 }
  12
  13 std::size_t hash_value(const CWordCacheKey& key)
  14 {
  15     return( CStringElementTraits<CString>::Hash(key.m_str) );
  16 }
  17
  18 std::size_t hash_value(const OverlayKey& key)
  19 {
  20     return( CStringElementTraits<CString>::Hash(key.m_str) ^ key.m_p.x ^ key.m_p.y );
  21 }
  22
  23 std::size_t hash_value( const PathDataCacheKey& key )
  24 {
  25     return( CStringElementTraits<CString>::Hash(key.m_str) );
  26 }
  27
  28 std::size_t hash_value( const ScanLineDataCacheKey& key )
  29 {
  30     return hash_value(static_cast<PathDataCacheKey>(key)) ^ key.m_org.x ^ key.m_org.y;
  31 }
  32
  33 std::size_t hash_value( const OverlayNoBlurKey& key )
  34 {
  35     return hash_value(static_cast<ScanLineDataCacheKey>(key)) ^ key.m_p.x ^ key.m_p.y;
  36 }
  37
  38 CWordCacheKey::CWordCacheKey( const CWord& word )
  39 {
  40     m_str = word.m_str;
  41     m_style = word.m_style;
  42     m_ktype = word.m_ktype;
  43     m_kstart = word.m_kstart;
  44     m_kend = word.m_kend;
  45 }
  46
  47 CWordCacheKey::CWordCacheKey( const CWordCacheKey& key )
  48 {
  49     m_str = key.m_str;
  50     m_style = key.m_style;
  51     m_ktype = key.m_ktype;
  52     m_kstart = key.m_kstart;
  53     m_kend = key.m_kend;
  54 }
  55
  56 CWordCacheKey::CWordCacheKey( const FwSTSStyle& style, const CStringW& str, int ktype, int kstart, int kend )
  57     :m_style(style),m_str(str),m_ktype(ktype),m_kstart(kstart),m_kend(m_kend)
  58 {
  59
  60 }
  61
  62 bool CWordCacheKey::operator==( const CWordCacheKey& key ) const
  63 {
  64     return (m_str == key.m_str &&
  65         m_style == key.m_style &&
  66         m_ktype == key.m_ktype &&
  67         m_kstart == key.m_kstart &&
  68         m_kend == key.m_kend);
  69 }
  70
  71 bool CWordCacheKey::operator==(const CWord& key)const
  72 {
  73     return (m_str == key.m_str &&
  74         m_style == key.m_style &&
  75         m_ktype == key.m_ktype &&
  76         m_kstart == key.m_kstart &&
  77         m_kend == key.m_kend);
  78 }
  79
  80 //////////////////////////////////////////////////////////////////////////////////////////////
  81
  82 // PathDataCacheKey
  83
  84 bool PathDataCacheKey::CompareSTSStyle( const STSStyle& lhs, const STSStyle& rhs )
  85 {
  86     return lhs.charSet==rhs.charSet &&
  87         lhs.fontName==rhs.fontName &&
  88         lhs.fontSize==rhs.fontSize &&
  89         lhs.fontWeight==rhs.fontWeight &&
  90         lhs.fItalic==rhs.fItalic &&
  91         lhs.fUnderline==rhs.fUnderline &&
  92         lhs.fStrikeOut==rhs.fStrikeOut;
  93 }
  94
  95 //////////////////////////////////////////////////////////////////////////////////////////////
  96
  97 // ScanLineDataCacheKey
  98
  99 bool ScanLineDataCacheKey::operator==( const ScanLineDataCacheKey& key ) const
 100 {
 101     return (static_cast<PathDataCacheKey>(*this)==static_cast<PathDataCacheKey>(key))
 102         && this->m_style.get().borderStyle == key.m_style.get().borderStyle
 103         && fabs(this->m_style.get().outlineWidthX - key.m_style.get().outlineWidthX) < 0.000001
 104         && fabs(this->m_style.get().outlineWidthY - key.m_style.get().outlineWidthY) < 0.000001
 105         && fabs(this->m_style.get().fontScaleX - key.m_style.get().fontScaleX) < 0.000001
 106         && fabs(this->m_style.get().fontScaleY - key.m_style.get().fontScaleY) < 0.000001
 107         && fabs(this->m_style.get().fontAngleX - key.m_style.get().fontAngleX) < 0.000001
 108         && fabs(this->m_style.get().fontAngleY - key.m_style.get().fontAngleY) < 0.000001
 109         && fabs(this->m_style.get().fontAngleZ - key.m_style.get().fontAngleZ) < 0.000001
 110         && fabs(this->m_style.get().fontShiftX - key.m_style.get().fontShiftX) < 0.000001
 111         && fabs(this->m_style.get().fontShiftY - key.m_style.get().fontShiftY) < 0.000001
 112         && (m_org.x==key.m_org.x) && (m_org.y==key.m_org.y);
 113 }
 114
 115 //////////////////////////////////////////////////////////////////////////////////////////////
 116
 117 // OverlayNoBlurKey
 118
 119 bool OverlayNoBlurKey::operator==( const OverlayNoBlurKey& key ) const
 120 {
 121     return (static_cast<ScanLineDataCacheKey>(*this)==static_cast<ScanLineDataCacheKey>(key))
 122         && (m_p.x==key.m_p.x) && (m_p.y==key.m_p.y);
 123 }
 124
 125 //////////////////////////////////////////////////////////////////////////////////////////////
 126
 127 // CacheManager
 128
 129 CWordMruCache* CacheManager::s_word_mru_cache = NULL;
 130 PathDataMruCache* CacheManager::s_path_data_mru_cache = NULL;
 131 ScanLineDataMruCache* CacheManager::s_scan_line_data_mru_cache = NULL;
 132 OverlayNoBlurMruCache* CacheManager::s_overlay_no_blur_mru_cache = NULL;
 133 OverlayMruCache* CacheManager::s_overlay_mru_cache = NULL;
 134
 135 OverlayMruCache* CacheManager::GetOverlayMruCache()
 136 {
 137     if(s_overlay_mru_cache==NULL)
 138     {
 139         s_overlay_mru_cache = new OverlayMruCache(OVERLAY_CACHE_ITEM_NUM);
 140     }
 141     return s_overlay_mru_cache;
 142 }
 143
 144 PathDataMruCache* CacheManager::GetPathDataMruCache()
 145 {
 146     if (s_path_data_mru_cache==NULL)
 147     {
 148         s_path_data_mru_cache = new PathDataMruCache(PATH_CACHE_ITEM_NUM);
 149     }
 150     return s_path_data_mru_cache;
 151 }
 152
 153 CWordMruCache* CacheManager::GetCWordMruCache()
 154 {
 155     if(s_word_mru_cache==NULL)
 156     {
 157         s_word_mru_cache = new CWordMruCache(WORD_CACHE_ITEM_NUM);
 158     }
 159     return s_word_mru_cache;
 160 }
 161
 162 OverlayNoBlurMruCache* CacheManager::GetOverlayNoBlurMruCache()
 163 {
 164     if(s_overlay_no_blur_mru_cache==NULL)
 165     {
 166         s_overlay_no_blur_mru_cache = new OverlayNoBlurMruCache(OVERLAY_NO_BLUR_CACHE_ITEM_NUM);
 167     }
 168     return s_overlay_no_blur_mru_cache;
 169 }
 170
 171 ScanLineDataMruCache* CacheManager::GetScanLineDataMruCache()
 172 {
 173     if(s_scan_line_data_mru_cache==NULL)
 174     {
 175         s_scan_line_data_mru_cache = new ScanLineDataMruCache(SCAN_LINE_DATA_CACHE_ITEM_NUM);
 176     }
 177     return s_scan_line_data_mru_cache;
 178 }
 179