mirror of
https://github.com/VDR4Arch/vdr.git
synced 2023-10-10 13:36:52 +02:00
161 lines
5.5 KiB
C++
161 lines
5.5 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2003 by Marcel Wiesweg *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
|
|
#ifndef LIBSI_UTIL_H
|
|
#define LIBSI_UTIL_H
|
|
|
|
#include <stdint.h>
|
|
#include <pthread.h>
|
|
#include <time.h>
|
|
|
|
#define HILO(x) (x##_hi << 8 | x##_lo)
|
|
#define BCD_TIME_TO_SECONDS(x) ((3600 * ((10*((x##_h & 0xF0)>>4)) + (x##_h & 0xF))) + \
|
|
(60 * ((10*((x##_m & 0xF0)>>4)) + (x##_m & 0xF))) + \
|
|
((10*((x##_s & 0xF0)>>4)) + (x##_s & 0xF)))
|
|
|
|
namespace SI {
|
|
|
|
|
|
//Holds an array of unsigned char which is deleted
|
|
//when the last object pointing to it is deleted.
|
|
//Optimized for use in libsi.
|
|
class CharArray {
|
|
public:
|
|
CharArray();
|
|
|
|
CharArray(const CharArray &source);
|
|
CharArray& operator=(const CharArray &source);
|
|
~CharArray();
|
|
|
|
//can be called exactly once
|
|
void assign(const unsigned char*data, unsigned int size, bool doCopy=true);
|
|
//compares to a null-terminated string
|
|
bool operator==(const char *string) const;
|
|
//compares to another CharArray (data not necessarily null-terminated)
|
|
bool operator==(const CharArray &other) const;
|
|
|
|
//returns another CharArray with its offset incremented by offset
|
|
CharArray operator+(const unsigned int offset) const;
|
|
|
|
//access and convenience methods
|
|
const unsigned char* getData() const { return data_->data+off; }
|
|
const unsigned char* getData(int offset) const { return data_->data+offset+off; }
|
|
template <typename T> const T* getData() const { return (T*)(data_->data+off); }
|
|
template <typename T> const T* getData(int offset) const { return (T*)(data_->data+offset+off); }
|
|
//sets p to point to data+offset, increments offset
|
|
template <typename T> void setPointerAndOffset(const T* &p, unsigned int &offset) const { p=(T*)getData(offset); offset+=sizeof(T); }
|
|
unsigned char operator[](const unsigned int index) const { return data_->data ? data_->data[off+index] : 0; }
|
|
int getLength() const { return data_->size; }
|
|
unsigned short TwoBytes(const unsigned int index) const { return data_->data ? data_->TwoBytes(off+index) : 0; }
|
|
unsigned long FourBytes(const unsigned int index) const { return data_->data ? data_->FourBytes(off+index) : 0; }
|
|
|
|
void addOffset(unsigned int offset) { off+=offset; }
|
|
private:
|
|
class Data {
|
|
public:
|
|
Data();
|
|
virtual ~Data();
|
|
|
|
virtual void assign(const unsigned char*data, unsigned int size) = 0;
|
|
virtual void Delete() = 0;
|
|
|
|
unsigned short TwoBytes(const unsigned int index) const
|
|
{ return (data[index] << 8) | data[index+1]; }
|
|
unsigned long FourBytes(const unsigned int index) const
|
|
{ return (data[index] << 24) | (data[index+1] << 16) | (data[index+2] << 8) | data[index+3]; }
|
|
/*#ifdef CHARARRAY_THREADSAFE
|
|
void Lock();
|
|
void Unlock();
|
|
#else
|
|
void Lock() {}
|
|
void Unlock() {}
|
|
#endif
|
|
Data(const Data& d);
|
|
void assign(unsigned int size);
|
|
*/
|
|
|
|
const unsigned char*data;
|
|
unsigned int size;
|
|
|
|
unsigned count_;
|
|
// count_ is the number of CharArray objects that point at this
|
|
// count_ must be initialized to 1 by all constructors
|
|
// (it starts as 1 since it is pointed to by the CharArray object that created it)
|
|
|
|
/*
|
|
pthread_mutex_t mutex;
|
|
pid_t lockingPid;
|
|
pthread_t locked;
|
|
*/
|
|
};
|
|
class DataOwnData : public Data {
|
|
public:
|
|
DataOwnData() {}
|
|
virtual ~DataOwnData();
|
|
virtual void assign(const unsigned char*data, unsigned int size);
|
|
virtual void Delete();
|
|
};
|
|
class DataForeignData : public Data {
|
|
public:
|
|
DataForeignData() {}
|
|
virtual ~DataForeignData();
|
|
virtual void assign(const unsigned char*data, unsigned int size);
|
|
virtual void Delete();
|
|
};
|
|
Data* data_;
|
|
unsigned int off;
|
|
};
|
|
|
|
|
|
|
|
//abstract base class
|
|
class Parsable {
|
|
public:
|
|
void CheckParse();
|
|
protected:
|
|
Parsable();
|
|
virtual ~Parsable() {}
|
|
//actually parses given data.
|
|
virtual void Parse() = 0;
|
|
private:
|
|
bool parsed;
|
|
};
|
|
|
|
//taken and adapted from libdtv, (c) Rolf Hakenes and VDR, (c) Klaus Schmidinger
|
|
namespace DVBTime {
|
|
time_t getTime(unsigned char date_hi, unsigned char date_lo, unsigned char timehr, unsigned char timemi, unsigned char timese);
|
|
time_t getDuration(unsigned char timehr, unsigned char timemi, unsigned char timese);
|
|
inline unsigned char bcdToDec(unsigned char b) { return ((b >> 4) & 0x0F) * 10 + (b & 0x0F); }
|
|
};
|
|
|
|
//taken and adapted from libdtv, (c) Rolf Hakenes
|
|
class CRC32 {
|
|
public:
|
|
CRC32(const char *d, int len, unsigned long CRCvalue=0xFFFFFFFF);
|
|
bool isValid() { return crc32(data, length, value) == 0; }
|
|
static bool isValid(const char *d, int len, unsigned long CRCvalue=0xFFFFFFFF) { return crc32(d, len, CRCvalue) == 0; }
|
|
protected:
|
|
static unsigned long crc_table[256];
|
|
static unsigned long crc32 (const char *d, int len, unsigned long CRCvalue);
|
|
|
|
const char *data;
|
|
int length;
|
|
unsigned long value;
|
|
};
|
|
|
|
|
|
|
|
} //end of namespace
|
|
|
|
|
|
#endif
|
|
|