myvtm/Other/libvideoframework/adaptive_jitter_buffer/video_jbuff_api.cpp

#include "../adaptive_jitter_buffer/video_jbuff_api.h"
#include "../adaptive_jitter_buffer/video_jbuff_jitterbuffer.h"
#include "../adaptive_jitter_buffer/video_jbuff_log.h"

#include "../congestion_control/common/cf_platform.h"

#ifdef __cplusplus
extern "C" {
#endif

const int TIME_INTERVAL = 10; // 10 ms
const int GET_MISSING_TIME_INTERVAL = 200; // 200 ms


struct _VideoJBufferApi {
	volatile int	run_;				/*run线程标示 */
	su_mutex		mutex_;				/*用于上层多线程操作的保护锁*/
	su_thread		thr_;				/*线程ID*/

	AJB::JitterBuffer *jitterBuffer_;
	VideoJBufferObserver observer_;

	int scheduleKeyRequest_;
};

static void* jitter_buffer_loop_event(void* arg);

VideoJBufferApi *video_jbuffer_api_new(VideoJBufferObserver *observer, VideoJBufferLogCallBack *log_func){
	VideoJBufferApi *obj = (VideoJBufferApi *)malloc(sizeof(VideoJBufferApi));
	memset(obj, 0, sizeof(VideoJBufferApi));
	video_jitterbuffer_setup_log(log_func);

	obj->jitterBuffer_ = new AJB::JitterBuffer(observer);
	if (observer != NULL) {
		obj->observer_.OnReceiveEncodedImage = observer->OnReceiveEncodedImage;
		obj->observer_.RequestKeyFrame = observer->RequestKeyFrame;
		obj->observer_.userdata = observer->userdata;
	}
	obj->mutex_ = su_create_mutex();

	return obj;
}


void video_jbuffer_api_destroy(VideoJBufferApi *obj){
	if (obj != NULL) {
		if (obj->jitterBuffer_) {
			delete obj->jitterBuffer_;
			obj->jitterBuffer_ = NULL;
		}
		
		if (obj->mutex_) {
		su_destroy_mutex(obj->mutex_);
		}
		free(obj);
	}
	video_jitterbuffer_unsetup_log();
}

void video_jbuffer_api_start(VideoJBufferApi *obj){
	if (obj->jitterBuffer_) {
		obj->run_ = 1;
		obj->thr_ = su_create_thread(NULL, jitter_buffer_loop_event, obj);

	}
}

void video_jbuffer_api_stop(VideoJBufferApi *obj){
	obj->run_ = 0;
	while (obj->run_ == 0){
		su_sleep(0, 10000);
	}
}

void video_jbuffer_api_receive_packet(VideoJBufferApi *obj, const char* buffer, VideoJBufferPacketInfo *packet_info){

	if (obj->jitterBuffer_) {
		su_mutex_lock(obj->mutex_);
		FrameBufferEnum result = obj->jitterBuffer_->ReceivePacket(buffer, packet_info);
		if (result == kFlushIndicator) {
			obj->scheduleKeyRequest_ = true;
		}
		su_mutex_unlock(obj->mutex_);
	}
}


static void* jitter_buffer_loop_event(void* arg)
{
	VideoJBufferApi* obj = (VideoJBufferApi*)arg;
	int64_t now_ts = 0, prev_ts = 0;
	int64_t prev_getmissing_ts = 0;

	prev_ts = now_ts = GET_SYS_MS();

	while (obj->run_ == 1){

		now_ts = GET_SYS_MS();

		if (now_ts >= prev_ts + TIME_INTERVAL){
			int request_key_frame = false;
			
			su_mutex_lock(obj->mutex_);
			if (now_ts >= prev_getmissing_ts + GET_MISSING_TIME_INTERVAL){
				obj->jitterBuffer_->GetMissingList(&request_key_frame);
				prev_getmissing_ts = now_ts;
			}
			
			if ((obj->scheduleKeyRequest_ || request_key_frame) && obj->observer_.RequestKeyFrame) {
				int result = obj->observer_.RequestKeyFrame(obj->observer_.userdata);
				obj->scheduleKeyRequest_ = false;
			}
			
			obj->jitterBuffer_->GetFrame();
			su_mutex_unlock(obj->mutex_);

			prev_ts = now_ts;
		}

		//video_jitterbuffer_debug("jitter_buffer_loop_event prev_ts: %I64d now_ts: %I64d.", prev_ts, now_ts);
		Sleep(3);
		//video_jitterbuffer_debug("jitter_buffer_loop_event after currentTime: %I64d.", now_ts);
	}

	obj->run_ = -1;

	return NULL;
}



	
#ifdef __cplusplus
	  }
#endif /* end of __cplusplus */