rework singleton class

18 files changed, 191 insertions, 182 deletions

diff --git a/dxr3.c b/dxr3.c
index 6508349..3da4f79 100644
--- a/dxr3.c
+++ b/dxr3.c
@@ -29,22 +29,22 @@ eOSState cDxr3OsdItem::ProcessKey(eKeys Key)
 	switch (m_item)
 	{
 	case DXR3_RESET_HARDWARE:
-	    cDxr3Interface::Instance().ResetHardware();
+	    cDxr3Interface::instance()->ResetHardware();
 	    //cDxr3Device::Instance().Reset();
 	    break;
 
 	case DXR3_FORCE_LETTER_BOX:
-	    cDxr3ConfigData::Instance().SetForceLetterBox(
-		!cDxr3ConfigData::Instance().GetForceLetterBox());
+	    cDxr3ConfigData::instance()->SetForceLetterBox(
+		!cDxr3ConfigData::instance()->GetForceLetterBox());
 	    break;
 
 	case DXR3_ANALOG_OUT:
-	    cDxr3ConfigData::Instance().SetUseDigitalOut(0);
+	    cDxr3ConfigData::instance()->SetUseDigitalOut(0);
 	    //cDxr3Device::Instance().Reset();
 	    break;
 
 	case DXR3_DIGITAL_OUT:
-	    cDxr3ConfigData::Instance().SetUseDigitalOut(1);
+	    cDxr3ConfigData::instance()->SetUseDigitalOut(1);
 	    //cDxr3Device::Instance().Reset();
 	    break;
 	}
@@ -57,34 +57,34 @@ eOSState cDxr3OsdItem::ProcessKey(eKeys Key)
 // setup menu
 cMenuSetupDxr3::cMenuSetupDxr3(void)
 {
-    newBrightness = cDxr3ConfigData::Instance().GetBrightness();
+    newBrightness = cDxr3ConfigData::instance()->GetBrightness();
     Add(new cMenuEditIntItem(tr("Brightness"),
 			     &newBrightness, 0, 999));
-    newContrast = cDxr3ConfigData::Instance().GetContrast();
+    newContrast = cDxr3ConfigData::instance()->GetContrast();
     Add(new cMenuEditIntItem(tr("Contrast"),
 			     &newContrast, 0, 999));
-    newSaturation = cDxr3ConfigData::Instance().GetSaturation();
+    newSaturation = cDxr3ConfigData::instance()->GetSaturation();
     Add(new cMenuEditIntItem(tr("Saturation"),
 			     &newSaturation, 0, 999));
-    newVideoMode = (int) cDxr3ConfigData::Instance().GetVideoMode();
+    newVideoMode = (int) cDxr3ConfigData::instance()->GetVideoMode();
     menuVideoModes[0] = tr("PAL");
     menuVideoModes[1] = tr("PAL60");
     menuVideoModes[2] = tr("NTSC");
     Add(new cMenuEditStraItem(tr("Video mode"),
 			      &newVideoMode, 3, menuVideoModes));
-    newUseWSS = cDxr3ConfigData::Instance().GetUseWSS();
+    newUseWSS = cDxr3ConfigData::instance()->GetUseWSS();
 #ifdef EM8300_IOCTL_SET_WSS
     Add(new cMenuEditBoolItem(tr("Use widescreen signaling (WSS)"),
 			      &newUseWSS));
 #endif
-    newUseDigitalOut = cDxr3ConfigData::Instance().GetUseDigitalOut();
+    newUseDigitalOut = cDxr3ConfigData::instance()->GetUseDigitalOut();
     Add(new cMenuEditBoolItem(tr("Digital audio output"), &newUseDigitalOut));
-    newOsdFlushRate = cDxr3ConfigData::Instance().GetOsdFlushRate();
+    newOsdFlushRate = cDxr3ConfigData::instance()->GetOsdFlushRate();
     Add(new cMenuEditIntItem(tr("OSD flush rate (ms)"),
 			     &newOsdFlushRate, 0, 255));
-    newHideMenu = cDxr3ConfigData::Instance().GetHideMenu();
+    newHideMenu = cDxr3ConfigData::instance()->GetHideMenu();
     Add(new cMenuEditBoolItem(tr("Hide main menu entry"), &newHideMenu));
-    newDxr3Card = cDxr3ConfigData::Instance().GetDxr3Card();
+    newDxr3Card = cDxr3ConfigData::instance()->GetDxr3Card();
     Add(new cMenuEditIntItem(tr("Card number"),
 			     &newDxr3Card, 0, DXR3_MAX_CARDS - 1));
 }
@@ -94,30 +94,30 @@ cMenuSetupDxr3::cMenuSetupDxr3(void)
 void cMenuSetupDxr3::Store(void)
 {
     SetupStore("Brightness",
-	       cDxr3ConfigData::Instance().SetBrightness(newBrightness));
+	       cDxr3ConfigData::instance()->SetBrightness(newBrightness));
     SetupStore("Contrast",
-	       cDxr3ConfigData::Instance().SetContrast(newContrast));
+	       cDxr3ConfigData::instance()->SetContrast(newContrast));
     SetupStore("Saturation",
-	       cDxr3ConfigData::Instance().SetSaturation(newSaturation));
+	       cDxr3ConfigData::instance()->SetSaturation(newSaturation));
     SetupStore("Dxr3VideoMode",
-	       cDxr3ConfigData::Instance().SetVideoMode(
+	       cDxr3ConfigData::instance()->SetVideoMode(
 		   (eVideoMode) newVideoMode));
     SetupStore("UseWSS",
-	       cDxr3ConfigData::Instance().SetUseWSS(newUseWSS));
+	       cDxr3ConfigData::instance()->SetUseWSS(newUseWSS));
     SetupStore("UseDigitalOut",
-	       cDxr3ConfigData::Instance().SetUseDigitalOut(newUseDigitalOut));
+	       cDxr3ConfigData::instance()->SetUseDigitalOut(newUseDigitalOut));
     SetupStore("OsdFlushRate",
-	       cDxr3ConfigData::Instance().SetOsdFlushRate(newOsdFlushRate));
+	       cDxr3ConfigData::instance()->SetOsdFlushRate(newOsdFlushRate));
     SetupStore("HideMenu",
-	       cDxr3ConfigData::Instance().SetHideMenu(newHideMenu));
+	       cDxr3ConfigData::instance()->SetHideMenu(newHideMenu));
     SetupStore("Dxr3Card",
-	       cDxr3ConfigData::Instance().SetDxr3Card(newDxr3Card));
+	       cDxr3ConfigData::instance()->SetDxr3Card(newDxr3Card));
 
     // Apply (some of the) settings
-    cDxr3Interface::Instance().SetBrightness(newBrightness);
-    cDxr3Interface::Instance().SetContrast(newContrast);
-    cDxr3Interface::Instance().SetSaturation(newSaturation);
-    //cDxr3Device::Instance().Reset();
+    cDxr3Interface::instance()->SetBrightness(newBrightness);
+    cDxr3Interface::instance()->SetContrast(newContrast);
+    cDxr3Interface::instance()->SetSaturation(newSaturation);
+    //cDxr3Device::instance()->Reset();
 }
 
 // ==================================
@@ -151,7 +151,7 @@ cPluginDxr3::cPluginDxr3()
     // Initialize any member variables here.
     // DON'T DO ANYTHING ELSE THAT MAY HAVE SIDE EFFECTS, REQUIRE GLOBAL
     // VDR OBJECTS TO EXIST OR PRODUCE ANY OUTPUT!
-    cDxr3ConfigData::Instance();
+    cDxr3ConfigData::instance();
 }
 
 // ==================================
@@ -177,47 +177,47 @@ bool cPluginDxr3::SetupParse(const char *Name, const char *Value)
 {
     if (!strcasecmp(Name, "UseDigitalOut"))
     {
-	cDxr3ConfigData::Instance().SetUseDigitalOut(atoi(Value));
+	cDxr3ConfigData::instance()->SetUseDigitalOut(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "Dxr3Card"))
     {
-	cDxr3ConfigData::Instance().SetDxr3Card(atoi(Value));
+	cDxr3ConfigData::instance()->SetDxr3Card(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "Dxr3VideoMode"))
     {
-	cDxr3ConfigData::Instance().SetVideoMode((eVideoMode) atoi(Value));
+	cDxr3ConfigData::instance()->SetVideoMode((eVideoMode) atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "UseWSS"))
     {
-	cDxr3ConfigData::Instance().SetUseWSS(atoi(Value));
+	cDxr3ConfigData::instance()->SetUseWSS(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "HideMenu"))
     {
-	cDxr3ConfigData::Instance().SetHideMenu(atoi(Value));
+	cDxr3ConfigData::instance()->SetHideMenu(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "OsdFlushRate"))
     {
-	cDxr3ConfigData::Instance().SetOsdFlushRate(atoi(Value));
+	cDxr3ConfigData::instance()->SetOsdFlushRate(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "Brightness"))
     {
-	cDxr3ConfigData::Instance().SetBrightness(atoi(Value));
+	cDxr3ConfigData::instance()->SetBrightness(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "Contrast"))
     {
-	cDxr3ConfigData::Instance().SetContrast(atoi(Value));
+	cDxr3ConfigData::instance()->SetContrast(atoi(Value));
 	return true;
     }
     if (!strcasecmp(Name, "Saturation"))
     {
-	cDxr3ConfigData::Instance().SetSaturation(atoi(Value));
+	cDxr3ConfigData::instance()->SetSaturation(atoi(Value));
 	return true;
     }
 
@@ -227,7 +227,7 @@ bool cPluginDxr3::SetupParse(const char *Name, const char *Value)
 // ==================================
 const char* cPluginDxr3::MainMenuEntry()
 {
-    return cDxr3ConfigData::Instance().GetHideMenu() ?
+    return cDxr3ConfigData::instance()->GetHideMenu() ?
 	NULL : tr(MAINMENUENTRY);
 }
 
@@ -265,19 +265,19 @@ cString cPluginDxr3::SVDRPCommand(const char *Command, const char *Option,
 				  int &ReplyCode)
 {
     if (!strcasecmp(Command, "BRI")) {
-        cDxr3Interface::Instance().SetBrightness(atoi(Option));
+        cDxr3Interface::instance()->SetBrightness(atoi(Option));
         return cString::sprintf("Brightness set to %d",
-				cDxr3Interface::Instance().GetBrightness());
+				cDxr3Interface::instance()->GetBrightness());
     }
     if (!strcasecmp(Command, "CON")) {
-        cDxr3Interface::Instance().SetContrast(atoi(Option));
+        cDxr3Interface::instance()->SetContrast(atoi(Option));
         return cString::sprintf("Contrast set to %d",
-				cDxr3Interface::Instance().GetContrast());
+				cDxr3Interface::instance()->GetContrast());
     }
     if (!strcasecmp(Command, "SAT")) {
-        cDxr3Interface::Instance().SetSaturation(atoi(Option));
+        cDxr3Interface::instance()->SetSaturation(atoi(Option));
         return cString::sprintf("Saturation set to %d",
-				cDxr3Interface::Instance().GetSaturation());
+				cDxr3Interface::instance()->GetSaturation());
     }
     if (!strcasecmp(Command, "SDO")) {
         device->getAudioOutput()->setAudioMode(iAudio::DigitalPcm);
diff --git a/dxr3.h b/dxr3.h
index f91f112..4526e09 100644
--- a/dxr3.h
+++ b/dxr3.h
@@ -69,7 +69,7 @@ public:
 	Add(new cDxr3OsdItem(hk(tr("Toggle force letterbox")),
 			     DXR3_FORCE_LETTER_BOX));
 
-	if (cDxr3ConfigData::Instance().GetUseDigitalOut())
+	if (cDxr3ConfigData::instance()->GetUseDigitalOut())
 	    Add(new cDxr3OsdItem(hk(tr("Switch to analog audio output")),
 				 DXR3_ANALOG_OUT));
 	else
diff --git a/dxr3audio-alsa.c b/dxr3audio-alsa.c
index 82ef727..8cf1f8f 100644
--- a/dxr3audio-alsa.c
+++ b/dxr3audio-alsa.c
@@ -30,7 +30,7 @@ void cAudioAlsa::openDevice()
         return;
 
     // generate alsa card name
-    int card = cDxr3ConfigData::Instance().GetDxr3Card();
+    int card = cDxr3ConfigData::instance()->GetDxr3Card();
     string cardname = "EM8300";
 
     if (card > 0) {
diff --git a/dxr3audio-oss.c b/dxr3audio-oss.c
index 16c7adc..f842c61 100644
--- a/dxr3audio-oss.c
+++ b/dxr3audio-oss.c
@@ -38,7 +38,7 @@ void cAudioOss::openDevice()
         exit(1);
     }
 
-    if (cDxr3ConfigData::Instance().GetUseDigitalOut()) {
+    if (cDxr3ConfigData::instance()->GetUseDigitalOut()) {
         dsyslog("[dxr3-audio-oss] audio mode: digital");
         setAudioMode(DigitalPcm);
     } else {
@@ -105,7 +105,7 @@ void cAudioOss::setAudioMode(AudioMode mode)
 
     // we need to do it this way, as we dont have access
     // to the file handle for the conrtol sub device.
-    if (cDxr3Interface::Instance().OssSetPlayMode(ioval)) {
+    if (cDxr3Interface::instance()->OssSetPlayMode(ioval)) {
         this->mode = mode;
     }
 }
diff --git a/dxr3demuxdevice.c b/dxr3demuxdevice.c
index 0b08e82..669c729 100644
--- a/dxr3demuxdevice.c
+++ b/dxr3demuxdevice.c
@@ -24,21 +24,21 @@
 
 // ==================================
 //! constructor
-cDxr3DemuxDevice::cDxr3DemuxDevice(cDxr3Interface& dxr3Device) :
-    m_dxr3Device(dxr3Device),
-    m_aBuf(AUDIO_MAX_BUFFER_SIZE, AUIDO_MAX_FRAME_SIZE, m_dxr3Device),
-    m_vBuf(VIDEO_MAX_BUFFER_SIZE, VIDEO_MAX_FRAME_SIZE, m_dxr3Device)
+cDxr3DemuxDevice::cDxr3DemuxDevice() :
+    m_dxr3Device(cDxr3Interface::instance()),
+    m_aBuf(AUDIO_MAX_BUFFER_SIZE, AUIDO_MAX_FRAME_SIZE),
+    m_vBuf(VIDEO_MAX_BUFFER_SIZE, VIDEO_MAX_FRAME_SIZE)
 {
     m_ReUseFrame = 1;
     m_synchState = DXR3_DEMUX_UNSYNCHED;
     m_demuxMode = DXR3_DEMUX_OFF_MODE;
-    m_pAudioThread = new cDxr3AudioOutThread(dxr3Device, m_aBuf);
+    m_pAudioThread = new cDxr3AudioOutThread(m_aBuf);
     if (!m_pAudioThread) {
         esyslog("dxr3: fatal: unable to allocate memory for audio thread");
         exit(1);
     }
 
-    m_pVideoThread = new cDxr3VideoOutThread(dxr3Device, m_vBuf);
+    m_pVideoThread = new cDxr3VideoOutThread(m_vBuf);
     if (!m_pVideoThread) {
         esyslog("dxr3: fatal: unable to allocate memory for video thread");
         exit(1);
@@ -65,8 +65,8 @@ cDxr3DemuxDevice::~cDxr3DemuxDevice()
 // stop demuxing process
 void cDxr3DemuxDevice::Stop()
 {
-    m_dxr3Device.DisableVideo();
-    m_dxr3Device.DisableAudio();
+    m_dxr3Device->DisableVideo();
+    m_dxr3Device->DisableAudio();
     m_vBuf.Clear();
     m_aBuf.Clear();
     m_vBuf.WakeUp();
@@ -77,15 +77,15 @@ void cDxr3DemuxDevice::Stop()
     m_synchState = DXR3_DEMUX_UNSYNCHED;
     m_demuxMode = DXR3_DEMUX_OFF_MODE;
 
-    m_dxr3Device.PlayBlackFrame();
-    m_dxr3Device.ReOpenAudio();
+    m_dxr3Device->PlayBlackFrame();
+    m_dxr3Device->ReOpenAudio();
 }
 
 // ==================================
 void cDxr3DemuxDevice::Resync()
 {
-    m_dxr3Device.DisableVideo();
-    m_dxr3Device.DisableAudio();
+    m_dxr3Device->DisableVideo();
+    m_dxr3Device->DisableAudio();
     m_vBuf.Clear();
     m_aBuf.Clear();
     m_vBuf.WakeUp();
@@ -100,8 +100,8 @@ void cDxr3DemuxDevice::Resync()
 // ==================================
 void cDxr3DemuxDevice::Clear()
 {
-    m_dxr3Device.DisableVideo();
-    m_dxr3Device.DisableAudio();
+    m_dxr3Device->DisableVideo();
+    m_dxr3Device->DisableAudio();
     m_vBuf.Clear();
     m_aBuf.Clear();
     m_vBuf.WakeUp();
@@ -121,10 +121,10 @@ void cDxr3DemuxDevice::SetReplayMode()
 	if (m_demuxMode == DXR3_DEMUX_TRICK_MODE &&
 	    m_trickState == DXR3_FREEZE)
 	{
-	    m_dxr3Device.SetPlayMode();
-	    m_dxr3Device.SetSysClock(m_stopScr);
-	    m_dxr3Device.EnableVideo();
-	    m_dxr3Device.EnableAudio();
+	    m_dxr3Device->SetPlayMode();
+	    m_dxr3Device->SetSysClock(m_stopScr);
+	    m_dxr3Device->EnableVideo();
+	    m_dxr3Device->EnableAudio();
 	    m_vBuf.Start();
 	    m_aBuf.Start();
 	    m_vBuf.WakeUp();
@@ -145,13 +145,13 @@ void cDxr3DemuxDevice::SetTrickMode(eDxr3TrickState trickState, int Speed)
 {
     m_demuxMode = DXR3_DEMUX_TRICK_MODE;
     m_trickState = trickState;
-    m_dxr3Device.DisableAudio();
+    m_dxr3Device->DisableAudio();
 
     if (m_demuxMode == DXR3_DEMUX_TRICK_MODE &&
 	m_trickState == DXR3_FREEZE)
     {
-	m_stopScr = m_dxr3Device.GetSysClock();
-	// m_dxr3Device.Pause();
+	m_stopScr = m_dxr3Device->GetSysClock();
+	// m_dxr3Device->Pause();
 	m_vBuf.Stop();
 	m_aBuf.Stop();
     }
@@ -171,7 +171,7 @@ void cDxr3DemuxDevice::StillPicture(const uint8_t* buf, int length)
     m_aBuf.Clear();
     m_demuxMode = DXR3_DEMUX_TRICK_MODE;
     m_trickState = DXR3_FREEZE;
-    m_dxr3Device.SingleStep();
+    m_dxr3Device->SingleStep();
 
     dsyslog("dxr3: demux: stillpicture length: %d", length);
 
@@ -193,7 +193,7 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
     int scr = 0;
     int pcr = 0;
 
-    scr = m_dxr3Device.GetSysClock();
+    scr = m_dxr3Device->GetSysClock();
 
     //printf("vBuf size = %d\n", m_vBuf.Available());
     //printf("aBuf size = %d\n", m_aBuf.Available());
@@ -248,7 +248,7 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
 
     if (pesFrame->GetPesDataType() == cDxr3PesFrame::PES_VIDEO_DATA) {
         /*
-        m_dxr3Device.PlayVideoFrame(pesFrame->GetEsStart(),
+        m_dxr3Device->PlayVideoFrame(pesFrame->GetEsStart(),
                                     (int) (pesFrame->GetPayloadLength()));
         */
 
@@ -256,26 +256,26 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
             switch (pesFrame->GetFrameType()) {
             case I_FRAME:
                 dsyslog("dxr3: demux: I-frame");
-                m_dxr3Device.SingleStep();
+                m_dxr3Device->SingleStep();
                 bPlaySuc = true;
                 //if (bPlayedFrame) return length;
                 bPlayedFrame = true;
-                m_dxr3Device.SetHorizontalSize(pesFrame->GetHorizontalSize());
-                m_dxr3Device.SetVerticalSize(pesFrame->GetVerticalSize());
-                m_dxr3Device.PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
+                m_dxr3Device->SetHorizontalSize(pesFrame->GetHorizontalSize());
+                m_dxr3Device->SetVerticalSize(pesFrame->GetVerticalSize());
+                m_dxr3Device->PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
                 break;
 
             case UNKNOWN_FRAME:
                 dsyslog("dxr3: demux: unknown frame");
                 if (bPlaySuc) {
-                    m_dxr3Device.PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
+                    m_dxr3Device->PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
                 }
                 break;
 
             default:
                 dsyslog("dxr3: demux: default frame");
                 if (bPlaySuc) {
-                    m_dxr3Device.PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
+                    m_dxr3Device->PlayVideoFrame(pesFrame->GetPayload(), pesFrame->GetPayloadLength(), m_ReUseFrame);
                 }
 
                 bPlaySuc = false;
@@ -283,12 +283,12 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
             }
 
         } else if (m_demuxMode == DXR3_DEMUX_VIDEO_ONLY_MODE) {
-            m_dxr3Device.PlayVideoFrame(pesFrame->GetPayload(), (int)(pesFrame->GetPayloadLength()));
+            m_dxr3Device->PlayVideoFrame(pesFrame->GetPayload(), (int)(pesFrame->GetPayloadLength()));
 
         } else if (m_synchState == DXR3_DEMUX_VIDEO_SYNCHED ||
                  m_synchState == DXR3_DEMUX_SYNCHED) {
-            m_dxr3Device.SetHorizontalSize(pesFrame->GetHorizontalSize());
-            m_dxr3Device.SetVerticalSize(pesFrame->GetVerticalSize());
+            m_dxr3Device->SetHorizontalSize(pesFrame->GetHorizontalSize());
+            m_dxr3Device->SetVerticalSize(pesFrame->GetVerticalSize());
             while (!Poll(100));
             cFixedLengthFrame* pTempFrame = m_vBuf.Push(pesFrame->GetPayload(), (int) (pesFrame->GetPayloadLength()), pts, ftVideo);
 
@@ -303,10 +303,10 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
             if (m_vBuf.GetFillLevel() > 5 && m_synchState != DXR3_DEMUX_SYNCHED) {
                 m_synchState = DXR3_DEMUX_SYNCHED;
                 pcr = vPts - PRE_BUFFER_LENGTH;
-                m_dxr3Device.SetSysClock(pcr);
-                m_dxr3Device.SetPlayMode();
-                m_dxr3Device.EnableVideo();
-                m_dxr3Device.EnableAudio();
+                m_dxr3Device->SetSysClock(pcr);
+                m_dxr3Device->SetPlayMode();
+                m_dxr3Device->EnableVideo();
+                m_dxr3Device->EnableAudio();
                 m_vBuf.Start();
                 m_aBuf.Start();
             }
@@ -314,8 +314,8 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
             if (pesFrame->GetFrameType() == I_FRAME) {
                 vPts = pts;
 
-                m_dxr3Device.SetHorizontalSize(pesFrame->GetHorizontalSize());
-                m_dxr3Device.SetVerticalSize(pesFrame->GetVerticalSize());
+                m_dxr3Device->SetHorizontalSize(pesFrame->GetHorizontalSize());
+                m_dxr3Device->SetVerticalSize(pesFrame->GetVerticalSize());
                 cFixedLengthFrame* pTempFrame = m_vBuf.Push(pesFrame->GetPayload(), (int) (pesFrame->GetPayloadLength()), pts, ftVideo);
                 // TODO: rework me
                 //if (!pTempFrame) /* Push Timeout */
@@ -337,10 +337,10 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
                     } else {
                         pcr = vPts - PRE_BUFFER_LENGTH;
                     }
-                    m_dxr3Device.SetSysClock(pcr);
-                    m_dxr3Device.SetPlayMode();
-                    m_dxr3Device.EnableVideo();
-                    m_dxr3Device.EnableAudio();
+                    m_dxr3Device->SetSysClock(pcr);
+                    m_dxr3Device->SetPlayMode();
+                    m_dxr3Device->EnableVideo();
+                    m_dxr3Device->EnableAudio();
                     m_vBuf.Start();
                     m_aBuf.Start();
                 }
@@ -349,16 +349,16 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
 
     } else if (pesFrame->GetPesDataType() == cDxr3PesFrame::PES_AUDIO_DATA
              && m_demuxMode != DXR3_DEMUX_VIDEO_ONLY_MODE
-             && !cDxr3Interface::Instance().IsAudioModeAC3()) {
+             && !cDxr3Interface::instance()->IsAudioModeAC3()) {
         if (m_synchState == DXR3_DEMUX_AUDIO_SYNCHED ||
             m_synchState == DXR3_DEMUX_SYNCHED) {
             if (pts && m_synchState != DXR3_DEMUX_SYNCHED) {
                 m_synchState = DXR3_DEMUX_SYNCHED;
                 pcr = aPts - PRE_BUFFER_LENGTH;
-                m_dxr3Device.SetSysClock(pcr);
-                m_dxr3Device.SetPlayMode();
-                m_dxr3Device.EnableVideo();
-                m_dxr3Device.EnableAudio();
+                m_dxr3Device->SetSysClock(pcr);
+                m_dxr3Device->SetPlayMode();
+                m_dxr3Device->EnableVideo();
+                m_dxr3Device->EnableAudio();
                 m_vBuf.Start();
                 m_aBuf.Start();
             }
@@ -385,10 +385,10 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
                     } else {
                         pcr = vPts - PRE_BUFFER_LENGTH;
                     }
-                    m_dxr3Device.SetSysClock(pcr);
-                    m_dxr3Device.SetPlayMode();
-                    m_dxr3Device.EnableVideo();
-                    m_dxr3Device.EnableAudio();
+                    m_dxr3Device->SetSysClock(pcr);
+                    m_dxr3Device->SetPlayMode();
+                    m_dxr3Device->EnableVideo();
+                    m_dxr3Device->EnableAudio();
                     m_vBuf.Start();
                     m_aBuf.Start();
                 }
@@ -396,7 +396,7 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
         }
     } else if (pesFrame->GetPesDataType() == cDxr3PesFrame::PES_PRIVATE_DATA
              && m_demuxMode != DXR3_DEMUX_VIDEO_ONLY_MODE
-             && !cDxr3Interface::Instance().IsAudioModeAC3()
+             && !cDxr3Interface::instance()->IsAudioModeAC3()
              && !bAc3Dts) {
         if (m_synchState == DXR3_DEMUX_AUDIO_SYNCHED ||
             m_synchState == DXR3_DEMUX_SYNCHED) {
@@ -420,10 +420,10 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
                     } else {
                         pcr = vPts - PRE_BUFFER_LENGTH;
                     }
-                    m_dxr3Device.SetSysClock(pcr);
-                    m_dxr3Device.SetPlayMode();
-                    m_dxr3Device.EnableVideo();
-                    m_dxr3Device.EnableAudio();
+                    m_dxr3Device->SetSysClock(pcr);
+                    m_dxr3Device->SetPlayMode();
+                    m_dxr3Device->EnableVideo();
+                    m_dxr3Device->EnableAudio();
                     m_vBuf.Start();
                     m_aBuf.Start();
                 }
@@ -431,7 +431,7 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
         }
     } else if (pesFrame->GetPesDataType() == cDxr3PesFrame::PES_PRIVATE_DATA
              && m_demuxMode != DXR3_DEMUX_VIDEO_ONLY_MODE
-             && cDxr3Interface::Instance().IsAudioModeAC3()
+             && cDxr3Interface::instance()->IsAudioModeAC3()
              && bAc3Dts) {
         if (m_synchState == DXR3_DEMUX_AUDIO_SYNCHED ||
             m_synchState == DXR3_DEMUX_SYNCHED) {
@@ -461,10 +461,10 @@ int cDxr3DemuxDevice::DemuxPes(const uint8_t* buf, int length, bool bAc3Dts)
                     } else {
                         pcr = vPts - PRE_BUFFER_LENGTH;
                     }
-                    m_dxr3Device.SetSysClock(pcr);
-                    m_dxr3Device.SetPlayMode();
-                    m_dxr3Device.EnableVideo();
-                    m_dxr3Device.EnableAudio();
+                    m_dxr3Device->SetSysClock(pcr);
+                    m_dxr3Device->SetPlayMode();
+                    m_dxr3Device->EnableVideo();
+                    m_dxr3Device->EnableAudio();
                     m_vBuf.Start();
                     m_aBuf.Start();
                 }
@@ -497,9 +497,9 @@ int cDxr3DemuxDevice::DemuxAudioPes(const uint8_t* buf, int length)
         if (m_synchState != DXR3_DEMUX_AUDIO_SYNCHED &&
             syncCounter > 2) {
             m_synchState = DXR3_DEMUX_AUDIO_SYNCHED;
-            m_dxr3Device.SetPlayMode();
-            m_dxr3Device.EnableVideo();
-            m_dxr3Device.EnableAudio();
+            m_dxr3Device->SetPlayMode();
+            m_dxr3Device->EnableVideo();
+            m_dxr3Device->EnableAudio();
             m_vBuf.Start();
             m_aBuf.Start();
         }
diff --git a/dxr3demuxdevice.h b/dxr3demuxdevice.h
index 0da7dd8..b6f6355 100644
--- a/dxr3demuxdevice.h
+++ b/dxr3demuxdevice.h
@@ -37,7 +37,7 @@ const uint32_t PRE_BUFFER_LENGTH = 0;
 // extract video and audio
 class cDxr3DemuxDevice : private Uncopyable {
 public:
-    cDxr3DemuxDevice(cDxr3Interface& dxr3Device);
+    cDxr3DemuxDevice();
     ~cDxr3DemuxDevice();
 
     void setAudio(iAudio *audio);
@@ -60,7 +60,7 @@ public:
     };
 
 private:
-    cDxr3Interface& m_dxr3Device;
+    cDxr3Interface *m_dxr3Device;
     cDxr3SyncBuffer m_aBuf;
     cDxr3SyncBuffer m_vBuf;
     eDxr3DemuxSynchState m_synchState;
diff --git a/dxr3device.c b/dxr3device.c
index f4d59c6..b1c45b5 100644
--- a/dxr3device.c
+++ b/dxr3device.c
@@ -32,7 +32,7 @@
 
 // ==================================
 //! constructor
-cDxr3Device::cDxr3Device() : m_DemuxDevice(cDxr3Interface::Instance())
+cDxr3Device::cDxr3Device()
 {
     m_spuDecoder = NULL;
 
@@ -85,7 +85,7 @@ bool cDxr3Device::CanReplay() const
 bool cDxr3Device::SetPlayMode(ePlayMode PlayMode)
 {
     if (PlayMode != pmExtern_THIS_SHOULD_BE_AVOIDED) {
-        cDxr3Interface::Instance().ClaimDevices();
+        cDxr3Interface::instance()->ClaimDevices();
         audioOut->openDevice();
     }
 
@@ -94,7 +94,7 @@ bool cDxr3Device::SetPlayMode(ePlayMode PlayMode)
     switch (PlayMode) {
     case pmExtern_THIS_SHOULD_BE_AVOIDED:
         Tools::WriteInfoToOsd(tr("DXR3: releasing devices"));
-        cDxr3Interface::Instance().ReleaseDevices();
+        cDxr3Interface::instance()->ReleaseDevices();
         audioOut->releaseDevice();
         break;
 
@@ -116,7 +116,7 @@ bool cDxr3Device::SetPlayMode(ePlayMode PlayMode)
 // ==================================
 int64_t cDxr3Device::GetSTC()
 {
-    return cDxr3Interface::Instance().GetPts();
+    return cDxr3Interface::instance()->GetPts();
 }
 
 // ==================================
@@ -202,7 +202,7 @@ int cDxr3Device::PlayAudio(const uchar *Data, int Length, uchar Id)
 // ==================================
 void cDxr3Device::SetVideoFormat(bool VideoFormat16_9)
 {
-    cDxr3Interface::Instance().SetAspectRatio(
+    cDxr3Interface::instance()->SetAspectRatio(
 	VideoFormat16_9 ? EM8300_ASPECTRATIO_16_9 : EM8300_ASPECTRATIO_4_3);
 }
 
diff --git a/dxr3interface.c b/dxr3interface.c
index 8346a19..0338b17 100644
--- a/dxr3interface.c
+++ b/dxr3interface.c
@@ -186,7 +186,7 @@ void cDxr3Interface::SetAspectRatio(uint32_t ratio)
 
     Lock();
 
-    if (cDxr3ConfigData::Instance().GetForceLetterBox())
+    if (cDxr3ConfigData::instance()->GetForceLetterBox())
 	ratio = EM8300_ASPECTRATIO_16_9;
 
     if (ratio != UNKNOWN_ASPECT_RATIO)
@@ -588,7 +588,7 @@ void cDxr3Interface::UploadMicroCode()
 //! config and setup device via ioctl calls
 void cDxr3Interface::ConfigureDevice()
 {
-    uint32_t videomode = cDxr3ConfigData::Instance().GetVideoMode();
+    uint32_t videomode = cDxr3ConfigData::instance()->GetVideoMode();
 
     switch (videomode) {
     case PAL:
@@ -609,9 +609,9 @@ void cDxr3Interface::ConfigureDevice()
     }
 
     // set brightness/contrast/saturation
-    m_bcs.brightness = cDxr3ConfigData::Instance().GetBrightness();
-    m_bcs.contrast = cDxr3ConfigData::Instance().GetContrast();
-    m_bcs.saturation = cDxr3ConfigData::Instance().GetSaturation();
+    m_bcs.brightness = cDxr3ConfigData::instance()->GetBrightness();
+    m_bcs.contrast = cDxr3ConfigData::instance()->GetContrast();
+    m_bcs.saturation = cDxr3ConfigData::instance()->GetSaturation();
     dsyslog("dxr3: configure: brightness=%d,contrast=%d,saturation=%d",
 	    m_bcs.brightness, m_bcs.contrast, m_bcs.saturation);
     if (ioctl(m_fdControl, EM8300_IOCTL_SETBCS, &m_bcs) == -1) {
diff --git a/dxr3interface.h b/dxr3interface.h
index 86b07ed..ec25664 100644
--- a/dxr3interface.h
+++ b/dxr3interface.h
@@ -60,7 +60,7 @@ public:
     ~cDxr3Interface();
 
     static int Dxr3Open(const char *name, int mode, bool report_error = true) {
-        const char *filename = *cDxr3Name(name, cDxr3ConfigData::Instance().GetDxr3Card());
+        const char *filename = *cDxr3Name(name, cDxr3ConfigData::instance()->GetDxr3Card());
         int fd = open(filename, mode);
 
         if (report_error && (fd < 0)) {
diff --git a/dxr3interface_spu_encoder.c b/dxr3interface_spu_encoder.c
index 220fa94..8c085d7 100644
--- a/dxr3interface_spu_encoder.c
+++ b/dxr3interface_spu_encoder.c
@@ -302,7 +302,7 @@ int cSPUEncoder::Flush(cPalette *Palette)
 		| (Colors[i] & 0x00FF00) | ((Colors[i] & 0xFF0000) >> 16);
 	    palcolors[i] = Tools::Rgb2YCrCb(color);
 	}
-	cDxr3Interface::Instance().SetPalette(palcolors);
+	cDxr3Interface::instance()->SetPalette(palcolors);
     }
 
     // calculate osd size (actually dead code)
@@ -317,7 +317,7 @@ int cSPUEncoder::Flush(cPalette *Palette)
 
     if (m_encodeddata.count <= DATASIZE)
     {
-	cDxr3Interface::Instance().WriteSpu((uint8_t*) &m_encodeddata,
+	cDxr3Interface::instance()->WriteSpu((uint8_t*) &m_encodeddata,
 					    m_encodeddata.count);
 	return 0;
     }
@@ -365,8 +365,8 @@ void cSPUEncoder::EncodePixelbufRle(int x, int y, int w, int h, u_char *inbuf,
     pb.y = h;
 
 #ifdef USE_XINE_SCALER
-    int ws = cDxr3Interface::Instance().GetHorizontalSize();
-    int hs = cDxr3Interface::Instance().GetVerticalSize();
+    int ws = cDxr3Interface::instance()->GetHorizontalSize();
+    int hs = cDxr3Interface::instance()->GetVerticalSize();
     if (ws < 720 || hs < 576)
 	inbuf = XineScaler::ScaleBitmapLQ(inbuf, OSD_Screen2, 0, 0, OSDWIDTH,
 					  OSDHEIGHT, ws, hs, 0, 0, ws, hs,
@@ -658,7 +658,7 @@ void cSPUEncoder::StopSpu(void)
 
     /* 0xFF: end sequence */
     ed[9] = 0xFF;
-    cDxr3Interface::Instance().WriteSpu(ed, 10);
+    cDxr3Interface::instance()->WriteSpu(ed, 10);
 }
 
 // ==================================
diff --git a/dxr3osd.c b/dxr3osd.c
index 765aa67..821ee3c 100644
--- a/dxr3osd.c
+++ b/dxr3osd.c
@@ -71,8 +71,8 @@ cDxr3Osd::cDxr3Osd(int Left, int Top, uint Level)
     shown = false;
     Palette = new cPalette(4);
     last = new cTimeMs();
-    last->Set(-cDxr3ConfigData::Instance().GetOsdFlushRate());
-    Spu = &cSPUEncoder::Instance();
+    last->Set(-cDxr3ConfigData::instance()->GetOsdFlushRate());
+    Spu = cSPUEncoder::instance();
 }
 
 // ==================================
@@ -148,7 +148,7 @@ void cDxr3Osd::Flush()
 {
     if (!Active())
         return;
-    if (last->Elapsed() < cDxr3ConfigData::Instance().GetOsdFlushRate())
+    if (last->Elapsed() < cDxr3ConfigData::instance()->GetOsdFlushRate())
 	return;
     last->Set();
 
diff --git a/dxr3output-audio.c b/dxr3output-audio.c
index 4b478a6..dd1e4ba 100644
--- a/dxr3output-audio.c
+++ b/dxr3output-audio.c
@@ -27,14 +27,13 @@
 
 // ==================================
 const int AUDIO_OFFSET = 4500;
-#define SCR m_dxr3Device.GetSysClock()
+#define SCR m_dxr3Device->GetSysClock()
 // ==================================
 
 // ==================================
 //! constr.
-cDxr3AudioOutThread::cDxr3AudioOutThread(cDxr3Interface& dxr3Device,
-					 cDxr3SyncBuffer& buffer) :
-    cDxr3OutputThread(dxr3Device, buffer)
+cDxr3AudioOutThread::cDxr3AudioOutThread(cDxr3SyncBuffer& buffer) :
+    cDxr3OutputThread(buffer)
 {
     SetDescription("DXR3 audio output");
 }
@@ -73,7 +72,7 @@ void cDxr3AudioOutThread::Action()
 
 		if (pts && (pts < SCR) && ((SCR - pts) > 5000))
 		{
-		    m_dxr3Device.SetSysClock(pts + 1 * AUDIO_OFFSET);
+		    m_dxr3Device->SetSysClock(pts + 1 * AUDIO_OFFSET);
 		    PlayFrame(pNext);
 		    if (m_buffer.IsPolled())
 		    {
@@ -119,7 +118,7 @@ void cDxr3AudioOutThread::PlayFrame(cFixedLengthFrame *frame)
     }
 
     // volume changes
-    if (!cDxr3Interface::Instance().IsAudioModeAC3()) {
+    if (!cDxr3Interface::instance()->IsAudioModeAC3()) {
         audioOutput->changeVolume((short *)frame->GetData(), (size_t)frame->GetCount());
     }
 
@@ -132,7 +131,7 @@ void cDxr3AudioOutThread::PlayFrame(cDxr3PesFrame *frame)
     audioOutput->setup(frame->GetSampleContext());
 
     // volume changes
-    if (!cDxr3Interface::Instance().IsAudioModeAC3()) {
+    if (!cDxr3Interface::instance()->IsAudioModeAC3()) {
         audioOutput->changeVolume((short *)frame->GetDecoded(), (size_t)frame->GetDecodedSize());
     }
 
diff --git a/dxr3output-video.c b/dxr3output-video.c
index 09c3af8..7493f95 100644
--- a/dxr3output-video.c
+++ b/dxr3output-video.c
@@ -23,13 +23,12 @@
 #include <time.h>
 #include "dxr3output.h"
 
-#define SCR m_dxr3Device.GetSysClock()
+#define SCR m_dxr3Device->GetSysClock()
 
 // ==================================
 //! constr.
-cDxr3VideoOutThread::cDxr3VideoOutThread(cDxr3Interface& dxr3Device,
-					 cDxr3SyncBuffer& buffer) :
-    cDxr3OutputThread(dxr3Device, buffer)
+cDxr3VideoOutThread::cDxr3VideoOutThread(cDxr3SyncBuffer& buffer) :
+    cDxr3OutputThread(buffer)
 {
     SetDescription("DXR3 video output");
 }
@@ -52,14 +51,14 @@ void cDxr3VideoOutThread::Action()
 
 	    if (pts > SCR && abs((int)pts - (int)SCR) < 7500)
 	    {
-		m_dxr3Device.SetPts(pts);
+		m_dxr3Device->SetPts(pts);
 	    }
 
 	    if (!pts || pts < SCR)
 	    {
 		if (m_buffer.Available())
 		{
-		    m_dxr3Device.PlayVideoFrame(pNext);
+		    m_dxr3Device->PlayVideoFrame(pNext);
 		    m_buffer.Pop();
 		}
 	    }
@@ -67,12 +66,12 @@ void cDxr3VideoOutThread::Action()
 	    {
 		if ((pts > SCR) && abs((int)pts - (int)SCR) < 7500)
 		{
-		    m_dxr3Device.SetPts(pts);
+		    m_dxr3Device->SetPts(pts);
 
 		    if (m_buffer.Available() && pNext->GetData() &&
 			pNext->GetCount())
 		    {
-			m_dxr3Device.PlayVideoFrame(pNext);
+			m_dxr3Device->PlayVideoFrame(pNext);
 			m_buffer.Pop();
 		    }
 		}
@@ -80,7 +79,7 @@ void cDxr3VideoOutThread::Action()
 		{
 		    if (pts < SCR)
 		    {
-			m_dxr3Device.PlayVideoFrame(pNext);
+			m_dxr3Device->PlayVideoFrame(pNext);
 			m_buffer.Pop();
 		    }
 		}
diff --git a/dxr3output.c b/dxr3output.c
index d8d3c8a..6e83368 100644
--- a/dxr3output.c
+++ b/dxr3output.c
@@ -24,10 +24,9 @@
 
 // ==================================
 //! constructor
-cDxr3OutputThread::cDxr3OutputThread(cDxr3Interface& dxr3Device,
-				     cDxr3SyncBuffer& buffer) :
+cDxr3OutputThread::cDxr3OutputThread(cDxr3SyncBuffer& buffer) :
     cThread(),
-    m_dxr3Device(dxr3Device),
+    m_dxr3Device(cDxr3Interface::instance()),
     m_buffer(buffer),
     m_bNeedResync(false)
 {
diff --git a/dxr3output.h b/dxr3output.h
index e80478b..083893e 100644
--- a/dxr3output.h
+++ b/dxr3output.h
@@ -31,7 +31,7 @@ class iAudio;
 // ==================================
 class cDxr3OutputThread : public cThread, private Uncopyable {
 public:
-    cDxr3OutputThread(cDxr3Interface& dxr3Device, cDxr3SyncBuffer& buffer);
+    cDxr3OutputThread(cDxr3SyncBuffer& buffer);
     virtual ~cDxr3OutputThread() {
         m_buffer.Stop();
         Cancel(3);
@@ -43,7 +43,7 @@ public:
 protected:
     virtual void Action() = 0;
 
-    cDxr3Interface& m_dxr3Device;
+    cDxr3Interface *m_dxr3Device;
     cDxr3SyncBuffer& m_buffer;
     bool m_bNeedResync;
 };
@@ -51,7 +51,7 @@ protected:
 // ==================================
 class cDxr3AudioOutThread : public cDxr3OutputThread {
 public:
-    cDxr3AudioOutThread(cDxr3Interface& dxr3Device, cDxr3SyncBuffer& buffer);
+    cDxr3AudioOutThread(cDxr3SyncBuffer& buffer);
 
     void setAudio(iAudio *a)    { audioOutput = a; }
 
@@ -68,7 +68,7 @@ private:
 // ==================================
 class cDxr3VideoOutThread : public cDxr3OutputThread {
 public:
-    cDxr3VideoOutThread(cDxr3Interface& dxr3Device, cDxr3SyncBuffer& buffer);
+    cDxr3VideoOutThread(cDxr3SyncBuffer& buffer);
 
 protected:
     void Action();
diff --git a/dxr3singleton.h b/dxr3singleton.h
index ebfbe42..b53ac79 100644
--- a/dxr3singleton.h
+++ b/dxr3singleton.h
@@ -1,7 +1,7 @@
 /*
  * dxr3singleton.h
  *
- * Copyright (C) 2004 Christian Gmeiner
+ * Copyright (C) 2004-2009 Christian Gmeiner
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -22,30 +22,43 @@
 #ifndef _DXR3_SINGLETON_H_
 #define _DXR3_SINGLETON_H_
 
-// ==================================
-//!  A singleton template.
-/*!
-  Is a nice solution to use only
-  one instance of a class.
-*/
+#include <memory>
+#include <vdr/thread.h>
+
 template <class T>
-class Singleton {
+class Singleton
+{
 public:
-    virtual ~Singleton()    {}
-    static T& Instance();
+    static T *instance() {
+
+        // use double-checked looking
+        // see http://en.wikipedia.org/wiki/Double-checked_locking
+        if (inst.get() == 0) {
+            m.Lock();
+            if (inst.get() == 0) {
+                inst = std::auto_ptr<T>(new T);
+            }
+            m.Unlock();
+        }
+
+        return inst.get();
+    }
+
+    virtual ~Singleton() { };
 
 protected:
-    Singleton() {}
+    Singleton() { }
 
 private:
-    Singleton(const Singleton&);
+    static std::auto_ptr<T> inst;
+    static cMutex m;
 };
 
-template <class T>
-T& Singleton<T>::Instance() {
-    static T instance;
-    return instance;
-}
+template<class T>
+std::auto_ptr<T> Singleton<T>::inst(0);
+
+template<class T>
+cMutex Singleton<T>::m;
 
 #endif /*_DXR3_SINGLETON_H_*/
 
diff --git a/dxr3syncbuffer.c b/dxr3syncbuffer.c
index 7712e6c..ffdb0d2 100644
--- a/dxr3syncbuffer.c
+++ b/dxr3syncbuffer.c
@@ -105,10 +105,10 @@ void cFixedLengthFrame::SetPts(uint32_t pts)
 
 // ==================================
 //! constructor
-cDxr3SyncBuffer::cDxr3SyncBuffer(int frameCount, int frameLength,
-				 cDxr3Interface& dxr3Device) :
-    cRingBuffer(frameCount, true), m_dxr3Device(dxr3Device)
+cDxr3SyncBuffer::cDxr3SyncBuffer(int frameCount, int frameLength) :
+    cRingBuffer(frameCount, true)
 {
+    m_dxr3Device = cDxr3Interface::instance();
     m_pBuffer = new cFixedLengthFrame[frameCount];
 
     // got we a valid m_pBuffer?
@@ -157,7 +157,7 @@ const int BUFFER_LIMIT_2 = 10;
 bool cDxr3SyncBuffer::Poll(int TimeoutMs)
 {
     bool retVal = true;
-    uint32_t currTime = m_dxr3Device.GetSysClock();
+    uint32_t currTime = m_dxr3Device->GetSysClock();
     struct timeval tv_start, tv;
     m_bPollSync = true;
     gettimeofday(&tv_start, NULL);
@@ -165,7 +165,7 @@ bool cDxr3SyncBuffer::Poll(int TimeoutMs)
         if (Available() >= Size() - (Size()*BUFFER_LIMIT/100)) {
             m_bPollSync = true;
             while ((Available() >= Size() - (Size()*BUFFER_LIMIT_2)/100) &&
-               ((m_dxr3Device.GetSysClock() - currTime) <
+               ((m_dxr3Device->GetSysClock() - currTime) <
                 ((uint32_t)TimeoutMs * (uint32_t)45)))
             {
                 int d_s, d_us, ms;
diff --git a/dxr3syncbuffer.h b/dxr3syncbuffer.h
index 358368f..2c95a5c 100644
--- a/dxr3syncbuffer.h
+++ b/dxr3syncbuffer.h
@@ -84,8 +84,7 @@ public:
 	SYNC_BUFFER_OVERRUN
     };
 public:
-    cDxr3SyncBuffer(int frameCount, int frameLength,
-		    cDxr3Interface& dxr3Device);
+    cDxr3SyncBuffer(int frameCount, int frameLength);
     ~cDxr3SyncBuffer();
 
     virtual int Available(void);
@@ -135,7 +134,7 @@ private:
 
     cCondVar receiverStopped;
     cMutex receiverStoppedMutex;
-    cDxr3Interface& m_dxr3Device;
+    cDxr3Interface *m_dxr3Device;
     bool m_bPollSync;
 
     cDxr3SyncBuffer(); // you are not allowed to use this constructor