myvtm/Other/unix/libvideoframework/video_common/video_encoded_image.cpp

#include "video_encoded_image.h"
#include "precompile.h"

extern "C" {

	RTPFragmentationHeader *rtp_fragmentation_header_new() {

		RTPFragmentationHeader *obj = (RTPFragmentationHeader *)malloc(sizeof(RTPFragmentationHeader));
		memset(obj, 0, sizeof(RTPFragmentationHeader));
		return obj;
	}

	void rtp_fragmentation_header_destroy(RTPFragmentationHeader *obj) {
		if (obj != NULL) {

			free(obj);
		}
	}

	void rtp_fragmentation_header_init(RTPFragmentationHeader *obj) {

		memset(obj, 0, sizeof(RTPFragmentationHeader));
	}

	void rtp_fragmentation_header_release(RTPFragmentationHeader *obj) {
		if (obj != NULL) {
			if (obj->fragmentationOffset != NULL) {
				free(obj->fragmentationOffset);
				obj->fragmentationOffset = NULL;
			}
			if (obj->fragmentationLength != NULL) {
				free(obj->fragmentationLength);
				obj->fragmentationLength = NULL;
			}
		}
	}


	void rtp_fragmentation_header_copy_from(RTPFragmentationHeader *obj, const RTPFragmentationHeader *src) {
		if (obj == src) {
			return;
		}

		if (src->fragmentationVectorSize != obj->fragmentationVectorSize) {
			// new size of vectors

			// delete old
			rtp_fragmentation_header_release(obj);

			if (src->fragmentationVectorSize > 0) {
				// allocate new
				if (src->fragmentationOffset) {
					obj->fragmentationOffset = (size_t *)malloc(sizeof(size_t) * src->fragmentationVectorSize);
				}
				if (src->fragmentationLength) {
					obj->fragmentationLength = (size_t *)malloc(sizeof(size_t) * src->fragmentationVectorSize);
				}
			}
			// set new size
			obj->fragmentationVectorSize = src->fragmentationVectorSize;
		}

		if (src->fragmentationVectorSize > 0) {
			// copy values
			if (src->fragmentationOffset) {
				memcpy(obj->fragmentationOffset, src->fragmentationOffset,
					src->fragmentationVectorSize * sizeof(size_t));
			}
			if (src->fragmentationLength) {
				memcpy(obj->fragmentationLength, src->fragmentationLength,
					src->fragmentationVectorSize * sizeof(size_t));
			}
		}
	}

	void rtp_fragmentation_header_allocation(RTPFragmentationHeader *obj, size_t size) {
		const uint16_t size16 = (uint16_t)(size);

		{
			// offset
			obj->fragmentationOffset = (size_t *)malloc(sizeof(size_t) * size16);
			memset(obj->fragmentationOffset, 0,
				sizeof(size_t) * (size16));
		}
		// length
		{
			obj->fragmentationLength = (size_t *)malloc(sizeof(size_t) * size16);
			memset(obj->fragmentationLength, 0,
				sizeof(size_t) * (size16));
		}

		obj->fragmentationVectorSize = size16;
	}


	void rtp_fragmentation_header_resize(RTPFragmentationHeader *obj, size_t size) {
		const uint16_t size16 = (uint16_t)(size);
		if (obj->fragmentationVectorSize < size16) {
			uint16_t oldVectorSize = obj->fragmentationVectorSize;
			{
				// offset
				size_t* oldOffsets = obj->fragmentationOffset;
				obj->fragmentationOffset = (size_t *)malloc(sizeof(size_t) * size16);
				memset(obj->fragmentationOffset + oldVectorSize, 0,
					sizeof(size_t) * (size16 - oldVectorSize));
				// copy old values
				if (oldVectorSize > 0) {
					memcpy(obj->fragmentationOffset, oldOffsets, sizeof(size_t) * oldVectorSize);
					free(oldOffsets);
				}
			}
			// length
			{
				size_t* oldLengths = obj->fragmentationLength;
				obj->fragmentationLength = (size_t *)malloc(sizeof(size_t) * size16);
				memset(obj->fragmentationLength + oldVectorSize, 0,
					sizeof(size_t) * (size16 - oldVectorSize));
				if (oldVectorSize > 0) {
					memcpy(obj->fragmentationLength, oldLengths, sizeof(size_t) * oldVectorSize);
					free(oldLengths);
				}
			}

			obj->fragmentationVectorSize = size16;
		}
	}

	size_t rtp_fragmentation_header_size(RTPFragmentationHeader *obj) {
		return obj->fragmentationVectorSize;
	}

	size_t rtp_fragmentation_header_offset(RTPFragmentationHeader *obj, size_t index) {
		return obj->fragmentationOffset[index];
	}

	size_t rtp_fragmentation_header_length(RTPFragmentationHeader *obj, size_t index) {
		return obj->fragmentationLength[index];
	}

	EncodedImage *encoded_image_new() {

		EncodedImage *obj = (EncodedImage *)malloc(sizeof(EncodedImage));
		memset(obj, 0, sizeof(EncodedImage));

		obj->_encodedWidth = 0;
		obj->_encodedHeight = 0;

		obj->capture_time_ms_ = 0;
		obj->key_frame = 0;

		obj->_completeFrame = false;
		obj->qp_ = -1;

		obj->size_ = 0;

		obj->encode_start_ms = 0;
		obj->encode_finish_ms = 0;
		rtp_fragmentation_header_init(&obj->fragmentation_header_);

		return obj;
	}


	void encoded_image_destroy(EncodedImage *obj) {
		if (obj != NULL) {

			free(obj);
		}
	}


	void encoded_image_init(EncodedImage *obj) {
		memset(obj, 0, sizeof(EncodedImage));

		obj->_encodedWidth = 0;
		obj->_encodedHeight = 0;

		obj->capture_time_ms_ = 0;
		obj->key_frame = 0;

		obj->_completeFrame = false;
		obj->qp_ = -1;

		obj->size_ = 0;

		obj->encode_start_ms = 0;
		obj->encode_finish_ms = 0;
		rtp_fragmentation_header_init(&obj->fragmentation_header_);
	}

	void encoded_image_release(EncodedImage *obj) {
		if (obj != NULL) {
			if (obj->encoded_data_ != NULL) {
				free(obj->encoded_data_);
				obj->encoded_data_ = NULL;
			}
			rtp_fragmentation_header_release(&obj->fragmentation_header_);
		}
	}

	void encoded_image_set_encode_time(EncodedImage *obj, int64_t encode_start_ms, int64_t encode_finish_ms) {
		obj->encode_start_ms = encode_start_ms;
		obj->encode_finish_ms = encode_finish_ms;
	}

	size_t encoded_image_size(EncodedImage *obj) { return obj->size_; }
	uint8_t* encoded_image_data(EncodedImage *obj) { return obj->encoded_data_; }

	void encoded_image_set_buffer(EncodedImage *obj, uint8_t* buffer, size_t length) {
		obj->encoded_data_ = buffer;
		obj->size_ = length;
	}

}