mirror of
https://github.com/danog/libtgvoip.git
synced 2024-11-27 04:34:42 +01:00
358 lines
8.0 KiB
C++
358 lines
8.0 KiB
C++
//
|
|
// libtgvoip is free and unencumbered public domain software.
|
|
// For more information, see http://unlicense.org or the UNLICENSE file
|
|
// you should have received with this source code distribution.
|
|
//
|
|
|
|
#ifndef LIBTGVOIP_BUFFERINPUTSTREAM_H
|
|
#define LIBTGVOIP_BUFFERINPUTSTREAM_H
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <stdexcept>
|
|
#include <array>
|
|
#include <limits>
|
|
#include <bitset>
|
|
#include <stddef.h>
|
|
#include "threading.h"
|
|
#include "utils.h"
|
|
|
|
namespace tgvoip{
|
|
class Buffer;
|
|
|
|
class BufferInputStream{
|
|
|
|
public:
|
|
BufferInputStream(const unsigned char* data, size_t length);
|
|
BufferInputStream(const Buffer& buffer);
|
|
~BufferInputStream();
|
|
void Seek(size_t offset);
|
|
size_t GetLength();
|
|
size_t GetOffset();
|
|
size_t Remaining();
|
|
unsigned char ReadByte();
|
|
int64_t ReadInt64();
|
|
int32_t ReadInt32();
|
|
int16_t ReadInt16();
|
|
int32_t ReadTlLength();
|
|
void ReadBytes(unsigned char* to, size_t count);
|
|
void ReadBytes(Buffer& to);
|
|
BufferInputStream GetPartBuffer(size_t length, bool advance);
|
|
|
|
private:
|
|
void EnsureEnoughRemaining(size_t need);
|
|
const unsigned char* buffer;
|
|
size_t length;
|
|
size_t offset;
|
|
};
|
|
|
|
class BufferOutputStream{
|
|
friend class Buffer;
|
|
public:
|
|
TGVOIP_DISALLOW_COPY_AND_ASSIGN(BufferOutputStream);
|
|
BufferOutputStream(size_t size);
|
|
BufferOutputStream(unsigned char* buffer, size_t size);
|
|
~BufferOutputStream();
|
|
void WriteByte(unsigned char byte);
|
|
void WriteInt64(int64_t i);
|
|
void WriteInt32(int32_t i);
|
|
void WriteInt16(int16_t i);
|
|
void WriteBytes(const unsigned char* bytes, size_t count);
|
|
void WriteBytes(const Buffer& buffer);
|
|
void WriteBytes(const Buffer& buffer, size_t offset, size_t count);
|
|
unsigned char* GetBuffer();
|
|
size_t GetLength();
|
|
void Reset();
|
|
void Rewind(size_t numBytes);
|
|
|
|
BufferOutputStream& operator=(BufferOutputStream&& other){
|
|
if(this!=&other){
|
|
if(!bufferProvided && buffer)
|
|
free(buffer);
|
|
buffer=other.buffer;
|
|
offset=other.offset;
|
|
size=other.size;
|
|
bufferProvided=other.bufferProvided;
|
|
other.buffer=NULL;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void ExpandBufferIfNeeded(size_t need);
|
|
unsigned char* buffer=NULL;
|
|
size_t size;
|
|
size_t offset;
|
|
bool bufferProvided;
|
|
};
|
|
|
|
class Buffer{
|
|
public:
|
|
Buffer(size_t capacity){
|
|
if(capacity>0){
|
|
data=(unsigned char *) malloc(capacity);
|
|
if(!data)
|
|
throw std::bad_alloc();
|
|
}else{
|
|
data=NULL;
|
|
}
|
|
length=capacity;
|
|
};
|
|
TGVOIP_DISALLOW_COPY_AND_ASSIGN(Buffer); // use Buffer::CopyOf to copy contents explicitly
|
|
Buffer(Buffer&& other) noexcept {
|
|
data=other.data;
|
|
length=other.length;
|
|
freeFn=other.freeFn;
|
|
reallocFn=other.reallocFn;
|
|
other.data=NULL;
|
|
};
|
|
Buffer(BufferOutputStream&& stream){
|
|
data=stream.buffer;
|
|
length=stream.offset;
|
|
stream.buffer=NULL;
|
|
}
|
|
Buffer(){
|
|
data=NULL;
|
|
length=0;
|
|
}
|
|
~Buffer(){
|
|
if(data){
|
|
if(freeFn)
|
|
freeFn(data);
|
|
else
|
|
free(data);
|
|
}
|
|
data=NULL;
|
|
length=0;
|
|
};
|
|
Buffer& operator=(Buffer&& other){
|
|
if(this!=&other){
|
|
if(data){
|
|
if(freeFn)
|
|
freeFn(data);
|
|
else
|
|
free(data);
|
|
}
|
|
data=other.data;
|
|
length=other.length;
|
|
freeFn=other.freeFn;
|
|
reallocFn=other.reallocFn;
|
|
other.data=NULL;
|
|
other.length=0;
|
|
}
|
|
return *this;
|
|
}
|
|
unsigned char& operator[](size_t i){
|
|
if(i>=length)
|
|
throw std::out_of_range("");
|
|
return data[i];
|
|
}
|
|
const unsigned char& operator[](size_t i) const{
|
|
if(i>=length)
|
|
throw std::out_of_range("");
|
|
return data[i];
|
|
}
|
|
unsigned char* operator*(){
|
|
return data;
|
|
}
|
|
const unsigned char* operator*() const{
|
|
return data;
|
|
}
|
|
void CopyFrom(const Buffer& other, size_t count, size_t srcOffset=0, size_t dstOffset=0){
|
|
if(!other.data)
|
|
throw std::invalid_argument("CopyFrom can't copy from NULL");
|
|
if(other.length<srcOffset+count || length<dstOffset+count)
|
|
throw std::out_of_range("Out of offset+count bounds of either buffer");
|
|
memcpy(data+dstOffset, other.data+srcOffset, count);
|
|
}
|
|
void CopyFrom(const void* ptr, size_t dstOffset, size_t count){
|
|
if(length<dstOffset+count)
|
|
throw std::out_of_range("Offset+count is out of bounds");
|
|
memcpy(data+dstOffset, ptr, count);
|
|
}
|
|
void Resize(size_t newSize){
|
|
if(reallocFn)
|
|
data=(unsigned char *) reallocFn(data, newSize);
|
|
else
|
|
data=(unsigned char *) realloc(data, newSize);
|
|
if(!data)
|
|
throw std::bad_alloc();
|
|
length=newSize;
|
|
}
|
|
size_t Length() const{
|
|
return length;
|
|
}
|
|
bool IsEmpty() const{
|
|
return length==0 || !data;
|
|
}
|
|
static Buffer CopyOf(const Buffer& other){
|
|
if(other.IsEmpty())
|
|
return Buffer();
|
|
Buffer buf(other.length);
|
|
buf.CopyFrom(other, other.length);
|
|
return buf;
|
|
}
|
|
static Buffer CopyOf(const Buffer& other, size_t offset, size_t length){
|
|
if(offset+length>other.Length())
|
|
throw std::out_of_range("offset+length out of bounds");
|
|
Buffer buf(length);
|
|
buf.CopyFrom(other, length, offset);
|
|
return buf;
|
|
}
|
|
static Buffer Wrap(unsigned char* data, size_t size, std::function<void(void*)> freeFn, std::function<void*(void*, size_t)> reallocFn){
|
|
Buffer b=Buffer();
|
|
b.data=data;
|
|
b.length=size;
|
|
b.freeFn=freeFn;
|
|
b.reallocFn=reallocFn;
|
|
return b;
|
|
}
|
|
private:
|
|
unsigned char* data;
|
|
size_t length;
|
|
std::function<void(void*)> freeFn;
|
|
std::function<void*(void*, size_t)> reallocFn;
|
|
};
|
|
|
|
template <typename T, size_t size, typename AVG_T=T> class HistoricBuffer{
|
|
public:
|
|
HistoricBuffer(){
|
|
std::fill(data.begin(), data.end(), (T)0);
|
|
}
|
|
|
|
AVG_T Average() const {
|
|
AVG_T avg=(AVG_T)0;
|
|
for(T i:data){
|
|
avg+=i;
|
|
}
|
|
return avg/(AVG_T)size;
|
|
}
|
|
|
|
AVG_T Average(size_t firstN) const {
|
|
AVG_T avg=(AVG_T)0;
|
|
for(size_t i=0;i<firstN;i++){
|
|
avg+=(*this)[i];
|
|
}
|
|
return avg/(AVG_T)firstN;
|
|
}
|
|
|
|
AVG_T NonZeroAverage() const {
|
|
AVG_T avg=(AVG_T)0;
|
|
int nonZeroCount=0;
|
|
for(T i:data){
|
|
if(i!=0){
|
|
nonZeroCount++;
|
|
avg+=i;
|
|
}
|
|
}
|
|
if(nonZeroCount==0)
|
|
return (AVG_T)0;
|
|
return avg/(AVG_T)nonZeroCount;
|
|
}
|
|
|
|
void Add(T el){
|
|
data[offset]=el;
|
|
offset=(offset+1)%size;
|
|
}
|
|
|
|
T Min() const {
|
|
T min=std::numeric_limits<T>::max();
|
|
for(T i:data){
|
|
if(i<min)
|
|
min=i;
|
|
}
|
|
return min;
|
|
}
|
|
|
|
T Max() const {
|
|
T max=std::numeric_limits<T>::min();
|
|
for(T i:data){
|
|
if(i>max)
|
|
max=i;
|
|
}
|
|
return max;
|
|
}
|
|
|
|
void Reset(){
|
|
std::fill(data.begin(), data.end(), (T)0);
|
|
offset=0;
|
|
}
|
|
|
|
T operator[](size_t i) const {
|
|
assert(i<size);
|
|
// [0] should return the most recent entry, [1] the one before it, and so on
|
|
ptrdiff_t _i=offset-i-1;
|
|
if(_i<0)
|
|
_i=size+_i;
|
|
return data[_i];
|
|
}
|
|
|
|
T& operator[](size_t i){
|
|
assert(i<size);
|
|
// [0] should return the most recent entry, [1] the one before it, and so on
|
|
ptrdiff_t _i=offset-i-1;
|
|
if(_i<0)
|
|
_i=size+_i;
|
|
return data[_i];
|
|
}
|
|
|
|
size_t Size() const {
|
|
return size;
|
|
}
|
|
private:
|
|
std::array<T, size> data;
|
|
ptrdiff_t offset=0;
|
|
};
|
|
|
|
template <size_t bufSize, size_t bufCount> class BufferPool{
|
|
public:
|
|
TGVOIP_DISALLOW_COPY_AND_ASSIGN(BufferPool);
|
|
BufferPool(){
|
|
bufferStart=(unsigned char*)malloc(bufSize*bufCount);
|
|
if(!bufferStart)
|
|
throw std::bad_alloc();
|
|
};
|
|
~BufferPool(){
|
|
assert(usedBuffers.none());
|
|
free(bufferStart);
|
|
};
|
|
Buffer Get(){
|
|
auto freeFn=[this](void* _buf){
|
|
assert(_buf!=NULL);
|
|
unsigned char* buf=(unsigned char*)_buf;
|
|
size_t offset=buf-bufferStart;
|
|
assert(offset%bufSize==0);
|
|
size_t index=offset/bufSize;
|
|
assert(index<bufCount);
|
|
|
|
MutexGuard m(mutex);
|
|
assert(usedBuffers.test(index));
|
|
usedBuffers[index]=0;
|
|
};
|
|
auto resizeFn=[](void* buf, size_t newSize)->void*{
|
|
if(newSize>bufSize)
|
|
throw std::invalid_argument("newSize>bufferSize");
|
|
return buf;
|
|
};
|
|
MutexGuard m(mutex);
|
|
for(size_t i=0;i<bufCount;i++){
|
|
if(!usedBuffers[i]){
|
|
usedBuffers[i]=1;
|
|
return Buffer::Wrap(bufferStart+(bufSize*i), bufSize, freeFn, resizeFn);
|
|
}
|
|
}
|
|
throw std::bad_alloc();
|
|
}
|
|
|
|
private:
|
|
std::bitset<bufCount> usedBuffers;
|
|
unsigned char* bufferStart;
|
|
Mutex mutex;
|
|
};
|
|
}
|
|
|
|
#endif //LIBTGVOIP_BUFFERINPUTSTREAM_H
|