VDR segfaults mit usbremote plugin – woran liegt es?

/*
 * usbremote.c: USB Remote Controler plugin for the Video Disk Recorder
 *
 * See the README file for copyright information and how to reach the author.
 *
 */


#include <vdr/plugin.h>
#include <vdr/remote.h>
#include <vdr/thread.h>
#include "hostlib.h"
#include <stdio.h>


static const char *VERSION        = "2.0.0";
static const char *DESCRIPTION    = "USB Remote Control";


#define DO_DEBUG 0


#if DO_DEBUG
#define DEBUG(x) (printf x)
#else
#define DEBUG(x) (void)0
#endif




/*****************************************************************************/
class cRemoteUSB : protected cRemote, protected cThread
/*****************************************************************************/
{
protected:
  static const uint64_t INVALID_KEY = (uint64_t) -1;
  avr_device_t _device;
  int _polldelay;
  int _repeatdelay;
  int _repeatfreq;
  //int _repeattimeout;
  bool _ready;
public:
  cRemoteUSB();
  virtual ~cRemoteUSB();
  virtual uint64_t getKey(void);
  virtual eKeys getStaticKeys(void);
  virtual void Action(void);
  virtual bool Initialize(void);
  virtual bool Ready(void);
};




// ---------------------------------------------------------------------------
cRemoteUSB::cRemoteUSB()
    :cRemote("RemoteUSB")
// ---------------------------------------------------------------------------
{
    _polldelay     = 50;   // ms
    _repeatdelay   = 350;  // ms
    _repeatfreq    = 100;  // ms
    //_repeattimeout = 500;  // ms
    _device = NULL;
    _ready = false;


    _device = avr_open();
    if (_device != NULL ){
        _ready = true;
        Start();
        DEBUG(("USB Remote Receiver found and startet"));
    }else{
        DEBUG(("error: cannot find USB Remote Receiver"));


    }
}


// ---------------------------------------------------------------------------
cRemoteUSB::~cRemoteUSB()
// ---------------------------------------------------------------------------
{
    Cancel();
    if (_device) avr_close(_device);
}




// ---------------------------------------------------------------------------
void cRemoteUSB::Action(void)
// ---------------------------------------------------------------------------
{
    cTimeMs FirstTime,LastTime;
    uint64_t code, lastcode = INVALID_KEY;


    for (;;)
    {
        if (_polldelay)
            usleep(1000*_polldelay);


        code = getKey();


        if (code == INVALID_KEY){
            usleep(1000*_polldelay);
            continue;
        }






        if (code != lastcode)
        {
                lastcode = code;
                DEBUG(("put: %016llx \n",code));
                code = code | 0x8000;
                Put(code);
                FirstTime.Set();
                LastTime.Set();
        }
        else
        {
                if (FirstTime.Elapsed() <_repeatdelay || LastTime.Elapsed() < _repeatfreq)
                    continue;
                DEBUG(("put again: %016llx \n",code));
                code = code | 0x8000;
                Put(code,true);
                LastTime.Set();
        }


    }
}




// ---------------------------------------------------------------------------
uint64_t cRemoteUSB::getKey(void)
// ---------------------------------------------------------------------------
{
    uint64_t code = 0;
    char buffer[50];
    int bufferCounter = 3;
    int len = 0;


    int rc5Code[20];
    int bitCounter = 0;
    bool lastLevelHigh = true;
    bool newBit = false;


    len = avr_get_response(_device, AVR_INFRA_GET_CODE, 0, buffer, 50);
    if (len > 1){
        avr_send_command(_device, AVR_INFRA_BUFFER_EMPTY, 0);


        for(;bufferCounter <= len;){
                if (newBit){
                        if ((unsigned char)buffer[bufferCounter] < 15) lastLevelHigh = lastLevelHigh ? false : true ;
                        bufferCounter++;
                        newBit = false;
                }else{
                        rc5Code[bitCounter] = lastLevelHigh ? 1 : 0;
                        bitCounter++;
                        if ((unsigned char)buffer[bufferCounter] < 15) bufferCounter++;
                        newBit = true;
                        lastLevelHigh = lastLevelHigh ? false : true;
                }
        }


        // Ceck if it is RC5
        if ( !(rc5Code[0] && rc5Code[1] && (bitCounter == 14) ) ) return INVALID_KEY;


        // Set Code to 0
        code = 0;


        // Key Code
        if (rc5Code[13] == 1) code = code | 0x0001;
        if (rc5Code[12] == 1) code = code | 0x0002;
        if (rc5Code[11] == 1) code = code | 0x0004;
        if (rc5Code[10] == 1) code = code | 0x0008;
        if (rc5Code[9] == 1) code = code | 0x0010;
        if (rc5Code[8] == 1) code = code | 0x0020;


        // Addres Code
        if (rc5Code[7] == 1) code = code | 0x0100;
        if (rc5Code[6] == 1) code = code | 0x0200;
        if (rc5Code[5] == 1) code = code | 0x0400;
        if (rc5Code[4] == 1) code = code | 0x0800;
        if (rc5Code[3] == 1) code = code | 0x1000;


        // Toggle Bit
        if (rc5Code[2] == 1) code = code | 0x8000;


        //DEBUG((" (len: %d, bytes: %d, nummber: %d, seperator: %d)\n",len, (unsigned int)buffer[0],(unsigned int)buffer[1],(unsigned int)buffer[2] ));


        return code;
    }
    return INVALID_KEY;
}


// ---------------------------------------------------------------------------
eKeys cRemoteUSB::getStaticKeys(void)
// ---------------------------------------------------------------------------
{
        int len;
        char buffer[10];


        len = avr_get_response(_device, AVR_DDR_GET , 0, buffer, 10);
        if (len > 0){
                DEBUG(("Pins direction: %d\n", (int)buffer[0]));
        }


        len = avr_get_response(_device, AVR_DDR_GET , 0, buffer, 10);
        if (len > 0){
                DEBUG(("Pins out/pull-up: %04x\n", (unsigned int)buffer[0]));
        }


        len = avr_get_response(_device, AVR_PIN_GET , 0, buffer, 10);
        if (len > 0){
                DEBUG(("Pins level: %d\n", (int)buffer[0]));
        }


        return kNone;


}


// ---------------------------------------------------------------------------
bool cRemoteUSB::Initialize(void)
// ---------------------------------------------------------------------------
{
    return true;
}




// ---------------------------------------------------------------------------
bool cRemoteUSB::Ready(void)
// ---------------------------------------------------------------------------
{
    return _ready;
}




/*****************************************************************************/
class cPluginUSBRemote : public cPlugin
/*****************************************************************************/
{
private:


public:
  cPluginUSBRemote(void);
  virtual ~cPluginUSBRemote();
  virtual const char *Version(void) { return VERSION; }
  virtual const char *Description(void) { return tr(DESCRIPTION); }
  virtual const char *CommandLineHelp(void);
  virtual bool ProcessArgs(int argc, char *argv[]);
  virtual bool Start(void);
};




// ---------------------------------------------------------------------------
cPluginUSBRemote::cPluginUSBRemote(void)
// ---------------------------------------------------------------------------
{
}




// ---------------------------------------------------------------------------
cPluginUSBRemote::~cPluginUSBRemote()
// ---------------------------------------------------------------------------
{
}




// ---------------------------------------------------------------------------
const char *cPluginUSBRemote::CommandLineHelp(void)
// ---------------------------------------------------------------------------
{
    return NULL;
}




// ---------------------------------------------------------------------------
bool cPluginUSBRemote::ProcessArgs(int argc, char *argv[])
// ---------------------------------------------------------------------------
{
    return true;
}




// ---------------------------------------------------------------------------
bool cPluginUSBRemote::Start(void)
// ---------------------------------------------------------------------------
{
 new cRemoteUSB();
 return true;
}




/*****************************************************************************/