1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/libsi/util.h

163 lines
5.7 KiB
C
Raw Normal View History

2003-11-22 17:56:45 +01:00
/***************************************************************************
* 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. *
* *
2004-10-23 14:24:17 +02:00
* $Id: util.h 1.5 2004/10/23 14:22:40 kls Exp $
* *
2003-11-22 17:56:45 +01:00
***************************************************************************/
#ifndef LIBSI_UTIL_H
#define LIBSI_UTIL_H
#include <stdint.h>
#include <sys/types.h>
2003-11-22 17:56:45 +01:00
#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();
2003-11-22 17:56:45 +01:00
CharArray(const CharArray &source);
CharArray& operator=(const CharArray &source);
~CharArray();
2003-11-22 17:56:45 +01:00
//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;
2003-11-22 17:56:45 +01:00
//compares to another CharArray (data not necessarily null-terminated)
bool operator==(const CharArray &other) const;
2003-11-22 17:56:45 +01:00
//returns another CharArray with its offset incremented by offset
CharArray operator+(const unsigned int offset) const;
2003-11-22 17:56:45 +01:00
//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; }
u_int16_t TwoBytes(const unsigned int index) const { return data_->data ? data_->TwoBytes(off+index) : 0; }
u_int32_t FourBytes(const unsigned int index) const { return data_->data ? data_->FourBytes(off+index) : 0; }
bool isValid() const { return data_->valid; }
bool checkSize(unsigned int offset) { return (data_->valid && (data_->valid=(off+offset < data_->size))); }
2003-11-22 17:56:45 +01:00
void addOffset(unsigned int offset) { off+=offset; }
private:
class Data {
public:
Data();
virtual ~Data();
2003-11-22 17:56:45 +01:00
virtual void assign(const unsigned char*data, unsigned int size) = 0;
virtual void Delete() = 0;
u_int16_t TwoBytes(const unsigned int index) const
2003-11-22 17:56:45 +01:00
{ return (data[index] << 8) | data[index+1]; }
u_int32_t FourBytes(const unsigned int index) const
2003-11-22 17:56:45 +01:00
{ 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);
*/
2003-11-22 17:56:45 +01:00
const unsigned char*data;
unsigned int size;
2003-11-22 17:56:45 +01:00
// 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)
unsigned count_;
bool valid;
2003-11-22 17:56:45 +01:00
/*
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;
};
2003-11-22 17:56:45 +01:00
//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); }
2004-10-23 14:24:17 +02:00
}
2003-11-22 17:56:45 +01:00
//taken and adapted from libdtv, (c) Rolf Hakenes
class CRC32 {
public:
CRC32(const char *d, int len, u_int32_t CRCvalue=0xFFFFFFFF);
2003-11-22 17:56:45 +01:00
bool isValid() { return crc32(data, length, value) == 0; }
static bool isValid(const char *d, int len, u_int32_t CRCvalue=0xFFFFFFFF) { return crc32(d, len, CRCvalue) == 0; }
2003-11-22 17:56:45 +01:00
protected:
static u_int32_t crc_table[256];
static u_int32_t crc32 (const char *d, int len, u_int32_t CRCvalue);
2003-11-22 17:56:45 +01:00
const char *data;
int length;
u_int32_t value;
2003-11-22 17:56:45 +01:00
};
} //end of namespace
#endif