Repo created
This commit is contained in:
parent
81b91f4139
commit
f8c34fa5ee
22732 changed files with 4815320 additions and 2 deletions
278
TMessagesProj/jni/voip/libtgvoip/Buffers.h
Normal file
278
TMessagesProj/jni/voip/libtgvoip/Buffers.h
Normal file
|
|
@ -0,0 +1,278 @@
|
|||
//
|
||||
// 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 <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 BufferPool{
|
||||
public:
|
||||
TGVOIP_DISALLOW_COPY_AND_ASSIGN(BufferPool);
|
||||
BufferPool(unsigned int size, unsigned int count);
|
||||
~BufferPool();
|
||||
unsigned char* Get();
|
||||
void Reuse(unsigned char* buffer);
|
||||
size_t GetSingleBufferSize();
|
||||
size_t GetBufferCount();
|
||||
|
||||
private:
|
||||
uint64_t usedBuffers;
|
||||
int bufferCount;
|
||||
size_t size;
|
||||
unsigned char* buffers[64];
|
||||
Mutex mutex;
|
||||
};
|
||||
|
||||
class Buffer{
|
||||
public:
|
||||
Buffer(size_t capacity){
|
||||
if(capacity>0)
|
||||
data=(unsigned char *) malloc(capacity);
|
||||
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;
|
||||
other.data=NULL;
|
||||
};
|
||||
Buffer(BufferOutputStream&& stream){
|
||||
data=stream.buffer;
|
||||
length=stream.offset;
|
||||
stream.buffer=NULL;
|
||||
}
|
||||
Buffer(){
|
||||
data=NULL;
|
||||
length=0;
|
||||
}
|
||||
~Buffer(){
|
||||
if(data)
|
||||
free(data);
|
||||
data=NULL;
|
||||
};
|
||||
Buffer& operator=(Buffer&& other){
|
||||
if(this!=&other){
|
||||
if(data)
|
||||
free(data);
|
||||
data=other.data;
|
||||
length=other.length;
|
||||
other.data=NULL;
|
||||
}
|
||||
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){
|
||||
data=(unsigned char *) realloc(data, newSize);
|
||||
length=newSize;
|
||||
}
|
||||
size_t Length() const{
|
||||
return length;
|
||||
}
|
||||
bool IsEmpty() const{
|
||||
return length==0;
|
||||
}
|
||||
static Buffer CopyOf(const Buffer& other){
|
||||
Buffer buf(other.length);
|
||||
buf.CopyFrom(other, other.length);
|
||||
return buf;
|
||||
}
|
||||
private:
|
||||
unsigned char* data;
|
||||
size_t length;
|
||||
};
|
||||
|
||||
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(){
|
||||
AVG_T avg=(AVG_T)0;
|
||||
for(T& i:data){
|
||||
avg+=i;
|
||||
}
|
||||
return avg/(AVG_T)size;
|
||||
}
|
||||
|
||||
AVG_T Average(size_t firstN){
|
||||
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(){
|
||||
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(){
|
||||
T min=std::numeric_limits<T>::max();
|
||||
for(T& i:data){
|
||||
if(i<min)
|
||||
min=i;
|
||||
}
|
||||
return min;
|
||||
}
|
||||
|
||||
T Max(){
|
||||
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){
|
||||
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(){
|
||||
return size;
|
||||
}
|
||||
private:
|
||||
std::array<T, size> data;
|
||||
ptrdiff_t offset=0;
|
||||
};
|
||||
}
|
||||
|
||||
#endif //LIBTGVOIP_BUFFERINPUTSTREAM_H
|
||||
Loading…
Add table
Add a link
Reference in a new issue