Added scaling for symbols.

Updated for vdr-1.7.18.
2023-10-10 13:36:53 +02:00 · 2011-04-20 17:41:17 +03:00 · 2011-04-20 17:41:17 +03:00 · de92daf5f0
commit de92daf5f0
parent 0fd4062c76
5 changed files with 222 additions and 94 deletions
--- a/5
+++ b/5
@ -410,6 +410,7 @@ VDR Plugin 'femon' Revision History
 - Fixed detection of replaying.
 - Added support for LDFLAGS.

-2011-03-13: Version 1.7.10
+2011-04-20: Version 1.7.10

- Updated for vdr-1.7.17.
+- Updated for vdr-1.7.18.
+- Added scaling for symbols.
--- a/femon.c
+++ b/femon.c
@ -14,8 +14,8 @@
 #include "femonservice.h"
 #include "femontools.h"

-#if defined(APIVERSNUM) && APIVERSNUM < 10717
-#error "VDR-1.7.17 API version or greater is required!"
+#if defined(APIVERSNUM) && APIVERSNUM < 10718
+#error "VDR-1.7.18 API version or greater is required!"
 #endif

 static const char VERSION[]       = "1.7.10";
--- a/femonosd.c
+++ b/femonosd.c
@ -25,8 +25,9 @@
 #define OSDROWHEIGHT              m_Font->Height()        // in pixels
 #define OSDINFOHEIGHT             (OSDROWHEIGHT * 13)     // in pixels (13 rows)
 #define OSDSTATUSHEIGHT           (OSDROWHEIGHT * 6)      // in pixels (6 rows)
-#define OSDSPACING                5
-#define OSDROUNDING               10
+#define OSDSYMBOL(id)             femonSymbols.Get(id)
+#define OSDSPACING                femonSymbols.GetSpacing()
+#define OSDROUNDING               femonSymbols.GetRounding()
 #define IS_OSDROUNDING            (femonConfig.skin == eFemonSkinElchi)
 #define IS_OSDRESOLUTION(r1, r2)  (abs(r1 - r2) < 20)
 #define OSDINFOWIN_Y(offset)      (femonConfig.position ? (OSDHEIGHT - OSDINFOHEIGHT + offset) : offset)
@ -193,12 +194,13 @@ cFemonOsd::cFemonOsd()
  memset(&m_FrontendStatus, 0, sizeof(m_FrontendStatus));
  memset(&m_FrontendInfo, 0, sizeof(m_FrontendInfo));
  m_SvdrpConnection.handle = -1;
+  femonSymbols.Refresh();
  m_Font = cFont::CreateFont(Setup.FontSml, min(max(Setup.FontSmlSize, MINFONTSIZE), MAXFONTSIZE));
  if (!m_Font || !m_Font->Height()) {
     m_Font = new cFemonDummyFont;
     error("cFemonOsd::cFemonOsd() cannot create required font.");
     }
-  tmp = 5 * bmSymbol[SYMBOL_LOCK].Width() + 6 * OSDSPACING;
+  tmp = 5 * OSDSYMBOL(SYMBOL_LOCK).Width() + 6 * OSDSPACING;
  if (OSDWIDTH < tmp) {
     error("cFemonOsd::cFemonOsd() OSD width (%d) smaller than required (%d).", OSDWIDTH, tmp);
     OSDWIDTH = tmp;
@ -249,84 +251,84 @@ void cFemonOsd::DrawStatusWindow(void)
  if (m_Osd && channel) {
     OSDDRAWSTATUSTITLEBAR(*cString::sprintf("%d%s %s", m_Number ? m_Number : channel->Number(), m_Number ? "-" : "", channel->ShortName(true)));
     if (m_SvdrpFrontend >= 0) {
-        bm = &bmSymbol[SYMBOL_SVDRP];
+        bm = &OSDSYMBOL(SYMBOL_SVDRP);
        OSDDRAWSTATUSBM(OSDSPACING);
        }
     switch (cDevice::ActualDevice()->CardIndex()) {
-       case 1:  bm = &bmSymbol[SYMBOL_ONE];   break;
-       case 2:  bm = &bmSymbol[SYMBOL_TWO];   break;
-       case 3:  bm = &bmSymbol[SYMBOL_THREE]; break;
-       case 4:  bm = &bmSymbol[SYMBOL_FOUR];  break;
-       case 5:  bm = &bmSymbol[SYMBOL_FIVE];  break;
-       case 6:  bm = &bmSymbol[SYMBOL_SIX];   break;
-       case 7:  bm = &bmSymbol[SYMBOL_SEVEN]; break;
-       case 8:  bm = &bmSymbol[SYMBOL_EIGHT]; break;
-       default: bm = &bmSymbol[SYMBOL_ZERO];  break;
+       case 1:  bm = &OSDSYMBOL(SYMBOL_ONE);   break;
+       case 2:  bm = &OSDSYMBOL(SYMBOL_TWO);   break;
+       case 3:  bm = &OSDSYMBOL(SYMBOL_THREE); break;
+       case 4:  bm = &OSDSYMBOL(SYMBOL_FOUR);  break;
+       case 5:  bm = &OSDSYMBOL(SYMBOL_FIVE);  break;
+       case 6:  bm = &OSDSYMBOL(SYMBOL_SIX);   break;
+       case 7:  bm = &OSDSYMBOL(SYMBOL_SEVEN); break;
+       case 8:  bm = &OSDSYMBOL(SYMBOL_EIGHT); break;
+       default: bm = &OSDSYMBOL(SYMBOL_ZERO);  break;
       }
     OSDDRAWSTATUSBM(OSDSPACING);
-     bm = &bmSymbol[SYMBOL_DEVICE];
+     bm = &OSDSYMBOL(SYMBOL_DEVICE);
     OSDDRAWSTATUSBM(0);
     if (IS_AUDIO_TRACK(track)) {
        switch (int(track - ttAudioFirst)) {
-           case 1:  bm = &bmSymbol[SYMBOL_ONE];   break;
-           case 2:  bm = &bmSymbol[SYMBOL_TWO];   break;
-           case 3:  bm = &bmSymbol[SYMBOL_THREE]; break;
-           case 4:  bm = &bmSymbol[SYMBOL_FOUR];  break;
-           case 5:  bm = &bmSymbol[SYMBOL_FIVE];  break;
-           case 6:  bm = &bmSymbol[SYMBOL_SIX];   break;
-           case 7:  bm = &bmSymbol[SYMBOL_SEVEN]; break;
-           case 8:  bm = &bmSymbol[SYMBOL_EIGHT]; break;
-           default: bm = &bmSymbol[SYMBOL_ZERO];  break;
+           case 1:  bm = &OSDSYMBOL(SYMBOL_ONE);   break;
+           case 2:  bm = &OSDSYMBOL(SYMBOL_TWO);   break;
+           case 3:  bm = &OSDSYMBOL(SYMBOL_THREE); break;
+           case 4:  bm = &OSDSYMBOL(SYMBOL_FOUR);  break;
+           case 5:  bm = &OSDSYMBOL(SYMBOL_FIVE);  break;
+           case 6:  bm = &OSDSYMBOL(SYMBOL_SIX);   break;
+           case 7:  bm = &OSDSYMBOL(SYMBOL_SEVEN); break;
+           case 8:  bm = &OSDSYMBOL(SYMBOL_EIGHT); break;
+           default: bm = &OSDSYMBOL(SYMBOL_ZERO);  break;
           }
        OSDDRAWSTATUSBM(OSDSPACING);
        switch (cDevice::PrimaryDevice()->GetAudioChannel()) {
-           case 1:  bm = &bmSymbol[SYMBOL_MONO_LEFT];  break;
-           case 2:  bm = &bmSymbol[SYMBOL_MONO_RIGHT]; break;
-           default: bm = &bmSymbol[SYMBOL_STEREO];     break;
+           case 1:  bm = &OSDSYMBOL(SYMBOL_MONO_LEFT);  break;
+           case 2:  bm = &OSDSYMBOL(SYMBOL_MONO_RIGHT); break;
+           default: bm = &OSDSYMBOL(SYMBOL_STEREO);     break;
           }
        OSDDRAWSTATUSBM(0);
        }
     else if (m_Receiver && m_Receiver->AC3Valid() && IS_DOLBY_TRACK(track)) {
-        if      (m_Receiver->AC3_5_1()) bm = &bmSymbol[SYMBOL_DD51];
-        else if (m_Receiver->AC3_2_0()) bm = &bmSymbol[SYMBOL_DD20];
-        else                            bm = &bmSymbol[SYMBOL_DD];
+        if      (m_Receiver->AC3_5_1()) bm = &OSDSYMBOL(SYMBOL_DD51);
+        else if (m_Receiver->AC3_2_0()) bm = &OSDSYMBOL(SYMBOL_DD20);
+        else                            bm = &OSDSYMBOL(SYMBOL_DD);
        OSDDRAWSTATUSBM(OSDSPACING);
        }
     if (m_Receiver) {
        if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 1080))
-           bm = &bmSymbol[SYMBOL_FORMAT_1080];
+           bm = &OSDSYMBOL(SYMBOL_FORMAT_1080);
        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 720))
-           bm = &bmSymbol[SYMBOL_FORMAT_720];
+           bm = &OSDSYMBOL(SYMBOL_FORMAT_720);
        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 576))
-           bm = &bmSymbol[SYMBOL_FORMAT_576];
+           bm = &OSDSYMBOL(SYMBOL_FORMAT_576);
        else if (IS_OSDRESOLUTION(m_Receiver->VideoVerticalSize(), 480))
-           bm = &bmSymbol[SYMBOL_FORMAT_480];
+           bm = &OSDSYMBOL(SYMBOL_FORMAT_480);
        else
           bm = NULL;
        OSDDRAWSTATUSBM(OSDSPACING);
        switch (m_Receiver->VideoCodec()) {
-           case VIDEO_CODEC_MPEG2: bm = &bmSymbol[SYMBOL_MPEG2]; break;
-           case VIDEO_CODEC_H264:  bm = &bmSymbol[SYMBOL_H264];  break;
-           default:                bm = NULL;                    break;
+           case VIDEO_CODEC_MPEG2: bm = &OSDSYMBOL(SYMBOL_MPEG2); break;
+           case VIDEO_CODEC_H264:  bm = &OSDSYMBOL(SYMBOL_H264);  break;
+           default:                bm = NULL;                     break;
           }
        OSDDRAWSTATUSBM(OSDSPACING);
        switch (m_Receiver->VideoFormat()) {
-           case VIDEO_FORMAT_PAL:  bm = &bmSymbol[SYMBOL_PAL];  break;
-           case VIDEO_FORMAT_NTSC: bm = &bmSymbol[SYMBOL_NTSC]; break;
-           default:                bm = NULL;                   break;
+           case VIDEO_FORMAT_PAL:  bm = &OSDSYMBOL(SYMBOL_PAL);  break;
+           case VIDEO_FORMAT_NTSC: bm = &OSDSYMBOL(SYMBOL_NTSC); break;
+           default:                bm = NULL;                    break;
           }
        OSDDRAWSTATUSBM(OSDSPACING);
        switch (m_Receiver->VideoAspectRatio()) {
-           case VIDEO_ASPECT_RATIO_1_1:    bm = &bmSymbol[SYMBOL_AR_1_1];    break;
-           case VIDEO_ASPECT_RATIO_4_3:    bm = &bmSymbol[SYMBOL_AR_4_3];    break;
-           case VIDEO_ASPECT_RATIO_16_9:   bm = &bmSymbol[SYMBOL_AR_16_9];   break;
-           case VIDEO_ASPECT_RATIO_2_21_1: bm = &bmSymbol[SYMBOL_AR_2_21_1]; break;
-           default:                        bm = NULL;                        break;
+           case VIDEO_ASPECT_RATIO_1_1:    bm = &OSDSYMBOL(SYMBOL_AR_1_1);    break;
+           case VIDEO_ASPECT_RATIO_4_3:    bm = &OSDSYMBOL(SYMBOL_AR_4_3);    break;
+           case VIDEO_ASPECT_RATIO_16_9:   bm = &OSDSYMBOL(SYMBOL_AR_16_9);   break;
+           case VIDEO_ASPECT_RATIO_2_21_1: bm = &OSDSYMBOL(SYMBOL_AR_2_21_1); break;
+           default:                        bm = NULL;                         break;
           }
        OSDDRAWSTATUSBM(OSDSPACING);
        }
     if (channel->Ca() > 0xFF) {
-        bm = &bmSymbol[SYMBOL_ENCRYPTED];
+        bm = &OSDSYMBOL(SYMBOL_ENCRYPTED);
        OSDDRAWSTATUSBM(OSDSPACING);
        }
     offset += OSDROWHEIGHT;
@ -345,14 +347,14 @@ void cFemonOsd::DrawStatusWindow(void)
                         *cString::sprintf("%s:", (m_Receiver && m_Receiver->AC3Valid() && IS_DOLBY_TRACK(track)) ? tr("AC-3") : tr("Audio")),
                         *getBitrateKbits(m_Receiver ? ((m_Receiver->AC3Valid() && IS_DOLBY_TRACK(track)) ? m_Receiver->AC3Bitrate() : m_Receiver->AudioBitrate()) : (m_SvdrpFrontend >= 0 ? m_SvdrpAudioBitrate : -1.0)));
     offset += OSDROWHEIGHT;
-     x = bmSymbol[SYMBOL_LOCK].Width();
-     y = (OSDROWHEIGHT - bmSymbol[SYMBOL_LOCK].Height()) / 2;
+     x = OSDSYMBOL(SYMBOL_LOCK).Width();
+     y = (OSDROWHEIGHT - OSDSYMBOL(SYMBOL_LOCK).Height()) / 2;
     if (m_FrontendStatusValid) {
-        OSDDRAWSTATUSFRONTEND(1, bmSymbol[SYMBOL_LOCK],    FE_HAS_LOCK);
-        OSDDRAWSTATUSFRONTEND(2, bmSymbol[SYMBOL_SIGNAL],  FE_HAS_SIGNAL);
-        OSDDRAWSTATUSFRONTEND(3, bmSymbol[SYMBOL_CARRIER], FE_HAS_CARRIER);
-        OSDDRAWSTATUSFRONTEND(4, bmSymbol[SYMBOL_VITERBI], FE_HAS_VITERBI);
-        OSDDRAWSTATUSFRONTEND(5, bmSymbol[SYMBOL_SYNC],    FE_HAS_SYNC);
+        OSDDRAWSTATUSFRONTEND(1, OSDSYMBOL(SYMBOL_LOCK),    FE_HAS_LOCK);
+        OSDDRAWSTATUSFRONTEND(2, OSDSYMBOL(SYMBOL_SIGNAL),  FE_HAS_SIGNAL);
+        OSDDRAWSTATUSFRONTEND(3, OSDSYMBOL(SYMBOL_CARRIER), FE_HAS_CARRIER);
+        OSDDRAWSTATUSFRONTEND(4, OSDSYMBOL(SYMBOL_VITERBI), FE_HAS_VITERBI);
+        OSDDRAWSTATUSFRONTEND(5, OSDSYMBOL(SYMBOL_SYNC),    FE_HAS_SYNC);
        }
     OSDDRAWSTATUSBOTTOMBAR();
     m_Osd->Flush();
--- a/femonsymbol.c
+++ b/femonsymbol.c
@ -5,6 +5,8 @@
 *
 */

+#include <vdr/device.h>
+#include "femontools.h"
 #include "femonsymbol.h"

 #include "symbols/stereo.xpm"
@ -43,41 +45,140 @@
 #include "symbols/format576.xpm"
 #include "symbols/format480.xpm"

-cBitmap bmSymbol[SYMBOL_MAX_COUNT] =
+static cBitmap bmStereo(stereo_xpm);
+static cBitmap bmMonoLeft(monoleft_xpm);
+static cBitmap bmMonoRight(monoright_xpm);
+static cBitmap bmDolbyDigital(dolbydigital_xpm);
+static cBitmap bmDolbyDigital20(dolbydigital20_xpm);
+static cBitmap bmDolbyDigital51(dolbydigital51_xpm);
+static cBitmap bmMpeg2(mpeg2_xpm);
+static cBitmap bmH264(h264_xpm);
+static cBitmap bmPal(pal_xpm);
+static cBitmap bmNtsc(ntsc_xpm);
+static cBitmap bmEncrypted(encrypted_xpm);
+static cBitmap bmSvdrp(svdrp_xpm);
+static cBitmap bmLock(lock_xpm);
+static cBitmap bmSignal(signal_xpm);
+static cBitmap bmCarrier(carrier_xpm);
+static cBitmap bmViterbi(viterbi_xpm);
+static cBitmap bmSync(sync_xpm);
+static cBitmap bmAspectRatio11(ar11_xpm);
+static cBitmap bmAspectRatio169(ar169_xpm);
+static cBitmap bmAspectRatio2211(ar2211_xpm);
+static cBitmap bmAspectRatio43(ar43_xpm);
+static cBitmap bmDevice(device_xpm);
+static cBitmap bmZero(zero_xpm);
+static cBitmap bmOne(one_xpm);
+static cBitmap bmTwo(two_xpm);
+static cBitmap bmThree(three_xpm);
+static cBitmap bmFour(four_xpm);
+static cBitmap bmFive(five_xpm);
+static cBitmap bmSix(six_xpm);
+static cBitmap bmSeven(seven_xpm);
+static cBitmap bmEight(eight_xpm);
+static cBitmap bmFormat1080(format1080_xpm);
+static cBitmap bmFormat720(format720_xpm);
+static cBitmap bmFormat576(format576_xpm);
+static cBitmap bmFormat480(format480_xpm);
+
+cFemonSymbolCache femonSymbols;
+
+cFemonSymbolCache::cFemonSymbolCache()
+: xFactorM(1.0),
+  yFactorM(1.0),
+  antiAliasM(false)
 {
-  cBitmap(stereo_xpm),         // SYMBOL_STEREO
-  cBitmap(monoleft_xpm),       // SYMBOL_MONO_LEFT
-  cBitmap(monoright_xpm),      // SYMBOL_MONO_RIGHT
-  cBitmap(dolbydigital_xpm),   // SYMBOL_DD
-  cBitmap(dolbydigital20_xpm), // SYMBOL_DD20
-  cBitmap(dolbydigital51_xpm), // SYMBOL_DD51
-  cBitmap(mpeg2_xpm),          // SYMBOL_MPEG2
-  cBitmap(h264_xpm),           // SYMBOL_H264
-  cBitmap(pal_xpm),            // SYMBOL_PAL
-  cBitmap(ntsc_xpm),           // SYMBOL_NTSC
-  cBitmap(encrypted_xpm),      // SYMBOL_ENCRYPTED
-  cBitmap(svdrp_xpm),          // SYMBOL_SVDRP
-  cBitmap(lock_xpm),           // SYMBOL_LOCK
-  cBitmap(signal_xpm),         // SYMBOL_SIGNAL
-  cBitmap(carrier_xpm),        // SYMBOL_CARRIER
-  cBitmap(viterbi_xpm),        // SYMBOL_VITERBI
-  cBitmap(sync_xpm),           // SYMBOL_SYNC
-  cBitmap(ar11_xpm),           // SYMBOL_AR_1_1
-  cBitmap(ar169_xpm),          // SYMBOL_AR_16_9
-  cBitmap(ar2211_xpm),         // SYMBOL_AR_2_21_1
-  cBitmap(ar43_xpm),           // SYMBOL_AR_4_3
-  cBitmap(device_xpm),         // SYMBOL_DEVICE
-  cBitmap(zero_xpm),           // SYMBOL_ZERO
-  cBitmap(one_xpm),            // SYMBOL_ONE
-  cBitmap(two_xpm),            // SYMBOL_TWO
-  cBitmap(three_xpm),          // SYMBOL_THREE
-  cBitmap(four_xpm),           // SYMBOL_FOUR
-  cBitmap(five_xpm),           // SYMBOL_FIVE
-  cBitmap(six_xpm),            // SYMBOL_SIX
-  cBitmap(seven_xpm),          // SYMBOL_SEVEN
-  cBitmap(eight_xpm),          // SYMBOL_EIGHT
-  cBitmap(format1080_xpm),     // SYMBOL_FORMAT_1080
-  cBitmap(format720_xpm),      // SYMBOL_FORMAT_720
-  cBitmap(format576_xpm),      // SYMBOL_FORMAT_576
-  cBitmap(format480_xpm)       // SYMBOL_FORMAT_480
-};
+  Populate();
+}
+
+cFemonSymbolCache::~cFemonSymbolCache()
+{
+  Flush();
+}
+
+void cFemonSymbolCache::Refresh()
+{
+  int width, height;
+  double aspect, xfactor, yfactor;
+  cDevice::PrimaryDevice()->GetOsdSize(width, height, aspect);
+  debug("cFemonSymbolCache::Refresh(): %dx%d", width, height);
+  xfactor = (double)width / DEFAULT_WIDTH;
+  yfactor = (double)height / DEFAULT_HEIGHT;
+  if (!DoubleEqual(xfactor, xFactorM) || !DoubleEqual(yfactor, yFactorM)) {
+     xFactorM = xfactor;
+     yFactorM = yfactor;
+     Populate();
+     }
+}
+
+bool cFemonSymbolCache::Populate(void)
+{
+  debug("cFemonSymbolCache::Populate(): %.02fx%.02f ", xFactorM, yFactorM);
+  if (!DoubleEqual(0.0, xFactorM) || !DoubleEqual(0.0, yFactorM)) {
+     Flush();
+
+     // pushing order must follow the enumeration
+     cacheM.push_back(bmStereo.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_STEREO
+     cacheM.push_back(bmMonoLeft.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_MONO_LEFT
+     cacheM.push_back(bmMonoRight.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_MONO_RIGHT
+     cacheM.push_back(bmDolbyDigital.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_DD
+     cacheM.push_back(bmDolbyDigital20.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_DD20
+     cacheM.push_back(bmDolbyDigital51.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_DD51
+     cacheM.push_back(bmMpeg2.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_MPEG2
+     cacheM.push_back(bmH264.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_H264
+     cacheM.push_back(bmPal.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_PAL
+     cacheM.push_back(bmNtsc.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_NTSC
+     cacheM.push_back(bmEncrypted.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_ENCRYPTED
+     cacheM.push_back(bmSvdrp.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_SVDRP
+     cacheM.push_back(bmLock.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_LOCK
+     cacheM.push_back(bmSignal.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_SIGNAL
+     cacheM.push_back(bmCarrier.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_CARRIER
+     cacheM.push_back(bmViterbi.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_VITERBI
+     cacheM.push_back(bmSync.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_SYNC
+     cacheM.push_back(bmAspectRatio11.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_AR_1_1
+     cacheM.push_back(bmAspectRatio169.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_AR_16_9
+     cacheM.push_back(bmAspectRatio2211.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_AR_2_21_1
+     cacheM.push_back(bmAspectRatio43.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_AR_4_3
+     cacheM.push_back(bmDevice.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_DEVICE
+     cacheM.push_back(bmZero.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_ZERO
+     cacheM.push_back(bmOne.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_ONE
+     cacheM.push_back(bmTwo.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_TWO
+     cacheM.push_back(bmThree.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_THREE
+     cacheM.push_back(bmFour.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FOUR
+     cacheM.push_back(bmFive.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FIVE
+     cacheM.push_back(bmSix.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_SIX
+     cacheM.push_back(bmSeven.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_SEVEN
+     cacheM.push_back(bmEight.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_EIGHT
+     cacheM.push_back(bmFormat1080.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_1080
+     cacheM.push_back(bmFormat720.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_720
+     cacheM.push_back(bmFormat576.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_576
+     cacheM.push_back(bmFormat480.Scaled(xFactorM, yFactorM, antiAliasM)); // SYMBOL_FORMAT_480
+
+     return true;
+     }
+
+  return false;
+}
+
+bool cFemonSymbolCache::Flush(void)
+{
+  debug("cFemonSymbolCache::Flush()");
+  if (!cacheM.empty()) {
+     for (unsigned int i = 0; i < cacheM.size(); ++i) {
+         cBitmap *bmp = cacheM[i];
+         DELETENULL(bmp);
+         }
+     cacheM.clear();
+     }
+  return true;
+}
+
+cBitmap& cFemonSymbolCache::Get(unsigned int symbolP)
+{
+  cBitmap *bitmapM = NULL;
+
+  if (symbolP < cacheM.size())
+     bitmapM = cacheM[symbolP];
+
+  return *bitmapM;
+}
--- a/femonsymbol.h
+++ b/femonsymbol.h
@ -8,6 +8,7 @@
 #ifndef __FEMONSYMBOL_H
 #define __FEMONSYMBOL_H

+#include <vector>
 #include <vdr/osd.h>

 enum eSymbols {
@ -49,6 +50,29 @@ enum eSymbols {
  SYMBOL_MAX_COUNT
  };

-extern cBitmap bmSymbol[SYMBOL_MAX_COUNT];
+class cFemonSymbolCache {
+private:
+  enum {
+    DEFAULT_SPACING  = 5,
+    DEFAULT_ROUNDING = 10,
+    DEFAULT_HEIGHT   = 576,
+    DEFAULT_WIDTH    = 720
+  };
+  double xFactorM;
+  double yFactorM;
+  bool antiAliasM;
+  std::vector<cBitmap*> cacheM;
+  bool Populate(void);
+  bool Flush(void);
+public:
+  cFemonSymbolCache();
+  ~cFemonSymbolCache();
+  void Refresh();
+  cBitmap& Get(unsigned int symbolP);
+  int GetSpacing()  { return yFactorM * DEFAULT_SPACING; }
+  int GetRounding() { return yFactorM * DEFAULT_ROUNDING; }
+};
+
+extern cFemonSymbolCache femonSymbols;

 #endif // __FEMONSYMBOL_H