valib/goffmpeg.git

			@@ -39,6 +39,8 @@
			,gb_(0)
			,cpu_(0)
			,use_decoder_(false)
			,minduration(250)
			,maxduration(750)
			{
			makeTheWorld();
			}
			@@ -46,14 +48,29 @@

			Wrapper::~Wrapper()
			{
			if(thread_){
			stop_stream_.store(true);
			thread_->join();
			try
			{
			if(thread_){
			stop_stream_.store(true);
			thread_->join();
			}
			if(bridge_){
			delete bridge_; bridge_ = NULL;
			}

			map_rec_.clear();
			list_rec_pkt_.clear();

			for(auto &i : list_pic_){
			free(i.data);
			}
			}
			if(bridge_){
			delete bridge_; bridge_ = NULL;
			catch(const std::exception& e)
			{
			logIt("WRAPPER EXCEPTION: ", e.what());
			}



			}

			void Wrapper::ScalePicture(const int w, const int h, const int flags){
			@@ -100,6 +117,20 @@
			return nullptr;
			}

			int Wrapper::RunStream(const char* input){
			if(thread_){
			logIt("wrapper run stream already run");
			return 0;
			}

			input_url_ = input;

			thread_.reset(new std::thread([&]{
			run_stream_thread();
			}));

			return 0;
			}

			void Wrapper::run_stream_thread(){

			@@ -129,73 +160,16 @@

			run_worker(in.get(), pkt);
			if(!data){
			map_rec_.clear();
			std::lock_guard<std::mutex> locker(mtx_rec_pkt_);
			list_rec_pkt_.clear();

			break;
			}
			//test
			// if(recorder_)
			// if(id % 250 == 0)
			// recorder_->FireRecorder(id);
			}
			}
			}

			int Wrapper::RunStream(const char* input){
			if(thread_){
			logIt("wrapper run stream already run");
			return 0;
			}

			input_url_ = input;

			thread_.reset(new std::thread([&]{
			run_stream_thread();
			}));

			return 0;
			}

			//////////////recorder
			std::shared_ptr<Recorder> Wrapper::init_recorder(FormatIn *in, std::string id,std::string dir, const int mind, const int maxd){
			if(!in){
			logIt("Init wrapper first");
			return nullptr;
			}

			auto rec = std::make_shared<Recorder>(in, id);

			rec->SetCallback([&](std::string &id, int &index, std::string &path){
			cache_rec_info(id, index, path);
			});

			int trycnt = 0;
			while(trycnt < 100){
			const int ret = rec->Run(dir.c_str(), mind, maxd);
			if(ret == 0) break;
			usleep(200000);
			}
			if (trycnt < 100){
			return rec;
			}
			return nullptr;
			}

			void Wrapper::BuildRecorder(const char* id, const char *output, const int mindur, const int maxdur){
			std::string rid(id);
			std::string dir(output);
			auto fn = [=](FormatIn *in){
			return init_recorder(in, rid, dir, mindur, maxdur);
			};
			std::shared_ptr<Recorder> rec(nullptr);

			FnRec r = FnRec{fn, rec};
			map_rec_[rid] = r;
			}

			int Wrapper::FireRecorder(const char* sid,const int64_t &id){
			auto iter = map_rec_.find(sid);
			if (iter != map_rec_.end()){
			if(iter->second.rec){
			iter->second.rec->FireRecorder(id);
			}
			}
			}
			@@ -227,38 +201,125 @@
			auto ret = in->decode(frame, pkt.data);
			if(ret == 1){
			//吐出数据
			cache_pic(frame);
			cache_pic(frame, pkt.id);
			}
			}

			cache_rec_pkt(pkt);
			for(auto &i : map_rec_){
			if (!i.second.rec){
			i.second.rec = i.second.fn_init(in);
			}
			if (i.second.rec){
			if (i.second.rec){
			std::lock_guard<std::mutex> locker(mtx_rec_pkt_);
			for(auto &k : list_rec_pkt_){
			avpacket p = {k.data, k.id};
			i.second.rec->CachePacket(p);
			}
			logIt("START REC %d FRAMES", list_rec_pkt_.size());
			}
			}else if (i.second.rec){
			i.second.rec->CachePacket(pkt);
			}
			}
			}

			void Wrapper::cache_rec_info(std::string &id, int &index, std::string &path){
			if(func_rec_){ //active api
			func_rec_(path, index);
			}else{ // passive api
			std::lock_guard<std::mutex> l(mutex_rec_);
			while(list_rec_.size() > 100){
			for(int i = 0; i < 25; i++){
			list_rec_.pop_front();
			int Wrapper::cache_rec_pkt(const avpacket &pkt){

			std::lock_guard<std::mutex> locker(mtx_rec_pkt_);
			//wait I
			if (list_rec_pkt_.empty()) {
			AVPacket &avpkt = pkt.data->getAVPacket();
			if (!(avpkt.flags & AV_PKT_FLAG_KEY)){
			return -1;
			}
			}
			maybe_dump_rec_pkt();
			recpkt k = {pkt.data, pkt.id};
			list_rec_pkt_.push_back(k);

			return 0;
			}
			void Wrapper::maybe_dump_rec_pkt(){
			//超过min/2,丢弃gop
			while (list_rec_pkt_.size() > minduration) {
			list_rec_pkt_.pop_front();
			while(!list_rec_pkt_.empty()){
			auto &cache = list_rec_pkt_.front();
			AVPacket &avpkt = cache.data->getAVPacket();
			if (!(avpkt.flags & AV_PKT_FLAG_KEY)){
			list_rec_pkt_.pop_front();
			}else{
			break;
			}
			}
			struct record_file_info info;
			info.file_frame_index = index;
			info.file_path = path;
			list_rec_.emplace_back(info);
			list_rec_map_[path] = id;
			logIt("list rec files count : %d", list_rec_.size());
			map_rec_.erase(id);
			}
			}

			//////////////recorder
			std::shared_ptr<Recorder> Wrapper::init_recorder(FormatIn *in, std::string id, std::string dir, const int mind, const int maxd){
			if(!in){
			logIt("Init wrapper first");
			return nullptr;
			}

			auto rec = std::make_shared<Recorder>(in, id.c_str());

			rec->SetCallback([&](std::string &id, int &index, std::string &path){
			cache_rec_info(id, index, path);
			});

			int trycnt = 0;
			while(trycnt < 100){
			const int ret = rec->Run(dir.c_str(), mind, maxd);
			if(ret == 0) break;
			usleep(200000);
			}
			if (trycnt < 100){
			return rec;
			}
			return nullptr;
			}

			void Wrapper::BuildRecorder(const char* id, const char *output, const int mindur, const int maxdur){
			std::string rid(id);
			std::string dir(output);

			auto fn = [=](FormatIn *in){
			return init_recorder(in, rid, dir, mindur, maxdur);
			};
			std::shared_ptr<Recorder> rec(nullptr);

			FnRec r = FnRec{fn, rec};
			map_rec_[rid] = r;

			minduration = mindur * 25;
			maxduration = maxdur * 25;
			}

			int Wrapper::FireRecorder(const char* sid,const int64_t &id){
			auto iter = map_rec_.find(sid);
			if (iter != map_rec_.end()){
			if(iter->second.rec){
			iter->second.rec->FireRecorder(id);
			}
			}
			}

			void Wrapper::cache_rec_info(std::string &id, int &index, std::string &path){

			std::lock_guard<std::mutex> l(mutex_rec_);
			while(list_rec_.size() > 100){
			for(int i = 0; i < 25; i++){
			list_rec_.pop_front();
			}
			}
			struct record_file_info info;
			info.file_frame_index = index;
			info.file_path = path;
			info.rec_id = id;
			list_rec_.emplace_back(info);
			list_rec_map_[path] = id;
			logIt("LIST REC FILES COUNT : %d", list_rec_.size());

			}

			void Wrapper::GetInfoRecorder(int &index, std::string &path){
			@@ -272,22 +333,29 @@
			index = info.file_frame_index;
			path = info.file_path;
			list_rec_.pop_front();

			if (map_rec_.find(info.rec_id) != map_rec_.end())
			map_rec_.erase(info.rec_id);
			// logIt("go get info index: %d, file: %s\n", index, path.c_str());
			}

			std::string Wrapper::GetRecorderID(const std::string &path){
			std::string ret("");
			auto iter = list_rec_map_.find(path);
			if (iter != list_rec_map_.end()){
			return iter->second;
			ret = iter->second;
			list_rec_map_.erase(iter);
			}
			return "";


			return ret;
			}
			////////decoder
			void Wrapper::BuildDecoder(){
			use_decoder_ = true;
			}

			void Wrapper::cache_pic(std::shared_ptr<ffwrapper::FrameData> &frame){
			void Wrapper::cache_pic(std::shared_ptr<ffwrapper::FrameData> &frame, int64_t &id){

			pic_bgr24 pic;
			if(bridge_){
			@@ -298,10 +366,10 @@
			unsigned char data = (unsigned char)malloc(pic.w * pic.h * 3);
			bridge_->copyPicture(data, frm);
			pic.data = data;
			pic.id = id;
			}
			if(func_dec_){
			func_dec_(pic.data, pic.w, pic.h);
			}else{

			{
			std::lock_guard<std::mutex> l(mutex_pic_);
			while(list_pic_.size() > 10){
			for(int i = 0; i < 5; i++){
			@@ -315,7 +383,7 @@

			}

			void Wrapper::GetPicDecoder(unsigned char *data, int w, int *h){
			void Wrapper::GetPicDecoder(unsigned char *data, int w, int h, int64_t id){
			std::lock_guard<std::mutex> l(mutex_pic_);
			if(list_pic_.empty()){
			*data = NULL;
			@@ -325,6 +393,7 @@
			}
			auto p = list_pic_.front();
			data = p.data; w = p.w; *h = p.h;
			*id = p.id;
			list_pic_.pop_front();
			}

			@@ -350,20 +419,6 @@
			}
			}
			list_avpkt_.emplace_back(pkt);
			}


			///// active api
			void Wrapper::ActiveRecorder(const char *dir, const int mind, const int maxd,
			FUNC_REC func){

			BuildRecorder("", dir, mind, maxd);
			func_rec_ = func;
			}

			void Wrapper::ActiveDecoder(FUNC_DEC fn){
			BuildDecoder();
			func_dec_ = fn;
			}

			////// test