#include "CVideoDataManager.h"

#include <fstream>

extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
};

CPacketInfo::CPacketInfo(int64_t pts, AVPacket* pPkt)
{
	m_nPts = pts;
	m_bTimeMark = false;
	m_pPkt = pPkt;
	m_UseState = NO_USE;
}

CPacketInfo::~CPacketInfo()
{
	if (m_pPkt)
	{
		av_packet_free(&m_pPkt);
		m_pPkt = nullptr;
	}
}

CVideoDataManager::CVideoDataManager()
{

}

CVideoDataManager::~CVideoDataManager()
{

}

void CVideoDataManager::AddRecvData(int64_t pts, AVPacket* pAvpkt, bool bIData)
{
	if (pAvpkt ==nullptr || pAvpkt->size<=0)
	{
		return;
	}

	double ptsVideo = pts;
	AVRational ar{ 1,90000 };
	ptsVideo *= av_q2d(ar);

	if (abs(ptsVideo - m_syncVideoPts) < TIME_SYNC_VAINTERVAL)
	{
		//OutputDebugPrintf("VideoPlayer  CVideoDataManager AddData ptsVideo %lf %d", ptsVideo, this);
	}

	CPacketInfo  *pPkt = new CPacketInfo(pts, pAvpkt);
	
	m_lockRecv.lock();
	m_vecRecvPacket.emplace_back(pPkt);
	m_lockRecv.unlock();
}

bool CVideoDataManager::GetRecvData(int64_t nPts, double dPts, CPacketInfo* &pPack)
{
	std::lock_guard<std::mutex> lock(m_lockRecv);

	if (m_vecRecvPacket.size()<=0)
	{
		return false;
	}

	pPack = *m_vecRecvPacket.begin();
	m_vecRecvPacket.erase(m_vecRecvPacket.begin());
	return true;

	for (auto it = m_vecRecvPacket.begin(); it != m_vecRecvPacket.end(); it++)
	{
		double ptsVideo = (*it)->m_nPts;
		AVRational ar{ 1,90000 };
		ptsVideo *= av_q2d(ar);

		if (abs(ptsVideo - m_syncVideoPts - dPts) < TIME_SYNC_VAINTERVAL)
		{
			pPack = (*it);
			m_vecRecvPacket.erase(m_vecRecvPacket.begin());
			return true;
		}
	}

	double ptsVideo = (*m_vecRecvPacket.begin())->m_nPts;
	AVRational ar{ 1,90000 };
	ptsVideo *= av_q2d(ar);
	if (ptsVideo - m_syncVideoPts - dPts> TIME_SYNC_VAINTERVAL)
	{
		//OutputDebugPrintf("VideoPlayer  CVideoDataManager  TIME_SYNC_VAINTERVAL ");
		pPack = new CPacketInfo(0, nullptr);
		return true;
	}

	return false;
}

bool CVideoDataManager::AlignRecvData()
{
	m_lockRecv.lock();
	
	
	bool bHave = false;
	auto it = m_vecRecvPacket.begin();
	for (it = m_vecRecvPacket.begin(); it != m_vecRecvPacket.end();)
	{
		CPacketInfo  *pPkt = *it;
		double ptsVideo = pPkt->m_nPts;
		AVRational ar{ 1,90000 };
		ptsVideo *= av_q2d(ar);
		if (abs(ptsVideo - m_curAutdioPts) < TIME_MARK_VAINTERVAL)
		{
			m_curVideoPts = pPkt->m_nPts;
			m_syncVideoPts = ptsVideo;
			m_nMarkVideoIndex = m_nMarkAudioIndex;
		
			pPkt->m_bTimeMark = true;

			//OutputDebugPrintf("VideoPlayer  UpdateData m_syncVideoPts %lf m_curAutdioPts %lf %d", m_syncVideoPts, m_curAutdioPts,this);
		
			bHave = true;
			break;
		}
		else
		{
			delete pPkt;
			it = m_vecRecvPacket.erase(it);
		}
	}
	
	m_lockRecv.unlock();
	return bHave;
	
}

void CVideoDataManager::Clear()
{
	std::lock_guard<std::mutex> lock(m_lockRecv);
	for (auto it = m_vecRecvPacket.begin(); it != m_vecRecvPacket.end(); it++)
	{
		CPacketInfo  *pPkt = *it;
		delete pPkt;
		pPkt = nullptr;
	}
	m_vecRecvPacket.clear();
}

bool CVideoDataManager::PopData(int64_t & pts, double& dPts, CPacketInfo* &pPack)
{
	std::lock_guard<std::mutex> lock(m_lockRecv);
	if (m_vecRecvPacket.size()>0)
	{
		pts = (*m_vecRecvPacket.begin())->m_nPts;
		pPack = *m_vecRecvPacket.begin();

		dPts = pts;
		AVRational ar{ 1,90000 };
		dPts *= av_q2d(ar);

		dPts = dPts - m_syncVideoPts;
		
		//bool b = (*m_vecRecvPacket.begin())->m_bTimeMark;
		m_vecRecvPacket.erase(m_vecRecvPacket.begin());

		return true;
	}

	return false;
}

void CVideoDataManager::SetAutdioPts(double curAutdioPts)
{
	m_curAutdioPts = curAutdioPts;
}

bool CVideoDataManager::AddSyncData(CPacketInfo* pPack)
{
	//return true;
	std::lock_guard<std::mutex> lock(m_lockSync);

	m_vecPacketSync.emplace_back(pPack);
	return true;
}

bool CVideoDataManager::GetSyncData(CPacketInfo*& pPack)
{
	//return true;
	std::lock_guard<std::mutex> lock(m_lockSync);
	
	if (m_vecPacketSync.size()>0)
	{
		pPack = *m_vecPacketSync.begin();

		m_vecPacketSync.erase(m_vecPacketSync.begin());
		return true;
	}
	
	return false;
}

void CVideoDataManager::ReleaseSyncData(CPacketInfo* pPack)
{
	if (pPack!=nullptr)
	{
		delete pPack;
		pPack = nullptr;
	}
}

size_t CVideoDataManager::GetSyncDataCount()
{
	return m_vecPacketSync.size();
}

bool CVideoDataManager::AddDecoderData(uint8_t* pData, double dPtzAngle)
{
	std::lock_guard<std::mutex> lock(m_lockDecoder);

	if (m_vecFrameDecoder.size()<2)
	{
		m_vecFrameDecoder.emplace_back(pData);
		m_vecPtzAngleDecoder.emplace_back(dPtzAngle);

	}
	else
	{
		delete[]pData;
	}
	
	return false;
}

bool CVideoDataManager::GetDecoderData(uint8_t*& pData, int& nDataSize, double& dPtzAngle)
{
	std::lock_guard<std::mutex> lock(m_lockDecoder);
	if (m_vecFrameDecoder.size() > 0)
	{
		pData = *m_vecFrameDecoder.begin();
		dPtzAngle = *m_vecPtzAngleDecoder.begin();
		m_vecFrameDecoder.erase(m_vecFrameDecoder.begin());
		m_vecPtzAngleDecoder.erase(m_vecPtzAngleDecoder.begin());
		nDataSize = m_nDataDecodeSize;
		return true;
	}

	return false;
}

void CVideoDataManager::ReleaseDecoderData(uint8_t* pData)
{
	if (pData)
	{
		delete[]pData;
		pData = nullptr;
	}
}

int CVideoDataManager::GetDecoderDataCount()
{
	return m_vecFrameDecoder.size();
}