#include "PL_AVFrameBGRA.h"
#include "MaterialBuffer.h"
#include "logger.h"

extern "C"
{
	#include <libavcodec/avcodec.h>
	#include <libavutil/frame.h>
	#include <libavformat/avformat.h>
	
	#include <libyuv.h>
}

struct PL_AVFrameBGRA_Internal
{
	uint8_t buffer[1920*1080*4];//#todo
	size_t buffSize;
	size_t buffSizeMax;
	MB_Frame lastFrame;

	bool payError;
	
	PL_AVFrameBGRA_Internal() : 
		buffSize(0), buffSizeMax(sizeof(buffer)), lastFrame(), 
		payError(true)
	{
	}
	
	~PL_AVFrameBGRA_Internal()
	{
	}
	
	void reset()
	{
		buffSize = 0;
		payError = true;
		
		MB_Frame _lastFrame;
		lastFrame = _lastFrame;
	}
};

PipeLineElem* create_PL_AVFrameBGRA()
{
	return new PL_AVFrameBGRA;
}

PL_AVFrameBGRA::PL_AVFrameBGRA() : internal(new PL_AVFrameBGRA_Internal)
{
}

PL_AVFrameBGRA::~PL_AVFrameBGRA()
{
	delete (PL_AVFrameBGRA_Internal*)internal;
	internal= nullptr;
}

bool PL_AVFrameBGRA::init(void* args)
{
	PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
	in->reset();

	return true;
}

void PL_AVFrameBGRA::finit()
{
	PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
	
}

#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a))

bool PL_AVFrameBGRA::pay(const PipeMaterial& pm)
{
	PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;
	
	if (pm.type != PipeMaterial::PMT_FRAME)
	{
		LOG(ERROR) << "PL_AVFrameBGRA::pay only support PMT_FRAME";
		return false;
	}
	
	if (pm.buffer == nullptr)
		return false;
	
	MB_Frame* frame = (MB_Frame*)pm.buffer;
	if (frame->type != MB_Frame::MBFT_PTR_AVFRAME)
	{
		LOG(ERROR) << "PL_AVFrameBGRA::pay only support MBFT_PTR_AVFRAME";
		return false;
	}

	AVFrame* pAVFrame = (AVFrame*)frame->buffer;
	if (pAVFrame == nullptr)
		return false;

	const int height = pAVFrame->height;
	const int width = pAVFrame->width;

//int I420ToBGRA(const uint8* src_y, int src_stride_y,
//               const uint8* src_u, int src_stride_u,
//               const uint8* src_v, int src_stride_v,
//               uint8* dst_argb, int dst_stride_argb,
//			   int width, int height);

	libyuv::I420ToBGRA(pAVFrame->data[0], width, 
						pAVFrame->data[1], SUBSAMPLE(width, 2), 
						pAVFrame->data[2], SUBSAMPLE(width, 2), 
						in->buffer, 4 * width, 
						width, height);

	in->buffSize = in->buffSizeMax;
	//in->buffer readly
	
	in->lastFrame.type = MB_Frame::MBFT_BGRA;
	in->lastFrame.buffer = in->buffer;
	in->lastFrame.buffSize = in->buffSize;
	in->lastFrame.width = width;
	in->lastFrame.height = height;
	in->lastFrame.pts = frame->pts;

	//#test
	//static size_t f=0;
	//char fname[50];
	//sprintf(fname, "%u.bgra", ++f);
	//FILE * pFile = fopen (fname,"wb");
	//fwrite (in->buffer , sizeof(char), in->buffSize, pFile);
	//fclose(pFile);

	return true;
}

bool PL_AVFrameBGRA::gain(PipeMaterial& pm)
{
	PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;

	pm.type = PipeMaterial::PMT_FRAME;
	pm.buffer = &(in->lastFrame);
	pm.buffSize = 0;
	pm.former = this;
	return true;
}