I tried so hard, and got so far

But in the end, it doesn't even matter

😭

Author: grishka

Diff for: Android.mk

@@ -11,9 +11,11 @@ LOCAL_C_INCLUDES := $(LOCAL_PATH)/../opus/include $(LOCAL_PATH)/../boringssl/inc
 
 ifeq ($(TARGET_ARCH_ABI),$(filter $(TARGET_ARCH_ABI),armeabi-v7a arm64-v8a))
 CC_NEON := cc.neon
+CPP_NEON := cpp.neon
 LOCAL_CFLAGS += -DWEBRTC_HAS_NEON
 else
 CC_NEON := cc
+CPP_NEON := cpp.neon
 endif
 
 LOCAL_CFLAGS += $(TGVOIP_ADDITIONAL_CFLAGS)
@@ -48,6 +50,10 @@ LOCAL_SRC_FILES := \
 ./video/VideoRenderer.cpp \
 ./video/VideoSource.cpp \
 ./video/ScreamCongestionController.cpp \
+./video/VideoPacketSender.cpp \
+./video/VideoFEC.cpp \
+./video/cm256/cm256.$(CPP_NEON) \
+./video/cm256/gf256.$(CPP_NEON) \
 ./os/android/VideoSourceAndroid.cpp \
 ./os/android/VideoRendererAndroid.cpp \
 ./client/android/tg_voip_jni.cpp
@@ -330,6 +336,9 @@ LOCAL_SRC_FILES += \
 ./webrtc_dsp/common_audio/signal_processing/downsample_fast_neon.c.neon \
 ./webrtc_dsp/common_audio/signal_processing/min_max_operations_neon.c.neon \
 ./webrtc_dsp/common_audio/signal_processing/cross_correlation_neon.c.neon
+
+LOCAL_CPPFLAGS += -DUSE_NEON
+
 endif
 
 ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
@@ -345,6 +354,9 @@ LOCAL_SRC_FILES += \
 ./webrtc_dsp/modules/audio_processing/utility/ooura_fft_sse2.cc \
 ./webrtc_dsp/common_audio/fir_filter_sse.cc \
 ./webrtc_dsp/common_audio/resampler/sinc_resampler_sse.cc
+
+LOCAL_CPPFLAGS += -DUSE_SSSE3
+
 endif
 
 include $(BUILD_STATIC_LIBRARY)

Diff for: BlockingQueue.h

@@ -59,7 +59,7 @@ class BlockingQueue{
 		return GetInternal();
 	}
 
-	unsigned int Size(){
+	size_t Size(){
 		return queue.size();
 	}
 

Diff for: Buffers.cpp

@@ -234,57 +234,3 @@ void BufferOutputStream::Rewind(size_t numBytes){
 		throw std::out_of_range("buffer underflow");
 	offset-=numBytes;
 }
-
-#pragma mark - BufferPool
-
-BufferPool::BufferPool(unsigned int size, unsigned int count){
-	assert(count<=64);
-	buffers[0]=(unsigned char*) malloc(size*count);
-	bufferCount=count;
-	unsigned int i;
-	for(i=1;i<count;i++){
-		buffers[i]=buffers[0]+i*size;
-	}
-	usedBuffers=0;
-	this->size=size;
-}
-
-BufferPool::~BufferPool(){
-	free(buffers[0]);
-}
-
-unsigned char* BufferPool::Get(){
-	MutexGuard m(mutex);
-	int i;
-	for(i=0;i<bufferCount;i++){
-		if(!((usedBuffers >> i) & 1)){
-			usedBuffers|=(1LL << i);
-			return buffers[i];
-		}
-	}
-	return NULL;
-}
-
-void BufferPool::Reuse(unsigned char* buffer){
-	MutexGuard m(mutex);
-	int i;
-	for(i=0;i<bufferCount;i++){
-		if(buffers[i]==buffer){
-			usedBuffers&= ~(1LL << i);
-			return;
-		}
-	}
-	LOGE("pointer passed isn't a valid buffer from this pool");
-	abort();
-}
-
-size_t BufferPool::GetSingleBufferSize(){
-	return size;
-}
-
-size_t BufferPool::GetBufferCount(){
-	return (size_t) bufferCount;
-}
-
-#pragma mark - Buffer
-

Diff for: Buffers.h

@@ -15,6 +15,7 @@
 #include <stdexcept>
 #include <array>
 #include <limits>
+#include <bitset>
 #include <stddef.h>
 #include "threading.h"
 #include "utils.h"
@@ -88,37 +89,24 @@ namespace tgvoip{
 		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)
+			if(capacity>0){
 				data=(unsigned char *) malloc(capacity);
-			else
+				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){
@@ -131,17 +119,29 @@ namespace tgvoip{
 			length=0;
 		}
 		~Buffer(){
-			if(data)
-				free(data);
+			if(data){
+				if(freeFn)
+					freeFn(data);
+				else
+					free(data);
+			}
 			data=NULL;
+			length=0;
 		};
 		Buffer& operator=(Buffer&& other){
 			if(this!=&other){
-				if(data)
-					free(data);
+				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;
 		}
@@ -174,23 +174,47 @@ namespace tgvoip{
 			memcpy(data+dstOffset, ptr, count);
 		}
 		void Resize(size_t newSize){
-			data=(unsigned char *) realloc(data, 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;
+			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{
@@ -199,26 +223,26 @@ namespace tgvoip{
 			std::fill(data.begin(), data.end(), (T)0);
 		}
 
-		AVG_T Average(){
+		AVG_T Average() const {
 			AVG_T avg=(AVG_T)0;
-			for(T& i:data){
+			for(T i:data){
 				avg+=i;
 			}
 			return avg/(AVG_T)size;
 		}
 
-		AVG_T Average(size_t firstN){
+		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(){
+		AVG_T NonZeroAverage() const {
 			AVG_T avg=(AVG_T)0;
 			int nonZeroCount=0;
-			for(T& i:data){
+			for(T i:data){
 				if(i!=0){
 					nonZeroCount++;
 					avg+=i;
@@ -234,18 +258,18 @@ namespace tgvoip{
 			offset=(offset+1)%size;
 		}
 
-		T Min(){
+		T Min() const {
 			T min=std::numeric_limits<T>::max();
-			for(T& i:data){
+			for(T i:data){
 				if(i<min)
 					min=i;
 			}
 			return min;
 		}
 
-		T Max(){
+		T Max() const {
 			T max=std::numeric_limits<T>::min();
-			for(T& i:data){
+			for(T i:data){
 				if(i>max)
 					max=i;
 			}
@@ -257,6 +281,15 @@ namespace tgvoip{
 			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
@@ -266,13 +299,59 @@ namespace tgvoip{
 			return data[_i];
 		}
 
-		size_t Size(){
+		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