#include "recorder.hpp"
|
|
#include <thread>
|
#include <unistd.h>
|
|
extern "C"{
|
#include <libavcodec/avcodec.h>
|
}
|
|
#include "../ffmpeg/format/FormatIn.hpp"
|
#include "../ffmpeg/format/FormatOut.hpp"
|
#include "../ffmpeg/data/CodedData.hpp"
|
#include "../ffmpeg/log/log.hpp"
|
|
using namespace logif;
|
using namespace ffwrapper;
|
|
namespace cffmpeg_wrap{
|
namespace buz{
|
Recorder::Recorder(FormatIn *in)
|
:in_(in)
|
,out_(NULL)
|
,maxduration(30 * 25)
|
,minduration(10 * 25)
|
,end_frame(minduration)
|
,cur_frame(-1)
|
,thread_(nullptr)
|
,stop_recorder_(false)
|
,id_frame_(0)
|
,file_frame_index_(-1)
|
,file_path_("")
|
,func_rec_info_(nullptr)
|
{}
|
|
Recorder::~Recorder(){
|
if(thread_){
|
stop_recorder_.store(true);
|
cv_.notify_one();
|
thread_->join();
|
}
|
if(out_)
|
delete out_;
|
}
|
|
int Recorder::init_writer(){
|
if (out_) {
|
delete out_;
|
}
|
|
if(!in_){
|
logIt("init_writer FormatIn not init");
|
return -1;
|
}
|
|
out_ = new FormatOut(in_->getStream(), "mp4");
|
|
return 0;
|
}
|
|
void Recorder::start_writer(){
|
if (cur_frame == 0) {
|
file_path_ = dir_ + "/" + std::to_string(random()) + ".mp4";
|
out_->JustWriter(in_->getStream(), file_path_.c_str());
|
logIt("start record %s", file_path_.c_str());
|
}
|
}
|
|
int Recorder::write_correctly(const avpacket &pkt){
|
//reader failed, break stream
|
if(pkt.id == -1 && !pkt.data){
|
end_writer();
|
return 1;
|
}
|
// writer error, reinit writer
|
int64_t cur = cur_frame++;
|
if(!out_->writeFrame(pkt.data->getAVPacket(), cur)){
|
end_writer();
|
return -1;
|
}
|
if(pkt.id == id_frame_){
|
file_frame_index_ = cur_frame;
|
}
|
return 0;
|
}
|
|
void Recorder::end_writer(){
|
if(cur_frame == -1) return;
|
out_->endWriter();
|
//reinit cur_frame clear list pkt
|
{
|
std::lock_guard<std::mutex> locker(mutex_pkt_);
|
cur_frame = -1;
|
end_frame = minduration;
|
list_pkt_.clear();
|
}
|
//callback to frame index and path
|
if(func_rec_info_){
|
func_rec_info_(file_frame_index_, file_path_);
|
}
|
}
|
|
void Recorder::run_thread(){
|
bool reinit_writer = false;
|
while(!stop_recorder_.load()){
|
if (reinit_writer) {
|
while(!stop_recorder_.load()){
|
if(init_writer() == 0)
|
break;
|
usleep(300000);
|
}
|
if(stop_recorder_.load()) break;
|
}
|
|
std::list<avpacket> pkts;
|
{
|
std::unique_lock<std::mutex> locker(mutex_pkt_);
|
cv_.wait(locker,[&]{
|
return !list_pkt_.empty() || stop_recorder_.load();
|
});
|
if(stop_recorder_.load()){
|
end_writer();
|
break;
|
}
|
if(cur_frame == -1){
|
continue;
|
}
|
list_pkt_.swap(pkts);
|
}
|
|
if (cur_frame == 0) {
|
start_writer();
|
}
|
|
for(auto &i : pkts){
|
if (cur_frame < end_frame){
|
const int ret = write_correctly(i);
|
if(ret != 0){
|
if(ret == -1) reinit_writer = true;
|
break;
|
}
|
}else{
|
end_writer();
|
break;
|
}
|
}
|
}
|
}
|
|
int Recorder::Run(const char* output, const int mind, const int maxd){
|
if(thread_){
|
logIt("recorder already run");
|
return 0;
|
}
|
|
dir_ = output;
|
int ret = init_writer();
|
if(ret != 0){
|
logIt("recorder init writer error");
|
return -1;
|
}
|
|
double fps = out_->getFPS();
|
if(fps > 1.0){
|
maxduration = fps * maxd;
|
minduration = fps * mind;
|
end_frame = minduration;
|
}
|
|
logIt("min %d max %d endcount %d", minduration, maxduration, end_frame);
|
|
thread_.reset(new std::thread([&]{
|
run_thread();
|
}));
|
|
return 0;
|
}
|
|
int Recorder::FireRecorder(const int64_t &id){
|
if(cur_frame == -1){
|
id_frame_ = id;
|
{
|
std::lock_guard<std::mutex> locker(mutex_pkt_);
|
cur_frame = 0;
|
}
|
}else if(end_frame - cur_frame > minduration/2 && end_frame < maxduration){
|
end_frame = end_frame + minduration / 2;
|
if(end_frame > maxduration){
|
end_frame = maxduration;
|
}
|
}
|
return 0;
|
}
|
|
int Recorder::CachePacket(const avpacket &pkt){
|
|
std::lock_guard<std::mutex> locker(mutex_pkt_);
|
|
if(cur_frame == -1){
|
//error occur, stream break
|
if(pkt.id == -1 && pkt.data == nullptr){
|
list_pkt_.clear();
|
return -1;
|
}
|
//wait I
|
if (list_pkt_.empty()) {
|
AVPacket &avpkt = pkt.data->getAVPacket();
|
if (!(avpkt.flags & AV_PKT_FLAG_KEY)){
|
return -1;
|
}
|
}
|
|
maybe_dump_gop();
|
|
list_pkt_.push_back(pkt);
|
}else{
|
list_pkt_.push_back(pkt);
|
cv_.notify_one();
|
}
|
|
return 0;
|
}
|
|
void Recorder::maybe_dump_gop(){
|
//超过min/2,丢弃gop
|
while (list_pkt_.size() > minduration /2) {
|
list_pkt_.pop_front();
|
while(!list_pkt_.empty()){
|
auto &cache = list_pkt_.front();
|
AVPacket &avpkt = cache.data->getAVPacket();
|
if (!(avpkt.flags & AV_PKT_FLAG_KEY)){
|
list_pkt_.pop_front();
|
}else{
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
