Index: trunk/MagicSoft/Cosy/videodev/Camera.cc
===================================================================
--- trunk/MagicSoft/Cosy/videodev/Camera.cc	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/Camera.cc	(revision 2278)
@@ -47,4 +47,5 @@
 void Camera::SigInit()
 {
+    return;
     struct sigaction act, old;
 
@@ -215,8 +216,6 @@
     while (img < end)
     {
-        *beg = *img;
-
+        *beg++ = *img;
         img += depth;
-        beg++;
     }
 }
Index: trunk/MagicSoft/Cosy/videodev/Camera.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/Camera.h	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/Camera.h	(revision 2278)
@@ -14,7 +14,8 @@
 #endif
 
+#include "PixGetter.h"
 #include "PixClient.h"
 
-class Camera
+class Camera : public PixGetter
 {
 private:
Index: trunk/MagicSoft/Cosy/videodev/CaosFilter.cc
===================================================================
--- trunk/MagicSoft/Cosy/videodev/CaosFilter.cc	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/CaosFilter.cc	(revision 2278)
@@ -28,31 +28,37 @@
 }
 
-float CaosFilter::Mean(const byte *buffer, const int offset, int *min, int *max)
-{
-    double mean = 0.0;
-
-    *min = 0xff;
-    *max = 0x00;
+void CaosFilter::GetStat(const byte *buffer, const int offset, double *mean, double *sdev)
+{
+    double sum = 0;
+    double sq  = 0;
+
+    byte *s  = (byte*)buffer;
+    const byte *e0 = s+768*576;
 
     //
     // calculate mean value
     //
-    for (int x=offset; x<768-offset; x++)
-        for (int y=offset; y<576-offset; y++)
-        {
-            byte val = buffer[y*768+x];
-
-            mean += val;
-
-            if (val>*max)
-                *max = val;
-
-            if (val<*min)
-                *min = val;
-        }
-
-    mean /= (768-2*offset)*(576-2*offset);
-
-    return mean;
+    while (s<e0)
+    {
+        const byte *e = s+576-offset;
+        s += offset;
+
+        while (s<e)
+        {
+            sum += *s;
+            sq  += *s * *s;
+            s++;
+        }
+
+        s+=offset;
+    }
+
+    const Int_t sz = (768-2*offset)*(576-2*offset);
+
+    sum /= sz;
+    sq  /= sz;
+
+    *mean = sum;
+    *sdev = sqrt(sq-sum*sum);
 }
 
@@ -80,25 +86,4 @@
     return (int)my*768 + (int)mx;
 }
-
-float CaosFilter::SDev(const byte *buffer, const int offset, const double mean)
-{
-    //
-    // calculate sigma
-    //
-    double sdev=0.0;
-
-    for (int x=offset; x<768-offset; x++)
-        for (int y=offset; y<576-offset; y++)
-        {
-            const float val = mean - buffer[y*768+x];
-
-            sdev += val*val;
-        }
-
-    sdev /= (768-2*offset)*(576-2*offset)-1;
-
-    return sqrt(sdev);
-}
-
 
 int CaosFilter::GetMeanPosition(const byte *bitmap, const int x, const int y,
@@ -389,27 +374,20 @@
     const int offset = 10;
 
-    int max;
-    int min;
-
-    const float mean = Mean(img, offset, &min, &max);
-    const float sdev = SDev(img, offset, mean);
-
-    const float cut = mean + 2.5*sdev;
+    double mean, sdev;
+    GetStat(img, offset, &mean, &sdev);
+
+    const byte max = mean+2.5*sdev>254 ? 254 : (byte)(mean+2.5*sdev);
 
     //
     // clean image from noise
     //
-    for (int x=0; x<768; x++)
-        for (int y=0; y<576; y++)
-        {
-            if (img[y*768+x]>cut)
-                continue;
-
-            //
-            // FIXME: Create LOOKUP Table!
-            //
-
-            img[y*768+x] = 0;
-        }
+    const byte *e = img+768*576;
+    byte *i = img;
+    while (i<e)
+    {
+        if (*i<=max)
+            *i = 0;
+        i++;
+    }
 
     //
@@ -511,27 +489,20 @@
     const int offset = 10;
 
-    int max;
-    int min;
-
-    const float mean = Mean(img, offset, &min, &max);
-    const float sdev = SDev(img, offset, mean);
-
-    const float cut = mean + 2.5*sdev;
+    double mean, sdev;
+    GetStat(img, offset, &mean, &sdev);
+
+    const byte cut = mean+2.5*sdev>254 ? 254 : (byte)(mean + 2.5*sdev);
 
     //
     // clean image from noise
     //
-    for (int x=0; x<768; x++)
-        for (int y=0; y<576; y++)
-        {
-            if (img[y*768+x]>cut)
-                continue;
-
-            //
-            // FIXME: Create LOOKUP Table!
-            //
-
-            img[y*768+x] = 0;
-        }
+    const byte *e = img+768*576;
+    byte *i = img;
+    while (i<e)
+    {
+        if (*i<=cut)
+            *i = 0;
+        i++;
+    }
 
     //
Index: trunk/MagicSoft/Cosy/videodev/CaosFilter.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/CaosFilter.h	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/CaosFilter.h	(revision 2278)
@@ -19,9 +19,6 @@
                            byte *buffer, const int col);
 
-    static float Mean(const byte *buffer, const int offset,
-                      int *min, int *max);
-
-    static float SDev(const byte *buffer, const int offset,
-                      const double mean);
+    static void  GetStat(const byte *buffer, const int offset,
+                         double *mean, double *sdev);
 
     static int   GetMeanPosition(const byte *bitmap,
Index: trunk/MagicSoft/Cosy/videodev/Filter.cc
===================================================================
--- trunk/MagicSoft/Cosy/videodev/Filter.cc	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/Filter.cc	(revision 2278)
@@ -24,32 +24,28 @@
 }
 
-float Filter::Mean(const byte *buffer, const int offset, int *min, int *max)
+float Filter::Mean(const byte *buffer, const int offset)
 {
     double mean = 0.0;
 
-    *min = 0xff;
-    *max = 0x00;
+    byte *s  = (byte*)buffer;
+    const byte *e0 = s+768*576;
 
     //
     // calculate mean value
     //
-    for (int x=offset; x<768-offset; x++)
-        for (int y=offset; y<576-offset; y++)
-        {
-            byte val = buffer[y*768+x];
+    while (s<e0)
+    {
+        const byte *e = s+576-offset;
+        s += offset;
 
-            mean += val;
+        while (s<e)
+            mean += *s++;
 
-            if (val>*max)
-                *max = val;
+        s+=offset;
+    }
 
-            if (val<*min)
-                *min = val;
-        }
+    return mean / ((768-2*offset)*(576-2*offset));
+}
 
-    mean /= (768-2*offset)*(576-2*offset);
-
-    return mean;
-}
 
 float Filter::SDev(const byte *buffer, const int offset, const double mean)
@@ -101,27 +97,20 @@
     const int offset = 10;
 
-    int max;
-    int min;
-
-    const float mean = Mean(img, offset, &min, &max);
+    const float mean = Mean(img, offset);
     const float sdev = SDev(img, offset, mean);
 
-    const float cut = mean + 2.5*sdev;
+    const byte cut = mean+2.5*sdev>254 ? 254 : (byte)(mean + 2.5*sdev);
 
     //
     // clean image from noise
     //
-    for (int x=0; x<768; x++)
-        for (int y=0; y<576; y++)
-        {
-            if (img[y*768+x]>cut)
-                continue;
-
-            //
-            // FIXME: Create LOOKUP Table!
-            //
-
-            img[y*768+x] = 0;
-        }
+    const byte *e = img+768*576;
+    byte *i = img;
+    while (i<e)
+    {
+        if (*i<=cut)
+            *i = 0;
+        i++;
+    }
 
     //
@@ -203,32 +192,2 @@
 }
 
-void Filter::Stretch(byte *img)
-{
-    const int offset = 25;
-
-    int max;
-    int min;
-
-    /*const float mean =*/Mean(img, offset, &min, &max);
-
-    const byte diff = max-min;
-
-    for (int x=0; x<768; x++)
-        for (int y=0; y<576; y++)
-        {
-            byte &b = img[y*768+x];
-
-            if (b<min)
-            {
-                b=0;
-                continue;
-            }
-            if (b>max)
-            {
-                b=max;
-                continue;
-            }
-            b -= min;
-            b *= 255/diff;
-        }
-}
Index: trunk/MagicSoft/Cosy/videodev/Filter.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/Filter.h	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/Filter.h	(revision 2278)
@@ -17,6 +17,5 @@
                            byte *buffer, const int col);
 
-    static float Mean(const byte *buffer, const int offset,
-                      int *min, int *max);
+    static float Mean(const byte *buffer, const int offset);
 
     static float SDev(const byte *buffer, const int offset,
@@ -29,5 +28,4 @@
 public:
     static void Execute(byte *img);
-    static void Stretch(byte *img);
 
     ClassDef(Filter, 0)
Index: trunk/MagicSoft/Cosy/videodev/FilterLed.cc
===================================================================
--- trunk/MagicSoft/Cosy/videodev/FilterLed.cc	(revision 2278)
+++ trunk/MagicSoft/Cosy/videodev/FilterLed.cc	(revision 2278)
@@ -0,0 +1,387 @@
+#include "FilterLed.h"
+
+#include <memory.h>   // memset
+#include <iostream.h> // cout
+
+#include "Led.h"
+#include "Leds.h"
+#include "Ring.h"
+
+ClassImp(FilterLed);
+
+void FilterLed::DrawCircle(float cx, float cy, float rpix, byte col) const
+{
+    if (cx-rpix<1 || cy-rpix<1 || cx+rpix>fW-2 || cy+rpix>fH-2)
+        return;
+
+    for (int dx=-(int)(rpix*0.7); dx<(int)(rpix*0.7); dx++)
+    {
+        const int dy = (int)sqrt(rpix*rpix-dx*dx);
+        fImg[(int)(cx+dx) + (int)(cy-dy)*fW] = col;
+        fImg[(int)(cx+dx) + (int)(cy+dy)*fW] = col;
+        fImg[(int)(cx-dy) + (int)(cy+dx)*fW] = col;
+        fImg[(int)(cx+dy) + (int)(cy+dx)*fW] = col;
+    }
+}
+
+void FilterLed::DrawCircle(const Ring &l, byte col=0x40) const
+{
+    DrawCircle(l.GetX(), l.GetY(), l.GetR(), col);
+}
+
+void FilterLed::DrawCircle(const Ring &l, double r, byte col=0x40) const
+{
+    DrawCircle(l.GetX(), l.GetY(), r, col);
+}
+
+void FilterLed::DrawBox(const int x1, const int y1,
+                        const int x2, const int y2,
+                        const int col) const
+{
+    for (int x=x1; x<x2+1; x++)
+        for (int y=y1; y<y2+1; y++)
+            if (x>=0 && x<fW-1 && y>=0 && y<fH-1)
+                fImg[y*fW+x] = col;
+}
+
+void FilterLed::MarkPoint(const Led &led) const
+{
+    const int x = (int)(led.GetX()+.5);
+    const int y = (int)(led.GetY()+.5);
+    const int m = (int)(led.GetMag());
+
+    MarkPoint(x, y, m);
+}
+
+void FilterLed::MarkPoint(Float_t px, Float_t py, Float_t mag) const
+{
+    const int x = (int)(px+.5);
+    const int y = (int)(py+.5);
+    const int m = (int)(mag);
+
+    DrawBox(x-8, y, x-5, y, m);
+    DrawBox(x, y+5, x, y+8, m);
+    DrawBox(x+5, y, x+8, y, m);
+    DrawBox(x, y-8, x, y-5, m);
+    return;
+}
+
+void FilterLed::GetMinMax(const int offset, byte *min, byte *max) const
+{
+    *min = fImg[0];
+    *max = fImg[0];
+
+    byte *s = (byte*)fImg;
+    const byte *e0 = s+fW*fH;
+
+    //
+    // calculate mean value
+    //
+    while (s<e0)
+    {
+        const byte *e = s+fH-offset;
+        s += offset;
+
+        while (s<e)
+        {
+            if (*s>*max)
+            {
+                *max = *s;
+                if (*max-*min==255)
+                    return;
+            }
+            if (*s<*min)
+            {
+                *min = *s;
+                if (*max-*min==255)
+                    return;
+            }
+            s++;
+        }
+        s+=offset;
+    }
+}
+
+int FilterLed::GetMeanPosition(const int x, const int y,
+                               const int box, float &mx, float &my) const
+{
+    unsigned int sumx=0;
+    unsigned int sumy=0;
+    unsigned int sum =0;
+
+    for (int dx=x-box; dx<x+box+1; dx++)
+        for (int dy=y-box; dy<y+box+1; dy++)
+        {
+            const byte &m = fImg[dy*fW+dx];
+
+            sumx += m*dx;
+            sumy += m*dy;
+            sum  += m;
+        }
+
+    mx = (float)sumx/sum;
+    my = (float)sumy/sum;
+
+    return (int)my*fW + (int)mx;
+}
+
+int FilterLed::GetMeanPosition(const int x, const int y, const int box) const
+{
+    float mx, my;
+    return GetMeanPosition(x, y, box, mx, my);
+}
+/*
+void FilterLed::RemoveTwins(Leds &leds, Double_t radius)
+{
+    for (int i=first; i<leds.GetEntriesFast(); i++)
+    {
+        const Led &led1 = leds(i);
+
+        const Double_t x1 = led1.GetX();
+        const Double_t y1 = led1.GetY();
+
+        for (int j=first; j<leds.GetEntriesFast(); j++)
+        {
+            if (j==i)
+                continuel
+
+            const Led &led2 = leds(j);
+
+            const Double_t x2 = led2.GetX();
+            const Double_t y2 = led2.GetY();
+
+            const Double_t dx = x2-x1;
+            const Double_t dy = y2-y1;
+
+            if (dx*dx+dy*dy<radius*radius)
+            {
+                // FIXME: Interpolation
+                leds.Remove(led2);
+            }
+        }
+    }
+}
+*/
+void FilterLed::RemoveTwinsInterpol(Leds &leds, Int_t first, Double_t radius) const
+{
+    const Int_t num=leds.GetEntriesFast();
+
+    for (int i=first; i<num; i++)
+    {
+        Led *led1 = (Led*)leds.UncheckedAt(i);
+        if (!led1)
+            continue;
+
+        const Double_t x1 = led1->GetX();
+        const Double_t y1 = led1->GetY();
+
+        Double_t mag = led1->GetMag();
+        Double_t x = x1*mag;
+        Double_t y = y1*mag;
+
+        Double_t sqm = mag*mag;
+        Double_t sqx = x*x;
+        Double_t sqy = y*y;
+
+        Int_t n=1;
+
+        for (int j=first; j<num; j++)
+        {
+            if (i==j)
+                continue;
+
+            Led *led2 = (Led*)leds.UncheckedAt(j);
+            if (!led2)
+                continue;
+
+            Double_t x2 = led2->GetX();
+            Double_t y2 = led2->GetY();
+
+            const Double_t dx = x2-x1;
+            const Double_t dy = y2-y1;
+
+            if (dx*dx+dy*dy>radius*radius)
+                continue;
+
+            // Multiply with weihgt
+            const Double_t w = led2->GetMag();
+            x2 *= w;
+            y2 *= w;
+
+            x   += x2;
+            y   += y2;
+            mag += w;
+
+            sqx += x2*x2;
+            sqy += y2*y2;
+            sqm += w*w;
+
+            n++;
+            leds.Remove(led2);
+        }
+
+        x /= mag;
+        y /= mag;
+
+        sqx /= sqm;
+        sqy /= sqm;
+
+        leds.Add(x, y, 0/*sqrt(sqx-x*x)*/, 0/*sqrt(sqy-y*y)*/, mag/n);
+        leds.Remove(led1);
+    }
+    leds.Compress();
+}
+
+void FilterLed::ExecuteAndMark(Leds &leds, int xc, int yc) const
+{
+    const Int_t first = leds.GetEntriesFast();
+
+    Execute(leds, xc, yc);
+
+    // Mark Stars in image
+    for (int i=first; i<leds.GetEntriesFast(); i++)
+        MarkPoint(leds(i));
+}
+
+void FilterLed::Execute(int xc, int yc) const
+{
+    Leds leds;
+    ExecuteAndMark(leds, xc, yc);
+}
+
+void FilterLed::Execute(Leds &leds, int xc, int yc) const
+{
+    int x0 = xc-fBoxW;
+    int x1 = xc+fBoxW;
+    int y0 = yc-fBoxH;
+    int y1 = yc+fBoxH;
+
+    if (x0<0) x0=0;
+    if (y0<0) y0=0;
+    if (x1>fW) x1=fW;
+    if (y1>fH) y1=fH;
+
+    const int wx = x1-x0;
+    const int hy = y1-y0;
+
+    double sum = 0;
+    double sq  = 0;
+
+    for (int x=x0; x<x1; x++)
+        for (int y=y0; y<y1; y++)
+        {
+            byte &b = fImg[y*fW+x];
+
+            sum += b;
+            sq  += b*b;
+        }
+
+    sum /= wx*hy;
+    sq  /= wx*hy;
+
+    const double sdev = sqrt(sq-sum*sum);
+    const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
+
+    //
+    // clean image from noise
+    // (FIXME: A lookup table could accelerate things...
+    //
+    for (int x=x0; x<x1; x++)
+        for (int y=y0; y<y1; y++)
+        {
+            byte &b = fImg[y*fW+x];
+            if (b<=max)
+                b = 0;
+        }
+
+    //
+    // find mean points
+    //
+    const int maxpnt = wx*hy>0x4000?0x4000:wx*hy;
+
+    int  pos[maxpnt]; // (Use 'new' instead for big numbers!)
+    byte mag[maxpnt]; // (Use 'new' instead for big numbers!)
+
+    int cnt = 0;
+    for (int x=x0; x<x1; x++)
+        for (int y=y0; y<y1; y++)
+        {
+            byte &b = fImg[y*fW+x];
+            if (b==0)
+                continue;
+
+            const int ipos = GetMeanPosition(x, y, 5);
+
+            int j;
+            for (j=0; j<cnt; j++)
+            {
+                if (pos[j]==ipos)
+                {
+                    if (mag[j] < 0xf0)
+                        mag[j] += 0x10;
+                    break;
+                }
+            }
+            if (cnt && j<cnt)
+                continue;
+
+            pos[cnt] = ipos;
+            mag[cnt] = 0x10;
+
+            cnt++;
+            if (cnt==0x4000)
+                return;
+        }
+
+    if (cnt>1000)
+        cout << "FIXME: Cnt>1000." << endl;
+
+    //
+    // Add found positions to array
+    //
+    const int first=leds.GetEntriesFast();
+
+    for (int i=0; i<cnt; i++)
+    {
+        if (mag[i]<=0x80) // 0xa0
+            continue;
+
+        Float_t mx, my;
+        GetMeanPosition(pos[i]%fW, pos[i]/fW, 5, mx, my);
+
+        leds.Add(mx, my, 0, 0, mag[i]);
+    }
+
+    RemoveTwinsInterpol(leds, first, 5);
+}
+
+void FilterLed::Stretch() const
+{
+    byte min, max;
+    GetMinMax(25, &min, &max);
+
+    if (min==max || max-min>230) // 255/230=1.1
+        return;
+
+    const float scale = 255./(max-min);
+
+    byte *b = fImg;
+    const byte *e = fImg+fW*fH;
+
+    while (b<e)
+    {
+        if (*b<min)
+        {
+            *b++=0;
+            continue;
+        }
+        if (*b>max)
+        {
+            *b++=255;
+            continue;
+        }
+        *b = (byte)((*b-min)*scale);
+        b++;
+    }
+}
+
Index: trunk/MagicSoft/Cosy/videodev/FilterLed.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/FilterLed.h	(revision 2278)
+++ trunk/MagicSoft/Cosy/videodev/FilterLed.h	(revision 2278)
@@ -0,0 +1,64 @@
+#ifndef CAOS_FilterLed
+#define CAOS_FilterLed
+
+#ifndef __CINT__
+#include <TROOT.h>
+#endif
+
+typedef unsigned char byte;
+
+class Led;
+class Leds;
+class Ring;
+
+class FilterLed
+{
+    byte *fImg;
+    int fW;
+    int fH;
+    int fBoxW;
+    int fBoxH;
+    float fCut;
+
+    void GetMinMax(const int offset, byte *min, byte *max) const;
+    int  GetMeanPosition(const int x, const int y, const int box) const;
+    int  GetMeanPosition(const int x, const int y, const int box, float &mx, float &my) const;
+    void RemoveTwinsInterpol(Leds &leds, Int_t first, Double_t radius) const;
+    void DrawBox(const int x1, const int y1,
+                 const int x2, const int y2,
+                 const int col) const;
+
+public:
+    FilterLed(byte *img, int w, int h, double cut=2.5)
+        : fImg(img), fW(w), fH(h), fBoxW(w/2), fBoxH(h/2), fCut(cut)
+    {
+    }
+
+    FilterLed(byte *img, int w, int h, int box, double cut=2.5)
+        : fImg(img), fW(w), fH(h), fBoxW(box), fBoxH(box), fCut(cut)
+    {
+    }
+
+    FilterLed(byte *img, int w, int h, int boxw, int boxh, double cut=2.5)
+        : fImg(img), fW(w), fH(h), fBoxW(boxw), fBoxH(boxh), fCut(cut)
+    {
+    }
+
+    void Execute(Leds &leds, int xc, int yc) const;
+    void Execute(Leds &leds) const { Execute(leds, fW/2, fH/2); }
+    void ExecuteAndMark(Leds &leds, int xc, int yc) const;
+    void ExecuteAndMark(Leds &leds) const { ExecuteAndMark(leds, fW/2, fH/2); }
+    void Execute(int xc, int yc) const;
+    void Execute() const { Execute(fW/2, fH/2); }
+    void MarkPoint(const Led &led) const;
+    void MarkPoint(Float_t x, Float_t y, Float_t mag) const;
+    void Stretch() const;
+    void DrawCircle(float cx, float cy, float r, byte col=0x40) const;
+    void DrawCircle(float r, byte col=0x40) const { DrawCircle(r, fW/2.+.5, fH/2.+.5, col); }
+    void DrawCircle(const Ring &c, byte col=0x40) const;
+    void DrawCircle(const Ring &c, double r, byte col) const;
+
+    ClassDef(FilterLed, 0)
+};
+
+#endif
Index: trunk/MagicSoft/Cosy/videodev/Makefile
===================================================================
--- trunk/MagicSoft/Cosy/videodev/Makefile	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/Makefile	(revision 2278)
@@ -34,7 +34,6 @@
            PngReader.cc \
            PixClient.cc \
-	   Filter.cc \
-	   Filter2.cc \
-           CaosFilter.cc \
+           PixGetter.cc \
+	   FilterLed.cc \
            Writer.cc 
 
Index: trunk/MagicSoft/Cosy/videodev/PixGetter.cc
===================================================================
--- trunk/MagicSoft/Cosy/videodev/PixGetter.cc	(revision 2278)
+++ trunk/MagicSoft/Cosy/videodev/PixGetter.cc	(revision 2278)
@@ -0,0 +1,2 @@
+#include "PixGetter.h"
+
Index: trunk/MagicSoft/Cosy/videodev/PixGetter.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/PixGetter.h	(revision 2278)
+++ trunk/MagicSoft/Cosy/videodev/PixGetter.h	(revision 2278)
@@ -0,0 +1,10 @@
+#ifndef COSY_PixGetter
+#define COSY_PixGetter
+
+class PixGetter
+{
+public:
+    virtual void ExitLoop() {}
+};
+
+#endif
Index: trunk/MagicSoft/Cosy/videodev/PngReader.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/PngReader.h	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/PngReader.h	(revision 2278)
@@ -14,9 +14,11 @@
 #endif
 
+#include "PixGetter.h"
+
 class PixClient;
 
 typedef unsigned char byte;
 
-class PngReader
+class PngReader : public PixGetter
 {
 private:
Index: trunk/MagicSoft/Cosy/videodev/VideodevLinkDef.h
===================================================================
--- trunk/MagicSoft/Cosy/videodev/VideodevLinkDef.h	(revision 2019)
+++ trunk/MagicSoft/Cosy/videodev/VideodevLinkDef.h	(revision 2278)
@@ -6,7 +6,8 @@
 
 #pragma link C++ class Writer+;
-#pragma link C++ class Filter+;
-#pragma link C++ class Filter2+;
-#pragma link C++ class CaosFilter+;
+//#pragma link C++ class Filter+;
+//#pragma link C++ class Filter2+;
+#pragma link C++ class FilterLed+;
+//#pragma link C++ class CaosFilter+;
 
 #pragma link C++ class Camera+;