#include "roll_polling.h"
#include <thread>
#include <vector>

namespace mediakit {

#define ErrorL std::cerr
#define InfoL std::cerr
#define WarnL std::cerr

int RollPollingWorker::Start(const std::string input, const std::string output) {
	av_log_set_level(AV_LOG_INFO);
	std::lock_guard<std::mutex> lock(mutex_);
	source_ctx_ = OpenInputFile(input);
	if (!source_ctx_) {
		ErrorL << "open input file [" << input << "] failed";
		return -1;
	}
		
	if (OpenOutputFile(output) < 0) {
		ErrorL << "open output file [" << output << "] failed";
		return -1;
	}

	filter_ctx_ = InitFilter(source_ctx_->codec_ctx_, ocodec_ctx_);
	if (!filter_ctx_) {
		ErrorL << "output file " << output << " init filter failed";
		return -1;
	}
	
	output_ = output;
	state_ = kRunning;
	std::cerr << "start roll polling task [" << output_ << "] successed \n";
	return 0;
}

int RollPollingWorker::Stop() {
	state_ = kStoped;
	return 0;
}

int RollPollingWorker::UpdateInput(const std::string input) {
	std::string prefix = Prefix();
	if (kRunning != state_) {
		ErrorL << prefix << " is not running";
		return -1;
	}
	
	if (input == source_ctx_->filename_) {
		InfoL << prefix << " input file [" << input << " is same with preview input";
		return 0;
	}

	std::shared_ptr<SourceContext> source_ctx = OpenInputFile(input);
	if (!source_ctx) {
		ErrorL << prefix << " open input file [" << input << "] failed";
		return -1;
	}


	std::shared_ptr<FilterContext> filter_ctx = InitFilter(source_ctx->codec_ctx_, ocodec_ctx_);
	if (!filter_ctx) {
		ErrorL << prefix << " init filter failed";
		return -1;
	}

	std::lock_guard<std::mutex> lock(mutex_);
	source_ctx_ = source_ctx;
	filter_ctx_ = filter_ctx;
	need_idr_ = true;
	InfoL << "update input file " << input << " successed \n";
	return 0;
}

void RollPollingWorker::Runnable() {
	std::string prefix = Prefix();
	AVPacket* pkt = av_packet_alloc();
	while (kRunning == state_) {
		std::lock_guard<std::mutex> lock(mutex_);
		SourceContext* source = source_ctx_.get();
		FilterContext* filter = filter_ctx_.get();
		
		int ret = av_read_frame(source->fmt_ctx_, pkt);
		if (ret < 0) {
			if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
				ret = 0;
			break;
		}

		// only process video stream 
		if (pkt->stream_index != source->vid_stream_idx_)
			continue;

		
		if (filter_ctx_) {
			ret = avcodec_send_packet(source->codec_ctx_, pkt);
			if (ret < 0) {
				if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
					ret = 0;
				break;
			}

			while (ret >= 0) {
			  	ret = avcodec_receive_frame(source->codec_ctx_, source->decoded_frame_);
				if (ret < 0) {
					if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
						ret = 0;
					break;
				}

				FilterFrame(filter, source->decoded_frame_);
				av_frame_unref(source->decoded_frame_);
			}			
		} else {
            //av_packet_rescale_ts(pkt,
            //                     source->fmt_ctx_->streams[pkt->stream_index]->time_base,
            //                     ofmt_ctx_->streams[0]->time_base);	// only video stream
            
			pkt->stream_index = 0;
			pkt->pts = pkt->dts = (frame_cnt_++) * 40;
			pkt->duration = 0;
			pkt->pos = -1;
            ret = av_interleaved_write_frame(ofmt_ctx_, pkt);
		}

		av_packet_unref(pkt);
		//std::cerr << "write video packet size = " << pkt->size << " result = " << ret << " \n";
		if (ret < 0) {
			ErrorL << prefix << " write packet to output file failed \n"; 
			//break;
		}
	}
	
	av_write_trailer(ofmt_ctx_);
	av_packet_free(&pkt);
	
	avcodec_free_context(&ocodec_ctx_);
    if (ofmt_ctx_ && !(ofmt_ctx_->oformat->flags & AVFMT_NOFILE))
        avio_closep(&ofmt_ctx_->pb);
    avformat_free_context(ofmt_ctx_);	
	state_ = kStoped;
	InfoL << "roll polling task finished";
}

std::shared_ptr<RollPollingWorker::SourceContext> RollPollingWorker::OpenInputFile(const std::string filename) {
	std::shared_ptr<SourceContext> source_ctx = std::make_shared<SourceContext>();
	int ret = avformat_open_input(&source_ctx->fmt_ctx_, filename.c_str(), 0, nullptr);
	if (ret < 0) {
		ErrorL << "failed to open input file [" << filename << "]";
		return nullptr;
	}
	
	ret = avformat_find_stream_info(source_ctx->fmt_ctx_, 0);
	if (ret < 0) {
		ErrorL << "Fail to find input stream information in [" << filename << "]";
		return nullptr;
	}
	
	AVCodec* dec = nullptr;
	ret = av_find_best_stream(source_ctx->fmt_ctx_, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
	if (ret < 0) {
		ErrorL << "Fail to av_find_best_stream in [" << filename << "]";
		return nullptr;
	}
	
	source_ctx->vid_stream_idx_ = ret;
	source_ctx->codec_ctx_ = avcodec_alloc_context3(dec);
	if (!source_ctx->codec_ctx_) {
		ErrorL << "Fail to avcodec_alloc_context3 in [" << filename << "]";
		return nullptr;
	}

	int vid_stream_idx = source_ctx->vid_stream_idx_;
	avcodec_parameters_to_context(source_ctx->codec_ctx_, source_ctx->fmt_ctx_->streams[vid_stream_idx]->codecpar);
	
	// very important 
	source_ctx->codec_ctx_->framerate = av_guess_frame_rate(source_ctx->fmt_ctx_, source_ctx->fmt_ctx_->streams[vid_stream_idx], nullptr);
	ret = avcodec_open2(source_ctx->codec_ctx_, dec, NULL);
	if (ret < 0) {
		ErrorL << "Fail to avcodec_open2 in [" << filename << "]";
		return nullptr;
	}
	
	source_ctx->decoded_frame_ = av_frame_alloc();	
	return source_ctx;
}

int RollPollingWorker::OpenOutputFile(const std::string filename) {
	avformat_alloc_output_context2(&ofmt_ctx_, nullptr, "flv", filename.c_str());
	if (!ofmt_ctx_) {
		ErrorL << "failed to open output file [" << filename << "]";
		return -1;
	}
			
    const AVCodec* enc = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!enc) {
    	ErrorL << "cannot find H.264 encoder";
   		return -1;
    }
		
    ocodec_ctx_ = avcodec_alloc_context3(enc);
    if (!ocodec_ctx_) {
        ErrorL << "failed to allocate H.264 encoder context";
        return -1;
    }

	ocodec_ctx_->height = source_ctx_->codec_ctx_->height;
	ocodec_ctx_->width = source_ctx_->codec_ctx_->width;
	ocodec_ctx_->sample_aspect_ratio = source_ctx_->codec_ctx_->sample_aspect_ratio;
	ocodec_ctx_->pix_fmt = source_ctx_->codec_ctx_->pix_fmt;
	ocodec_ctx_->time_base = av_inv_q(source_ctx_->codec_ctx_->framerate);

	AVDictionary* enc_opts = nullptr;
	av_dict_set(&enc_opts, "x264-params", "crf=23:bframes=0", 0);
    if (avcodec_open2(ocodec_ctx_, enc, &enc_opts) < 0) {
        ErrorL << "Cannot open video encoder";
        return -1;
    }
	
	AVStream* out_stream = avformat_new_stream(ofmt_ctx_, nullptr);
	if (!out_stream) {
		ErrorL << "Fail to avformat_new_stream, filename " << filename << " \n";
	  	return -1;
	}
			
    if (avcodec_parameters_from_context(out_stream->codecpar, ocodec_ctx_) < 0) {
        ErrorL << "Failed to copy encoder parameters to output";
        return -1;
    }

    out_stream->time_base = ocodec_ctx_->time_base;				
	if (avio_open(&ofmt_ctx_->pb, filename.c_str(), AVIO_FLAG_WRITE) < 0) {
   		ErrorL << "Could not open output file " << filename << "\n";
    	return -1;
	}

	AVDictionary* opts = nullptr;
	av_dict_set(&opts, "flvflags", "no_duration_filesize+no_metadata", 0);
	return avformat_write_header(ofmt_ctx_, &opts);	
}

std::shared_ptr<RollPollingWorker::FilterContext> RollPollingWorker::InitFilter(
		AVCodecContext* icodec_ctx, AVCodecContext* ocodec_ctx) {
	std::shared_ptr<FilterContext> filter_ctx = std::make_shared<FilterContext>();
	filter_ctx->filter_graph_ = avfilter_graph_alloc();
	filter_ctx->filter_frame_ = av_frame_alloc();
	
	char args[512];
	snprintf(args, sizeof(args),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		icodec_ctx->width, icodec_ctx->height, icodec_ctx->pix_fmt,
		icodec_ctx->time_base.num, icodec_ctx->time_base.den,
		icodec_ctx->sample_aspect_ratio.num,
		icodec_ctx->sample_aspect_ratio.den);
	const AVFilter* buffersrc = avfilter_get_by_name("buffer");
	int ret = avfilter_graph_create_filter(&filter_ctx->buffersrc_ctx_, buffersrc, "in", 
			args, nullptr, filter_ctx->filter_graph_);
	if (ret < 0) {
		ErrorL << "Cannot create buffer source";
		return nullptr;
	}

	const AVFilter* buffersink = avfilter_get_by_name("buffersink");
	ret = avfilter_graph_create_filter(&filter_ctx->buffersink_ctx_, buffersink, "out", 
			nullptr, nullptr, filter_ctx->filter_graph_); 
   	if (ret < 0) {
        ErrorL << "Cannot create buffer sink";
        return nullptr;
    }
		
    ret = av_opt_set_bin(filter_ctx->buffersink_ctx_, "pix_fmts", 
    		(uint8_t*)&ocodec_ctx_->pix_fmt, sizeof(ocodec_ctx_->pix_fmt), AV_OPT_SEARCH_CHILDREN);
    if (ret < 0) {
        ErrorL << "Cannot set output pixel format";
        return nullptr;
    }

	AVFilterInOut* outputs = avfilter_inout_alloc();;
	outputs->name = av_strdup("in");
	outputs->filter_ctx = filter_ctx->buffersrc_ctx_;
	outputs->pad_idx = 0;
	outputs->next = nullptr;
	
	AVFilterInOut *inputs  = avfilter_inout_alloc();
	inputs->name       = av_strdup("out");
	inputs->filter_ctx = filter_ctx->buffersink_ctx_;
	inputs->pad_idx    = 0;
	inputs->next       = NULL;

	std::string filter_spec = "[in]scale=" + std::to_string(kWidth) + ":" + std::to_string(kHeight) + "[out]";
	do {
		ret = avfilter_graph_parse_ptr(filter_ctx->filter_graph_, filter_spec.c_str(), &inputs, &outputs, nullptr);
		if (ret < 0) {
			ErrorL << "avfilter graph parse failed";
			break;
		}

		ret = avfilter_graph_config(filter_ctx->filter_graph_, nullptr);
		if (ret < 0) {
			ErrorL << "avfilter graph config failed";
			break;
		}
	} while (0);

    avfilter_inout_free(&inputs);
	avfilter_inout_free(&outputs);		
	return ret < 0 ? nullptr : filter_ctx;
}


int RollPollingWorker::FilterFrame(FilterContext* filter, AVFrame* frame) {
    int ret = av_buffersrc_add_frame_flags(filter->buffersrc_ctx_, frame, 0);
    if (ret < 0) {
        ErrorL << "Error while feeding the filtergraph \n";
        return ret;
    }

    while (1) {
        ret = av_buffersink_get_frame(filter->buffersink_ctx_, filter->filter_frame_);
        if (ret < 0) {
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                ret = 0;
            break;
        }

        filter->filter_frame_->pict_type = AV_PICTURE_TYPE_NONE;
		if (need_idr_) {
			filter->filter_frame_->pict_type = AV_PICTURE_TYPE_I;
			need_idr_ = false;
		}
        ret = EncodeFrame(filter->filter_frame_);
        av_frame_unref(filter->filter_frame_);
        if (ret < 0)
            break;
    }

    return ret;
}

int RollPollingWorker::EncodeFrame(AVFrame* frame) {
	if (avcodec_send_frame(ocodec_ctx_, frame) < 0)
		return -1;
	
	AVPacket* enc_pkt = av_packet_alloc();
	int ret = 0;
	while (ret >= 0) {
		ret = avcodec_receive_packet(ocodec_ctx_, enc_pkt);
        if (ret < 0) {
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                ret = 0;
            break;
        }
	
		enc_pkt->stream_index = 0;
		enc_pkt->pts = enc_pkt->dts = (frame_cnt_++) * 40;
		enc_pkt->duration = 0;
		enc_pkt->pos = -1;

		//std::cerr << "muxing frame: pts " << enc_pkt->pts << " duration " << enc_pkt->duration << "\n";
		ret = av_interleaved_write_frame(ofmt_ctx_, enc_pkt);
		av_packet_unref(enc_pkt);
		if (ret < 0) {
			ErrorL << Prefix() << " write packet to output file failed \n"; 
			break;
		}
	}

	av_packet_free(&enc_pkt);
	return ret;
}


int RollPollingWorkerPool::StartWorker(const std::string input, const std::string output) {
	std::shared_ptr<RollPollingWorker> worker = std::make_shared<RollPollingWorker>();
	if (!worker->Start(input, output)) {
		return -1;
	}
	
	std::weak_ptr<RollPollingWorker> weak_worker = worker;
	auto task = [weak_worker](int64_t unused){
		auto worker = weak_worker.lock();
		if (worker)
			worker->Runnable();
	};

	std::lock_guard<std::mutex> lock(mutex_);
	worker_list_[output] = worker;
	return 0;
}

int RollPollingWorkerPool::StopWorker(const std::string url) {
	std::lock_guard<std::mutex> lock(mutex_);
	auto it = worker_list_.find(url);
	return it != worker_list_.end() ? it->second->Stop() : -1;
}

int RollPollingWorkerPool::PollingStart(const std::vector<std::string> inputsurl, const std::string outputurl) {	
	std::vector<std::string> inputs = inputsurl ;
	// for (int i = 1; i < (argc - 1); i++)
	// 	inputs.push_back(argv[i]);
	// std::string output = argv[argc - 1];
	std::string output = outputurl;
	
	mediakit::RollPollingWorker worker;
	if (worker.Start(inputs[0], output) < 0)
		return -1;
		
	
	auto f = [&](){
		worker.Runnable();
	};
	
	std::thread task(f);
	task.detach();

	size_t idx = 1;
	while (worker.IsRunning()) {
		std::this_thread::sleep_for(std::chrono::milliseconds(10000));
		if (idx >= 4)
			break;
		
		if (inputs.size() > 1) {
			std::string tmp = inputs[idx % inputs.size()];
			std::cerr << "change input file to [" << tmp << "\n";
			worker.UpdateInput(tmp);
			idx++;			
		}
	}

	worker.Stop();
	//task.join();
	return 0;
}
}每一行都加上中文注释，帮助我理解