- rewrote cDxr3SpuDecoder

  dropped software decoder
  added hardware decoder, so we make use of DVD-functions of the dxr3
  kicked out YUV2Rgb - as we dont need it any more

4 files changed, 73 insertions, 746 deletions

diff --git a/HISTORY b/HISTORY
index 8197c4a..63c53f5 100644
--- a/HISTORY
+++ b/HISTORY
@@ -255,4 +255,8 @@ NOTE: I havent found time to include all of the languages, will be done in pre2
 - extended cDxr3MemcpyBench::Rdtsc(uint32_t config_flags)
   support for non x86 arch
   support for cpu's, which dont support rdtsc timing
-- logger now thread safe
\ No newline at end of file
+- logger now thread safe
+- rewrote cDxr3SpuDecoder
+  dropped software decoder
+  added hardware decoder, so we make use of DVD-functions of the dxr3
+  kicked out YUV2Rgb - as we dont need it any more
\ No newline at end of file
diff --git a/dxr3spudecoder.c b/dxr3spudecoder.c
index 1336483..fde5140 100644
--- a/dxr3spudecoder.c
+++ b/dxr3spudecoder.c
@@ -3,9 +3,6 @@
  *
  * Copyright (C) 2004 Christian Gmeiner
  *
- * Orginal:
- *    Copyright (C) 2001.2002 Andreas Schultz <aschultz@warp10.net>
- *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1
@@ -22,608 +19,76 @@
  *
  */
 
-/*
-ToDo:
-	- Line 175
-*/
-
-#include <assert.h>
-#include <string.h>
-#include <inttypes.h>
-#include <math.h>
-
 #include "dxr3spudecoder.h"
-#include "dxr3interface.h"
-#include "dxr3tools.h"
-#include "dxr3log.h"
-
-// ==================================
-#define CMD_SPU_MENU            0x00
-#define CMD_SPU_SHOW            0x01
-#define CMD_SPU_HIDE            0x02
-#define CMD_SPU_SET_PALETTE     0x03
-#define CMD_SPU_SET_ALPHA       0x04
-#define CMD_SPU_SET_SIZE        0x05
-#define CMD_SPU_SET_PXD_OFFSET  0x06
-#define CMD_SPU_EOF             0xff
-
-#define spuU32(i)  ((spu[i] << 8) + spu[i+1])
-
-
-/*
- * cDxr3Spubitmap:
- *
- * this is a bitmap of the full screen and two palettes
- * the normal palette for the background and the highlight palette
- *
- * Inputs:
- *  - a SPU rle encoded image on creation, which will be decoded into
- *    the full screen indexed bitmap
- *  
- * Output:
- *  - a minimal sized cDxr3SpuBitmap a given palette, the indexed bitmap
- *    will be scanned to get the smallest possible resulting bitmap considering
- *    transparencies
- */
-
-
-// ==================================
-void cDxr3SpuPalette::setPalette(const uint32_t * pal)
-{
-    for (int i = 0; i < 16; i++)
-        palette[i] = Tools::YUV2Rgb(pal[i]);
-}
-
-// ==================================
-#define setMin(a, b) if (a > b) a = b
-#define setMax(a, b) if (a < b) a = b
-
-#define spuXres   720
-#define spuYres   576
-
-#define revRect(r1, r2) { r1.x1 = r2.x2; r1.y1 = r2.y2; r1.x2 = r2.x1; r1.y2 = r2.y1; }
-
-// ==================================
-//! constructor
-cDxr3SpuBitmap::cDxr3SpuBitmap(sDxr3SpuRect size, uint8_t * fodd, uint8_t * eodd, uint8_t * feven, uint8_t * eeven)
-{
-    if (size.x1 < 0 || size.y1 < 0 || size.x2 >= spuXres
-        || size.y2 >= spuYres)
-        throw;
-
-    bmpsize = size;
-    revRect(minsize[0], size);
-    revRect(minsize[1], size);
-    revRect(minsize[2], size);
-    revRect(minsize[3], size);
-
-    if (!(bmp = new uint8_t[spuXres * spuYres * sizeof(uint8_t)]))
-        throw;
-
-    memset(bmp, 0, spuXres * spuYres * sizeof(uint8_t));
-    putFieldData(0, fodd, eodd);
-    putFieldData(1, feven, eeven);
-}
-
-// ==================================
-cDxr3SpuBitmap::~cDxr3SpuBitmap()
-{
-    delete[]bmp;
-}
-
-// ==================================
-cBitmap *cDxr3SpuBitmap::getBitmap(const aDxr3SpuPalDescr paldescr, const cDxr3SpuPalette & pal, sDxr3SpuRect & size) const
-{
-    int h = size.height();
-    int w = size.width();
-
-    if (size.y1 + h >= spuYres)
-	{
-        h = spuYres - size.y1 - 1;
-	}
-    if (size.x1 + w >= spuXres)
-	{
-        w = spuXres - size.x1 - 1;
-	}
-
-    if (w & 0x03)
-	{
-        w += 4 - (w & 0x03);
-	}
-
-    cBitmap *ret = new cBitmap(w, h, 2);
-
-    // set the palette
-    for (int i = 0; i < 4; i++) 
-	{
-        uint32_t color = pal.getColor(paldescr[i].index, paldescr[i].trans);
-        ret->SetColor(i, (tColor) color);
-    }
-
-    // set the content
-    for (int yp = 0; yp < h; yp++) 
-	{
-        for (int xp = 0; xp < w; xp++) 
-		{
-            uint8_t idx = bmp[(size.y1 + yp) * spuXres + size.x1 + xp];
-            ret->SetIndex(xp, yp, idx);
-        }
-    }
-    return ret;
-}
-
-// ==================================
-// find the minimum non-transparent area
-bool cDxr3SpuBitmap::getMinSize(const aDxr3SpuPalDescr paldescr, sDxr3SpuRect & size) const
-{
-    bool ret = false;
-    for (int i = 0; i < 4; i++) 
-	{
-        if (paldescr[i].trans != 0) 
-		{
-            if (!ret)
-			{
-                size = minsize[i];
-			}
-            else 
-			{
-                setMin(size.x1, minsize[i].x1);
-                setMin(size.y1, minsize[i].y1);
-                setMax(size.x2, minsize[i].x2);
-                setMax(size.y2, minsize[i].y2);
-            }
-            ret = true;
-        }
-    }
-/*
-	if (ret && cDxr3ConfigData::Instance().GetDebug())
-	{
-		cLog::Instance() << "cDxr3SpuBitmap::getMinSize: (" << size.x1 ", " << size.y1 << ") x (" << size.x2 << ", " << size.y2 << ")\n";
-	}
-*/
-    return ret;
-}
-
-// ==================================
-void cDxr3SpuBitmap::putPixel(int xp, int yp, int len, uint8_t colorid)
-{
-    memset(bmp + spuXres * yp + xp, colorid, len);
-    setMin(minsize[colorid].x1, xp);
-    setMin(minsize[colorid].y1, yp);
-    setMax(minsize[colorid].x2, xp + len - 1);
-    setMax(minsize[colorid].y2, yp + len - 1);
-}
-
-// ==================================
-static uint8_t getBits(uint8_t * &data, uint8_t & bitf)
-{
-    uint8_t ret = *data;
-    if (bitf)
-	{
-        ret >>= 4;
-	}
-    else
-	{
-        data++;
-	}
-
-    bitf ^= 1;
-
-    return (ret & 0xf);
-}
-
-// ==================================
-void cDxr3SpuBitmap::putFieldData(int field, uint8_t * data, uint8_t * endp)
-{
-    int xp = bmpsize.x1;
-    int yp = bmpsize.y1 + field;
-    uint8_t bitf = 1;
-
-    while (data < endp) 
-	{
-        uint16_t vlc = getBits(data, bitf);
-        if (vlc < 0x0004) 
-		{
-            vlc = (vlc << 4) | getBits(data, bitf);
-            if (vlc < 0x0010) 
-			{
-                vlc = (vlc << 4) | getBits(data, bitf);
-                if (vlc < 0x0040) 
-				{
-                    vlc = (vlc << 4) | getBits(data, bitf);
-                }
-            }
-        }
-
-        uint8_t color = vlc & 0x03;
-        int len = vlc >> 2;
-
-        // if len == 0 -> end sequence - fill to end of line
-        len = len ? len : bmpsize.x2 - xp + 1;
-        putPixel(xp, yp, len, color);
-        xp += len;
-
-        if (xp > bmpsize.x2) 
-		{
-            // nextLine
-            if (!bitf)
-                data++;
-            bitf = 1;
-            xp = bmpsize.x1;
-            yp += 2;
-            if (yp > bmpsize.y2)
-                return;
-        }
-    }
-}
-
-// ==================================
-cDxr3SpuDecoder::cDxr3SpuDecoder()
-{
-    clean = true;
-    scaleMode = eSpuNormal;
-    spu = NULL;
-    osd = NULL;
-    spubmp = NULL;
-}
 
 // ==================================
-cDxr3SpuDecoder::~cDxr3SpuDecoder()
+// ! constructor
+cDxr3SpuDecoder::cDxr3SpuDecoder() : m_Interface(cDxr3Interface::Instance()), m_visible(false) 
 {
-    delete spubmp;
-    delete spu;
-    delete osd;
 }
 
 // ==================================
-void cDxr3SpuDecoder::processSPU(uint32_t pts, uint8_t * buf)
+// ! send spu data to dxr3
+void cDxr3SpuDecoder::processSPU(uint32_t pts, uint8_t * buf) 
 {
-    setTime(pts);
-
-	if (cDxr3ConfigData::Instance().GetDebug())
-	{
-		cLog::Instance() << "cDxr3SpuDecoder::processSPU: SPU pushData: pts: " << pts << "\n";
-	}
-
-    delete spubmp;
-    spubmp = NULL;
-    delete[]spu;
-    spu = buf;
-    spupts = pts;
-
-    DCSQ_offset = cmdOffs();
-    prev_DCSQ_offset = 0;
-
-    clean = true;
-}
+	// size are the first two bits of buf
+	// size = (buf[0] << 8) + buf[1]
+	
+	m_Interface.WriteSpu(buf, (buf[0] << 8) + buf[1]);
+} 
 
 // ==================================
-void cDxr3SpuDecoder::setScaleMode(cSpuDecoder::eScaleMode ScaleMode)
+// ! set scalemode - not needed
+void cDxr3SpuDecoder::setScaleMode(cSpuDecoder::eScaleMode ScaleMode) 
 {
-    scaleMode = ScaleMode;
-}
+	// not needed
+} 
 
 // ==================================
-void cDxr3SpuDecoder::setPalette(uint32_t * pal)
+// ! send palette to dxr3
+void cDxr3SpuDecoder::setPalette(uint32_t * pal) 
 {
-    palette.setPalette(pal);
-}
+	m_Interface.SetPalette(pal);
+} 
 
 // ==================================
-void cDxr3SpuDecoder::setHighlight(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint32_t palette)
+// ! send highlight to dxr3
+void cDxr3SpuDecoder::setHighlight(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint32_t palette) 
 {
-    aDxr3SpuPalDescr pld;
-    for (int i = 0; i < 4; i++) 
-	{
-        pld[i].index = 0xf & (palette >> (16 + 4 * i));
-        pld[i].trans = 0xf & (palette >> (4 * i));
-    }
-
-    bool ne = hlpsize.x1 != sx || hlpsize.y1 != sy ||
-        hlpsize.x2 != ex || hlpsize.y2 != ey ||
-        pld[0] != hlpDescr[0] || pld[1] != hlpDescr[1] ||
-        pld[2] != hlpDescr[2] || pld[3] != hlpDescr[3];
-
-    if (ne) 
-	{
-		if (cDxr3ConfigData::Instance().GetDebug())
-		{
-			cLog::Instance() << "cDxr3SpuDecoder::setHighlight: " << sx << ", " << sy << ", " << ex << ", " << ey << "\n";
-		}
-
-        hlpsize.x1 = sx;
-        hlpsize.y1 = sy;
-        hlpsize.x2 = ex;
-        hlpsize.y2 = ey;
-        memcpy(hlpDescr, pld, sizeof(aDxr3SpuPalDescr));
-        highlight = true;
-        clean = false;
-    }
-}
+	m_Interface.SetButton(sx, sy, ex, ey, palette);
+} 
 
 // ==================================
-void cDxr3SpuDecoder::clearHighlight()
+// ! clear highlight
+void cDxr3SpuDecoder::clearHighlight(void) 
 {
-    clean &= !highlight;
-    highlight = false;
-    hlpsize.x1 = -1;
-    hlpsize.y1 = -1;
-    hlpsize.x2 = -1;
-    hlpsize.y2 = -1;
-}
+	m_Interface.ClearButton();
+} 
 
 // ==================================
-int cDxr3SpuDecoder::ScaleYcoord(int value)
+// ! draw nav, subtilte, ...
+void cDxr3SpuDecoder::Draw(void) 
 {
-    if (scaleMode == eSpuLetterBox) 
-	{
-        int offset = cDevice::PrimaryDevice()->GetVideoSystem() == vsPAL ? 72 : 60;
-        return lround((value * 3.0) / 4.0) + offset;
-    }
-	return value;
-}
-
-// ==================================
-int cDxr3SpuDecoder::ScaleYres(int value)
-{
-    if (scaleMode == eSpuLetterBox)
-	{
-        return lround((value * 3.0) / 4.0);
-	}
-	return value;
-}
-
-// ==================================
-void cDxr3SpuDecoder::DrawBmp(sDxr3SpuRect & size, cBitmap * bmp)
-{
-    int x2 = size.x2;
-    while ((x2 - size.x1 + 1) & 0x03)
-          x2++;
-    tArea Area = { size.x1, size.y1, x2, size.y2, 2 };
-    osd->SetAreas(&Area, 1);
-    if (x2 > size.x2)
-       osd->DrawRectangle(size.x2 + 1, size.y1, x2, size.y2, clrTransparent);
-    osd->DrawBitmap(size.x1, size.y1, *bmp);
-    delete bmp;
-}
-
-// ==================================
-void cDxr3SpuDecoder::Draw()
-{
-    Hide();
-
-    if (!spubmp)
-	{
-        return;
-	}
-
-    cBitmap *fg = NULL;
-    cBitmap *bg = NULL;
-    sDxr3SpuRect bgsize;
-    sDxr3SpuRect hlsize;
-
-    hlsize.x1 = hlpsize.x1;
-    hlsize.y1 = ScaleYcoord(hlpsize.y1);
-    hlsize.x2 = hlpsize.x2;
-    hlsize.y2 = ScaleYcoord(hlpsize.y2);
-
-    if (highlight)
-	{
-        fg = spubmp->getBitmap(hlpDescr, palette, hlsize);
-	}
-
-    if (spubmp->getMinSize(palDescr, bgsize)) 
-	{
-        bg = spubmp->getBitmap(palDescr, palette, bgsize);
-        if (scaleMode == eSpuLetterBox) 
-		{
-            // the coordinates have to be modified for letterbox
-            int y1 = ScaleYres(bgsize.y1) + bgsize.height();
-            bgsize.y2 = y1 + bgsize.height();
-            bgsize.y1 = y1;
-        }
-    }
-
-    if (bg || fg) 
-	{
-        if (osd == NULL)
-            if ((osd = cOsdProvider::NewOsd(0, 0)) == NULL) 
-			{
-				if (cDxr3ConfigData::Instance().GetDebug())
-				{
-					cLog::Instance() << "cDxr3SpuDecoder::Draw: New OSD faild!\n";
-				}
-                dsyslog("NewOsd failed\n");
-                return;
-            }
-
-        if (fg)
-		{
-            DrawBmp(hlsize, fg);
-		}
-
-        if (bg)
-		{
-            DrawBmp(bgsize, bg);
-		}
-
-        osd->Flush();
-    }
-
-    clean = true;
-}
+	m_visible = true;
+} 
 
 // ==================================
-void cDxr3SpuDecoder::Hide()
+// ! hide nav, subtilte, ...
+void cDxr3SpuDecoder::Hide(void) 
 {
-    delete osd;
-    osd = NULL;
-}
+	m_visible = false;
+} 
 
 // ==================================
-void cDxr3SpuDecoder::Empty()
+// ! clear highlight and osd
+void cDxr3SpuDecoder::Empty(void) 
 {
-    Hide();
-
-    delete spubmp;
-    spubmp = NULL;
-
-    delete[]spu;
-    spu = NULL;
-
-    clearHighlight();
-    clean = true;
-}
+	m_Interface.ClearOsd();
+} 
 
 // ==================================
-int cDxr3SpuDecoder::setTime(uint32_t pts)
-{
-    if (!spu)
-	{
-        return 0;
-	}
-
-    if (spu && !clean)
-	{
-        Draw();
-	}
-
-    while (DCSQ_offset != prev_DCSQ_offset) 
-	{   
-		// Display Control Sequences
-        int i = DCSQ_offset;
-        state = spNONE;
-
-        uint32_t exec_time = spupts + spuU32(i) * 1024;
-        if ((pts != 0) && (exec_time > pts))
-		{
-            return 0;
-		}
-
-        if (pts != 0) 
-		{
-            uint16_t feven = 0;
-            uint16_t fodd = 0;
-
-            i += 2;
-
-            prev_DCSQ_offset = DCSQ_offset;
-            DCSQ_offset = spuU32(i);
-            i += 2;
-
-            while (spu[i] != CMD_SPU_EOF) 
-			{
-				// Command Sequence
-                switch (spu[i]) 
-				{
-                case CMD_SPU_SHOW:     
-					// show subpicture
-					if (cDxr3ConfigData::Instance().GetDebug())
-					{
-						cLog::Instance() << "cDxr3SpuDecoder::setTime: show subpicture\n";
-					}
-                    state = spSHOW;
-                    i++;
-                    break;
-
-                case CMD_SPU_HIDE:     
-					// hide subpicture
-					if (cDxr3ConfigData::Instance().GetDebug())
-					{
-						cLog::Instance() << "cDxr3SpuDecoder::setTime: hide subpicture\n";
-					}
-                    state = spHIDE;
-                    i++;
-                    break;
-
-                case CMD_SPU_SET_PALETTE:      
-					// CLUT
-                    palDescr[0].index = spu[i + 2] & 0xf;
-                    palDescr[1].index = spu[i + 2] >> 4;
-                    palDescr[2].index = spu[i + 1] & 0xf;
-                    palDescr[3].index = spu[i + 1] >> 4;
-                    i += 3;
-                    break;
-
-                case CMD_SPU_SET_ALPHA:        
-					// transparency palette
-                    palDescr[0].trans = spu[i + 2] & 0xf;
-                    palDescr[1].trans = spu[i + 2] >> 4;
-                    palDescr[2].trans = spu[i + 1] & 0xf;
-                    palDescr[3].trans = spu[i + 1] >> 4;
-                    i += 3;
-                    break;
-
-                case CMD_SPU_SET_SIZE: 
-					// image coordinates
-                    size.x1 = (spu[i + 1] << 4) | (spu[i + 2] >> 4);
-                    size.x2 = ((spu[i + 2] & 0x0f) << 8) | spu[i + 3];
-
-                    size.y1 = (spu[i + 4] << 4) | (spu[i + 5] >> 4);
-                    size.y2 = ((spu[i + 5] & 0x0f) << 8) | spu[i + 6];
-
-					if (cDxr3ConfigData::Instance().GetDebug())
-					{
-						cLog::Instance() << "cDxr3SpuDecoder::setTime: (" << size.x1 << ", " << size.y1 <<") x (" << size.x2 << ", " << size.y2 <<")\n";
-					}
-                    i += 7;
-                    break;
-
-                case CMD_SPU_SET_PXD_OFFSET:   
-					// image 1 / image 2 offsets
-                    fodd = spuU32(i + 1);
-                    feven = spuU32(i + 3);
-
-					if (cDxr3ConfigData::Instance().GetDebug())
-					{
-						cLog::Instance() << "cDxr3SpuDecoder::setTime: odd = " << fodd << " even = " << feven << "\n";
-					}
-                    i += 5;
-                    break;
-
-                case CMD_SPU_MENU:
-					if (cDxr3ConfigData::Instance().GetDebug())
-					{
-						cLog::Instance() << "cDxr3SpuDecoder::setTime: spu menu\n";
-					}
-                    state = spMENU;
-
-                    i++;
-                    break;
-
-                default:
-                    esyslog("invalid sequence in control header (%.2x)\n", spu[i]);
-                    assert(0);
-                    i++;
-                    break;
-                }
-            }
-            if (fodd != 0 && feven != 0) 
-			{
-                delete spubmp;
-                spubmp = new cDxr3SpuBitmap(size, spu + fodd, spu + feven, spu + feven, spu + cmdOffs());
-            }
-        } 
-		else if (!clean)
-		{
-            state = spSHOW;
-		}
-
-        if (state == spSHOW || state == spMENU)
-		{
-            Draw();
-		}
-
-        if (state == spHIDE)
-		{
-            Hide();
-		}
-
-        if (pts == 0)
-		{
-            return 0;
-		}
-    }
-
-    return 1;
+// ! set pts
+int cDxr3SpuDecoder::setTime(uint32_t pts) 
+{ 
+    return (pts == 0) ? 0 : 1; 
 }
diff --git a/dxr3spudecoder.h b/dxr3spudecoder.h
index 5b510d6..b05540d 100644
--- a/dxr3spudecoder.h
+++ b/dxr3spudecoder.h
@@ -3,9 +3,6 @@
  *
  * Copyright (C) 2004 Christian Gmeiner
  *
- * Orginal:
- *    Copyright (C) 2001.2002 Andreas Schultz <aschultz@warp10.net>
- *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
  * as published by the Free Software Foundation; either version 2.1
@@ -24,140 +21,39 @@
 
 #ifndef _DXR3SPUDECODER_H_
 #define _DXR3SPUDECODER_H_
-
+ 
 #include "dxr3vdrincludes.h"
-#include <inttypes.h>
-
-// ==================================
-typedef struct sDxr3SpuPalDescr 
-{
-    uint8_t index;
-    uint8_t trans;
-
-    bool operator != (const sDxr3SpuPalDescr pd) const {
-        return index != pd.index && trans != pd.trans;
-    };
-} aDxr3SpuPalDescr[4];
-
-// ==================================
-//! describes a rectal
-struct sDxr3SpuRect 
-{
-    int x1, y1;
-    int x2, y2;
-
-    int width() 
-	{
-        return x2 - x1 + 1;
-    };
-
-    int height() 
-	{
-        return y2 - y1 + 1;
-    };
-
-    bool operator != (const sDxr3SpuRect r) const 
-	{
-        return r.x1 != x1 || r.y1 != y1 || r.x2 != x2 || r.y2 != y2;
-    };
-};
-
-// ==================================
-class cDxr3SpuPalette 
-{
-private:
-    uint32_t palette[16];
-	
-public:
-    void setPalette(const uint32_t * pal);
-    uint32_t getColor(uint8_t idx, uint8_t trans) const;
-};
-
-// ==================================
-class cDxr3SpuBitmap 
-{
-private:
-    sDxr3SpuRect bmpsize;
-    sDxr3SpuRect minsize[4];
-    uint8_t *bmp;
-	
-    void putPixel(int xp, int yp, int len, uint8_t colorid);
-    void putFieldData(int field, uint8_t * data, uint8_t * endp);
-	
-public:
-	cDxr3SpuBitmap(sDxr3SpuRect size, uint8_t * fodd, uint8_t * eodd, uint8_t * feven, uint8_t * eeven);
-    ~cDxr3SpuBitmap();
-		
-    bool getMinSize(const aDxr3SpuPalDescr paldescr, sDxr3SpuRect & size) const;
-    cBitmap *getBitmap(const aDxr3SpuPalDescr paldescr, const cDxr3SpuPalette & pal, sDxr3SpuRect & size) const;
-};
+#include "dxr3interface.h"
 
 // ==================================
-class cDxr3SpuDecoder : public cSpuDecoder  
+//! spu decoder
+/*!
+	cDxr3SpuDecoder is used to show DVD
+	navigation and subtitles.
+	We make here use of the DVD-Functions
+	of the dxr3 driver/card.
+*/
+class cDxr3SpuDecoder : public cSpuDecoder 
 {
 public: 
-    cDxr3SpuDecoder();
-    ~cDxr3SpuDecoder();
-
-    int setTime(uint32_t pts);
-
-    void setScaleMode(cSpuDecoder::eScaleMode ScaleMode);
-    void setPalette(uint32_t * pal);
-    void setHighlight(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint32_t palette);
-    void clearHighlight();
-    void Empty();
-    void processSPU(uint32_t pts, uint8_t * buf);
-
-	#if VDRVERSNUM >= 10311
-    void Hide();
-    void Draw();
-    bool IsVisible() { return osd != NULL; }
-	#endif
-
-private:
-    cOsd * osd;
-
-    // processing state
-    uint8_t *spu;
-    uint32_t spupts;
-    bool clean;
-    bool ready;
-	
-    enum spFlag { spNONE, spHIDE, spSHOW, spMENU };
-    spFlag state;
+	cDxr3SpuDecoder(); 
+	~cDxr3SpuDecoder()	{}
 	
-    cSpuDecoder::eScaleMode scaleMode;
+	int setTime(uint32_t pts); 
 	
-    // highligh area
-    bool highlight;
-    sDxr3SpuRect hlpsize;
-    aDxr3SpuPalDescr hlpDescr;
-	
-    // palette
-    cDxr3SpuPalette palette;
-	
-    // spu info's
-    sDxr3SpuRect size;
-    aDxr3SpuPalDescr palDescr;
-	
-    uint16_t DCSQ_offset;
-    uint16_t prev_DCSQ_offset;
-	
-    cDxr3SpuBitmap *spubmp;
-
-    int cmdOffs()	{ return ((spu[2] << 8) | spu[3]); }
-    int spuSize()	{ return ((spu[0] << 8) | spu[1]); }
-
-    int ScaleYcoord(int value);
-    int ScaleYres(int value);
-    void DrawBmp(sDxr3SpuRect & size, cBitmap * bmp);
-};
-
-// ==================================
-inline uint32_t cDxr3SpuPalette::getColor(uint8_t idx, uint8_t trans) const
-{
-    uint8_t t = trans == 0x0f ? 0xff : trans << 4;
-    return palette[idx] | (t << 24);
-}
+	void setScaleMode(cSpuDecoder::eScaleMode ScaleMode); 
+	void setPalette(uint32_t * pal);
+	void setHighlight(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint32_t palette); 
+	void clearHighlight(); 
+	void Empty(); 
+	void Hide(); 
+	void Draw(); 
+	bool IsVisible()	{ return m_visible; } 
+	void processSPU(uint32_t pts, uint8_t * buf); 
 
+private:
+	cDxr3Interface&	m_Interface;	///< interface to dxr3 driver
+	bool			m_visible;		///< is anything visible (nav, osd, subtilte)
+}; 
+ 
 #endif /*_DXR3SPUDECODER_H_*/
diff --git a/dxr3tools.h b/dxr3tools.h
index 97c112f..03708bf 100644
--- a/dxr3tools.h
+++ b/dxr3tools.h
@@ -48,44 +48,6 @@ namespace Tools
 	}
 
 	// ==================================
-	//! convert YUV to Rgb
-	inline unsigned int YUV2Rgb(unsigned int yuv_color)
-	{
-		int Y, Cb, Cr;
-		int Ey, Epb, Epr;
-		int Eg, Eb, Er;
-		
-		Y = (yuv_color >> 16) & 0xff;
-		Cb = (yuv_color) & 0xff;
-		Cr = (yuv_color >> 8) & 0xff;
-		
-		Ey = (Y - 16);
-		Epb = (Cb - 128);
-		Epr = (Cr - 128);
-
-		Eg = (298 * Ey - 100 * Epb - 208 * Epr) / 256;
-		Eb = (298 * Ey + 516 * Epb) / 256;
-		Er = (298 * Ey + 408 * Epr) / 256;
-		
-		if (Eg > 255)
-			Eg = 255;
-		if (Eg < 0)
-			Eg = 0;
-		
-		if (Eb > 255)
-			Eb = 255;
-		if (Eb < 0)
-			Eb = 0;
-		
-		if (Er > 255)
-			Er = 255;
-		if (Er < 0)
-			Er = 0;
-		
-		return Eb | (Eg << 8) | (Er << 16);
-	}
-
-	// ==================================
 	//! write a string via vdr to OSD
 	inline void WriteInfoToOsd(string x)
 	{