#include "Decoder_OMX.h"

#include "OMX_Core.h"
#include "OMX_Types.h"
#include "OMX_Other.h"
#include "OMX_Component.h"
#include <stdlib.h>
#include "logjam.h"
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <unistd.h>
#include <time.h>
#include <unistd.h>

#define 	OMX_MAX_STRINGNAME_SIZE   128  // why isn't this defined in OMX_Core.h ???
/*static OMX_BUFFERHEADERTYPE **omx_buffers_out;
 static OMX_BUFFERHEADERTYPE **omx_buffers_in;*/

static int buffer_out_mask;//, buffer_out_nb;
static int buffer_in_mask;//, buffer_in_nb, buffer_in_size;


typedef OMX_ERRORTYPE OMX_APIENTRY(*OMX_Init_FPTR)
(void);
OMX_Init_FPTR my_OMX_Init = NULL;

typedef OMX_ERRORTYPE OMX_APIENTRY(*OMX_ComponentNameEnum_FPTR)
(
		OMX_OUT OMX_STRING cComponentName,
		OMX_IN OMX_U32 nNameLength,
		OMX_IN OMX_U32 nIndex);
OMX_ComponentNameEnum_FPTR my_OMX_ComponentNameEnum = NULL;

typedef OMX_ERRORTYPE (*OMX_GetRolesOfComponent_FPTR)(OMX_IN OMX_STRING compName, OMX_INOUT OMX_U32 *pNumRoles, OMX_OUT OMX_U8 **roles);
OMX_GetRolesOfComponent_FPTR my_OMX_GetRolesOfComponent = NULL;

typedef OMX_ERRORTYPE (*OMX_GetHandle_FPTR)(
		OMX_OUT OMX_HANDLETYPE* pHandle,
		OMX_IN OMX_STRING cComponentName,
		OMX_IN OMX_PTR pAppData,
		OMX_IN OMX_CALLBACKTYPE* pCallBacks);
OMX_GetHandle_FPTR my_OMX_GetHandle = NULL;

OMX_HANDLETYPE decoder_handle;
int input_port = -1;
int output_port = -1;
int input_buffer_count = -1;
int input_buffer_size = -1;

// this is hardcoded !!!
// remember to make this dynamic
#define PICTURE_BUFFERS_NUM_INPUT 10
#define PICTURE_BUFFERS_NUM_OUTPUT 8

OMX_BUFFERHEADERTYPE* g_BuffersIn[PICTURE_BUFFERS_NUM_INPUT];
OMX_BUFFERHEADERTYPE* g_BuffersOut[PICTURE_BUFFERS_NUM_OUTPUT];

int g_iCurrentInput = 0;
int g_iCurrentOutput = 0;

FILE* g_pVidFile = NULL;

/*********************/
// Callbacks
/*********************/

void Print_Event_Type(OMX_EVENTTYPE event) {
	//LOGI("blah=%d",OMX_EventPortSettingsChanged);
	switch (event) {
	case OMX_EventCmdComplete:
		LOGI("event=OMX_EventCmdComplete");
		break;

	case OMX_EventError:
		LOGI("event=OMX_EventError");
		break;
	case OMX_EventMark:
		LOGI("event=OMX_EventMark");
		break;
	case OMX_EventPortSettingsChanged:
		LOGI("Oevent=MX_EventPortSettingsChanged");
		break;
	case OMX_EventBufferFlag:
		LOGI("event=OMX_EventBufferFlag");
		break;
	case OMX_EventResourcesAcquired:
		LOGI("event=OMX_EventResourcesAcquired");
		break;
	case OMX_EventComponentResumed:
		LOGI("event=OMX_EventComponentResumed");
		break;
	case OMX_EventDynamicResourcesAvailable:
		LOGI("event=OMX_EventDynamicResourcesAvailable");
		break;
	case OMX_EventPortFormatDetected:
		LOGI("event=OMX_EventPortFormatDetected");
		break;
	default:
		LOGI("[Unkown OMX_EVENTTYPE!]");
		break;
	}
}

void OnOutputPortEnabled() {
	LOGI("<<OnOutputPortEnabled>>");
	int err =
			OMX_FillThisBuffer(decoder_handle, g_BuffersOut[g_iCurrentOutput]);
	if (err != OMX_ErrorNone)
		LOGE("1 OMX_FillThisBuffer on output %d failed!! [0x%X]",
				g_iCurrentOutput, err);
	else
		LOGI("1 OMX_FillThisBuffer on output %d ok.", g_iCurrentOutput);

	g_iCurrentOutput++;
	g_iCurrentOutput %= PICTURE_BUFFERS_NUM_OUTPUT;
}

void OnInputPortEnabled() {
	LOGI("<<OnInputPortEnabled>>");
	OMX_BUFFERHEADERTYPE *buf = g_BuffersIn[g_iCurrentInput];

	int read_len = fread(buf->pBuffer, 1, input_buffer_size, g_pVidFile);
	LOGI("read from file: %d bytes\n", read_len);
	buf->nFilledLen = read_len;

	int err = OMX_EmptyThisBuffer(decoder_handle, buf);

	if (err == OMX_ErrorNotReady) {
		LOGI("OMX_EmptyThisBuffer input %d! - Error=OMX_ErrorNotReady",
				g_iCurrentInput);
	} else if (err != OMX_ErrorNone) {
		LOGE("Error on OMX_EmptyThisBuffer input %d! - Error=%X!!!",
				g_iCurrentInput, err);
	} else {
		LOGI("OMX_EmptyThisBuffer input %d ok.", g_iCurrentInput);
	}

	g_iCurrentInput++;
	g_iCurrentInput %= PICTURE_BUFFERS_NUM_INPUT;
}

OMX_ERRORTYPE decoder_event_handler(
		OMX_IN OMX_HANDLETYPE hComponent,
		OMX_IN OMX_PTR pAppData,
		OMX_IN OMX_EVENTTYPE eEvent,
		OMX_IN OMX_U32 nData1,
		OMX_IN OMX_U32 nData2,
		OMX_IN OMX_PTR pEventData)
{
	LOGI("[[decoder_event_handler]]: Got event %x %x %x\n", eEvent, (unsigned int)nData1, (unsigned int)nData2);
	//LOGI("Event=");
	Print_Event_Type(eEvent);

	OMX_COMMANDTYPE cmd_type;

	switch(eEvent)
	{
		case OMX_EventCmdComplete:
		switch (nData1) {
			case OMX_CommandPortDisable:
			LOGI("-- OMX_CommandPortDisable");
			//DCHECK_EQ(data2, output_port_);
			//OnOutputPortDisabled();
			return;
			case OMX_CommandPortEnable:
			LOGI("-- OMX_CommandPortEnable on port %d",nData2);

			if (nData2 == output_port)
			{
				//OnOutputPortEnabled();
			} else if (nData2 == input_port)
			{
				//OnInputPortEnabled();
			} else
			LOGE("Unkown port!!!");

			//DCHECK_EQ(data2, output_port_);
			//OnOutputPortEnabled();
			return;
			case OMX_CommandStateSet:
			LOGI("-- OMX_CommandStateSet");
			//DispatchStateReached(static_cast<OMX_STATETYPE>(data2));
			return;
			case OMX_CommandFlush:
			LOGI("-- OMX_CommandFlush");
			/*if (current_state_change_ == DESTROYING)
			 return;
			 DCHECK(current_state_change_ == RESETTING);
			 if (data2 == input_port_)
			 InputPortFlushDone();
			 else if (data2 == output_port_)
			 OutputPortFlushDone();
			 else
			 NOTREACHED() << "Unexpected port flushed: " << data2;*/
			return;
			default:
			LOGE("Unknown command completed: %d",nData1);
		}
		return;
		case OMX_EventPortSettingsChanged:
		// i got a reference for this
		LOGI("OMX_EventPortSettingsChanged ou~\n");
		break;
		case OMX_EventBufferFlag:
		LOGI("OMX_EventBufferFlag\n");
		break;
		case OMX_EventError:
		LOGE("fail\n");
		break;
		default:
		LOGI("Unkown event.");
	}

	return OMX_ErrorNone;
}

OMX_ERRORTYPE decoder_empty_buffer_done(
		OMX_IN OMX_HANDLETYPE hComponent,
		OMX_IN OMX_PTR pAppData,
		OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
{
	LOGI("[[decoder_empty_buffer_done]]: %x\n", pBuffer->pPlatformPrivate);
	/*if(pBuffer->pPlatformPrivate < 102400)
	 exit(1);

	 buffer_in_mask |= 1<<*(short*)pBuffer->pPlatformPrivate;
	 sem_post(&wait_buff);

	 return 0;
	 */

	return OMX_ErrorNone;
}

OMX_ERRORTYPE decoder_fill_buffer_done(
		OMX_OUT OMX_HANDLETYPE hComponent,
		OMX_OUT OMX_PTR pAppData,
		OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
{

	static int got = 0, times=0;

	times++;

	LOGI("[[decoder_fill_buffer_done]]: (%d)",times);

	/*

	 got +=  pBuffer->nFilledLen,
	 printf("filled %x %d %d %d\n", pBuffer,  pBuffer->nFilledLen, got, times );

	 #ifdef DUMP
	 write(dumper, pBuffer->pBuffer,  pBuffer->nFilledLen);
	 fsync(dumper);
	 printf("sync...\n");
	 #endif

	 buffer_out_mask |= 1<<*(short*)pBuffer->pPlatformPrivate;

	 sem_post(&wait_buff);

	 #if 0
	 int i;
	 printf("dump: ->");
	 for(i=0;i<pBuffer->nFilledLen;i++)
	 printf("%02x ", *(pBuffer->pBuffer+i));

	 printf("<-\n");
	 #endif

	 return 0;
	 */

	return OMX_ErrorNone;
}

/*********************/
/*********************/

static void setHeader(OMX_PTR header, OMX_U32 size) {

	memset(header, 0, size);

	OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*) (header + sizeof(OMX_U32));
	*((OMX_U32*) header) = size;

	ver->s.nVersionMajor = 1;
	ver->s.nVersionMinor = 1;
	ver->s.nRevision = 0;
	ver->s.nStep = 0;
}

// This is to initialize the OMX data structures to default values.
/*template <typename T>
 static void InitParam(const OmxVideoDecodeAccelerator& dec, T* param) {
 memset(param, 0, sizeof(T));
 param->nVersion.nVersion = 0x00000101;
 param->nSize = sizeof(T);
 }*/

void Print_CurrentState(OMX_HANDLETYPE h) {
	OMX_STATETYPE curr_state = -1;

	int err = OMX_GetState(h, &curr_state);
	if (err != OMX_ErrorNone) {
		LOGE("ERROR OMX_GetState - Error=%X!!!", err);
	} else {
		//LOGI("OMX_GetState ok. curr_state is %d",curr_state);
		switch (curr_state) {
		case OMX_StateInvalid:
			LOGI("OMX_StateInvalid.");
			break;
		case OMX_StateLoaded:
			LOGI("OMX_StateLoaded.");
			break;
		case OMX_StateIdle:
			LOGI("OMX_StateIdle.");
			break;
		case OMX_StateExecuting:
			LOGI("OMX_StateExecuting.");
			break;
		case OMX_StatePause:
			LOGI("OMX_StatePause.");
			break;
		case OMX_StateWaitForResources:
			LOGI("OMX_StateWaitForResources.");
			break;

		default:
			LOGE("Unkown state.");
			break;
		};
	}
}

void Print_OMX_BUFFERHEADERTYPE(struct OMX_BUFFERHEADERTYPE* pVal) {
	LOGI("****** OMX_BUFFERHEADERTYPE = 0x%8X ******", pVal);

	LOGI("pVal->nSize = %u", pVal->nSize);
	LOGI("pVal->nVersion = 0x%X", pVal->nVersion);
	LOGI("pVal->pBuffer = 0x%X", pVal->pBuffer);

	LOGI("pVal->nAllocLen = %u", pVal->nAllocLen);
	LOGI("pVal->nFilledLen = %u", pVal->nFilledLen);
	LOGI("pVal->nOffset = %u", pVal->nOffset);
	LOGI("pVal->pAppPrivate = 0x%X", pVal->pAppPrivate);
	LOGI("pVal->nFlags = %u", pVal->nFlags);
	LOGI("pVal->nOutputPortIndex = %u", pVal->nOutputPortIndex);
	LOGI("pVal->nInputPortIndex = %u", pVal->nInputPortIndex);

	LOGI("******************");
}

void Print_OMX_PORT_PARAM_TYPE(struct OMX_PORT_PARAM_TYPE* pVal) {
	LOGI("****** OMX_PORT_PARAM_TYPE = 0x%8X ******", pVal);

	LOGI("pVal->nSize = %u", pVal->nSize);
	LOGI("pVal->nVersion = 0x%X", pVal->nVersion);
	LOGI("pVal->nPorts = %u", pVal->nPorts);
	LOGI("pVal->nStartPortNumber = %u", pVal->nStartPortNumber);

	LOGI("******************");
}

void Print_OMX_PARAM_PORTDEFINITIONTYPE(
		struct OMX_PARAM_PORTDEFINITIONTYPE* port_def) {
	LOGI("****** port_def = 0x%8X ******", port_def);

	LOGI("nSize = %u", port_def->nSize);
	LOGI("nVersion = %X", port_def->nVersion);
	LOGI("nPortIndex = %u", port_def->nPortIndex);
	LOGI("eDir = %u", port_def->eDir);

	LOGI("nBufferCountActual = %u", port_def->nBufferCountActual);
	LOGI("nBufferCountMin = %u", port_def->nBufferCountMin);
	LOGI("nBufferSize = %u", port_def->nBufferSize);
	LOGI("bEnabled = %u", port_def->bEnabled);
	LOGI("bPopulated = %u", port_def->bPopulated);
	LOGI("eDomain = %u", port_def->eDomain);

	LOGI("format.video.cMIMEType = %s", port_def->format.video.cMIMEType);
	LOGI("format.video.pNativeRender = %u",
			port_def->format.video.pNativeRender);
	LOGI("format.video.nFrameWidth = %u", port_def->format.video.nFrameWidth);
	LOGI("format.video.nFrameHeight = %u", port_def->format.video.nFrameHeight);
	LOGI("format.video.nStride = %u", port_def->format.video.nStride);
	LOGI("format.video.nSliceHeight = %u", port_def->format.video.nSliceHeight);

	LOGI("format.video.nBitrate = %u", port_def->format.video.nBitrate);
	LOGI("format.video.xFramerate = %u", port_def->format.video.xFramerate);
	LOGI("format.video.bFlagErrorConcealment = %u",
			port_def->format.video.bFlagErrorConcealment);
	LOGI("format.video.eCompressionFormat = %u",
			port_def->format.video.eCompressionFormat);
	LOGI("format.video.eColorFormat = %u", port_def->format.video.eColorFormat);

	LOGI("******************************");
}

struct Decoder_OMX* CreateDecoder_OMX() {

	if (g_pVidFile == NULL) {
		g_pVidFile = fopen("/sdcard/out.yuv", "rb");
		LOGI("Opened video file - got file handle %X",
				(unsigned int) g_pVidFile);
		//fclose(g_pVideoFile);
	} else {
		LOGE("Failed trying to open video file.");

	}

	struct Decoder_OMX *instance = (struct Decoder_OMX *) malloc(
			sizeof(struct Decoder_OMX));

	void* hModule;
	hModule = dlopen("/system/lib/libnvomx.so", RTLD_NOW);//dlopen("libpvnvomx.so",RTLD_NOW);
	if (hModule == NULL) {
		LOGE("libnvomx.so Load Fails\n");
		return NULL;
	}

	LOGI("libnvomx.so Load Success\n");

	my_OMX_Init = (OMX_Init_FPTR) dlsym(hModule, "OMX_Init");
	LOGI("my_OMX_Init=0x%8X", my_OMX_Init);

	OMX_ERRORTYPE err;
	int i;
	char ComponentName[128];
	OMX_STRING str = ComponentName;

	err = my_OMX_Init();
	if (err != OMX_ErrorNone) {
		LOGE("OMX_Init Failed! [%d]", err);
		return NULL;
	}

	LOGI("OMX_Init ok.");

	my_OMX_ComponentNameEnum = (OMX_ComponentNameEnum_FPTR) dlsym(hModule,
			"OMX_ComponentNameEnum");
	LOGI("my_OMX_ComponentNameEnum=0x%8X", my_OMX_ComponentNameEnum);

	err = OMX_ErrorNone;

	for (i = 0; err != OMX_ErrorNoMore; i++) {
		err = my_OMX_ComponentNameEnum(str, 128, i);
		if (err == OMX_ErrorNone) {
			//LOGI("The %dth ComponentName is %s\n", i, str);
		}
	}

	my_OMX_GetRolesOfComponent = (OMX_GetRolesOfComponent_FPTR) dlsym(hModule,
			"OMX_GetRolesOfComponent");
	LOGI("my_OMX_GetRolesOfComponent=0x%8X", my_OMX_GetRolesOfComponent);

	OMX_U32 NumRoles;
	OMX_U8 **roles;

	my_OMX_GetRolesOfComponent("OMX.Nvidia.h264.decode", &NumRoles, NULL); // get number of roles

	LOGI("%d Roles found.", NumRoles);

	roles = (OMX_U8**) malloc(NumRoles * sizeof(OMX_U8*));
	for (i = 0; i < NumRoles; i++) {
		roles[i] = (OMX_U8*) malloc(OMX_MAX_STRINGNAME_SIZE);
	}

	my_OMX_GetRolesOfComponent("OMX.Nvidia.h264.decode", &NumRoles, roles);

	for (i = 0; i < NumRoles; i++) {
		LOGI("H.264 Decoder Roles:%s\n", roles[i]);
	}
	for (i = 0; i < NumRoles; i++) {
		free(roles[i]);
		roles[i] = NULL;
	}

	free(roles);
	roles = NULL;

	FILE* pVidFile = fopen("/sdcard/out.yuv", "rb");
	LOGI("pVidFile=0x%X", pVidFile);

	my_OMX_GetHandle = (OMX_GetHandle_FPTR) dlsym(hModule, "OMX_GetHandle");

	OMX_CALLBACKTYPE decoder_callbacks = { decoder_event_handler,
			decoder_empty_buffer_done, decoder_fill_buffer_done };

	err = my_OMX_GetHandle(&decoder_handle, "OMX.Nvidia.h264ext.decode", NULL,
			&decoder_callbacks);

	if (err != OMX_ErrorNone) {
		LOGE("GetHandle Fails - [0x%x]\n", err);
		return NULL;
	}

	LOGI("GetHandle ok.");

	// Get the port information. This will obtain information about the number of
	// ports and index of the first port.
	OMX_PORT_PARAM_TYPE port_param;
	setHeader(&port_param, sizeof(port_param));

	err
			= OMX_GetParameter(decoder_handle, OMX_IndexParamVideoInit,
					&port_param);

	if (err != OMX_ErrorNone)
		LOGE("1 OMX_GetParameter on OMX_IndexParamVideoInit failed! [0x%X]",
				err);
	else
		LOGI("1 OMX_GetParameter on OMX_IndexParamVideoInit ok.");

	input_port = port_param.nStartPortNumber;
	output_port = input_port + 1;

	Print_OMX_PORT_PARAM_TYPE(&port_param);

	// Set role for the component because components can have multiple roles.

	// skip it for now (seems like there's only one role in this component)

	// Populate input-buffer-related members based on input port data.
	OMX_PARAM_PORTDEFINITIONTYPE port_format;
	setHeader(&port_format, sizeof(port_format));

	LOGI("-- Before get parameter --");
	Print_OMX_PARAM_PORTDEFINITIONTYPE(&port_format);
	port_format.nPortIndex = input_port + 0;

	err = OMX_GetParameter(decoder_handle, OMX_IndexParamPortDefinition,
			&port_format);

	if (err != OMX_ErrorNone)
		LOGE(
				"2 OMX_GetParameter on OMX_IndexParamPortDefinition port 0 failed! [0x%X]",
				err);
	else
		LOGI("2 OMX_GetParameter on OMX_IndexParamPortDefinition port 0 ok.");

	input_buffer_count = port_format.nBufferCountActual;
	input_buffer_size = port_format.nBufferSize;

	Print_OMX_PARAM_PORTDEFINITIONTYPE(&port_format);

	// Verify output port conforms to our expectations.
	setHeader(&port_format, sizeof(port_format));
	port_format.nPortIndex = output_port;
	err = OMX_GetParameter(decoder_handle, OMX_IndexParamPortDefinition,
			&port_format);

	if (err != OMX_ErrorNone)
		LOGE(
				"3 OMX_GetParameter on OMX_IndexParamPortDefinition port 1 failed! [0x%X]",
				err);
	else
		LOGI("3 OMX_GetParameter on OMX_IndexParamPortDefinition port 1 ok.");

	if (OMX_DirOutput != port_format.eDir) {
		LOGE("Expected output port eDir to be of type, well ... OMX_DirOutput!");
	} else {
		LOGI("Output port eDir is ok.");
	}

	Print_OMX_PARAM_PORTDEFINITIONTYPE(&port_format);

	// Set output port parameters.
	port_format.nBufferCountActual = PICTURE_BUFFERS_NUM_OUTPUT; //it wanted 10 originally, so look at this later as well!
	port_format.nBufferCountMin = PICTURE_BUFFERS_NUM_OUTPUT; //it wanted 10 originally, so look at this later as well!

	if (PICTURE_BUFFERS_NUM_OUTPUT != port_format.nBufferCountMin) {
		LOGE(
				"ERROR - PICTURE_BUFFERS_NUM_OUTPUT != port_format.nBufferCountMin - nBufferCountMin=%d ",
				port_format.nBufferCountMin);
	}

	// Force an OMX_EventPortSettingsChanged event to be sent once we know the
	// stream's real dimensions (which can only happen once some Decode() work has
	// been done).
	port_format.format.video.nFrameWidth = -1;//640;
	port_format.format.video.nFrameHeight = -1;//480;
	//port_format.nBufferSize=640*480*3/2;

	int output_buff_size = port_format.nBufferSize;

	err = OMX_SetParameter(decoder_handle, OMX_IndexParamPortDefinition,
			&port_format);

	if (err != OMX_ErrorNone)
		LOGE(
				"4 OMX_SetParameter on OMX_IndexParamPortDefinition port 1 failed! [0x%X]",
				err);
	else
		LOGI("4 OMX_SetParameter on OMX_IndexParamPortDefinition port 1 ok.");

	// allocate output buffers

	/*
	 LOGI("--- Starting to allocate output buffers --- ");

	 for(i=0;i<PICTURE_BUFFERS_NUM_OUTPUT;++i)
	 {
	 err = OMX_AllocateBuffer(decoder_handle, &g_BuffersOut[i], output_port, NULL, port_format.nBufferSize);
	 if (err!=OMX_ErrorNone)
	 {
	 LOGE("Error on OMX_AllocateBuffer output %d! - Error=%X!!!",i,err);
	 } else
	 {
	 //LOGI("OMX_AllocateBuffer output %d ok.",i);
	 //Print_OMX_BUFFERHEADERTYPE(g_BuffersOut[i]);
	 }

	 buffer_out_mask |= 1<<i;

	 //g_BuffersOut[i]->pPlatformPrivate = count;
	 //*count = i;
	 //count++;


	 //LOGI("buf_out[%d]=%p\n", i, g_BuffersOut[i]);

	 }
	 */

	setHeader(&port_format, sizeof(port_format));
	port_format.nPortIndex = input_port;
	err = OMX_GetParameter(decoder_handle, OMX_IndexParamPortDefinition,
			&port_format);

	if (err != OMX_ErrorNone)
		LOGE(
				"5 OMX_GetParameter on OMX_IndexParamPortDefinition port 0 failed! [0x%X]",
				err);
	else
		LOGI("5 OMX_GetParameter on OMX_IndexParamPortDefinition port 0 ok.");

	LOGI("*** Input port: ***");

	Print_OMX_PARAM_PORTDEFINITIONTYPE(&port_format);

	if (PICTURE_BUFFERS_NUM_INPUT != port_format.nBufferCountMin) {
		LOGE(
				"input port_format.nBufferCountMin != PICTURE_BUFFERS_NUM !! it equals %d",
				port_format.nBufferCountMin);
	}

	/*LOGI("--- Starting to allocate input buffers --- ");

	 for(i=0;i<PICTURE_BUFFERS_NUM_INPUT;++i)
	 {
	 err = OMX_AllocateBuffer(decoder_handle, &g_BuffersIn[i], input_port, NULL, port_format.nBufferSize);

	 if (err!=OMX_ErrorNone)
	 {
	 LOGE("Error on OMX_AllocateBuffer input %d! - Error=%X!!!",i,err);
	 } else
	 {
	 //LOGI("OMX_AllocateBuffer input %d ok.",i);
	 //Print_OMX_BUFFERHEADERTYPE(g_BuffersIn[i]);
	 }


	 buffer_in_mask |= 1<<i;

	 //g_BuffersIn[i]->pPlatformPrivate = count;
	 //*count = i;
	 //count++;

	 LOGI("buf_in[%d]=%p\n", i, g_BuffersIn[i]);

	 }
	 */

	// Fill the component with fake output buffers.  This seems to be required for
	// the component to move from Loaded to Idle.  How bogus.
	for (i = 0; i < PICTURE_BUFFERS_NUM_OUTPUT; ++i) {
		OMX_BUFFERHEADERTYPE* buffer;
		err = OMX_UseBuffer(decoder_handle, &buffer, output_port, NULL, 0,
				(OMX_U8*) (0x1));

		//err = OMX_UseBuffer(decoder_handle, &buffer, output_port,
		//					   NULL, 0, (OMX_U8*)(0x1));

		if (err != OMX_ErrorNone) {
			LOGE("Error on OMX_UseBuffer output %d! - Error=%X!!!", i, err);
		} else {
			LOGI("OMX_UseBuffer output %d ok.", i);
		}

		buffer->pAppPrivate = NULL;
		buffer->nTimeStamp = -1;
		buffer->nOutputPortIndex = output_port;
		//CHECK(fake_output_buffers_.insert(buffer).second);
	}

	//1. add OMX_CommandPortEnable on both ports !!! (needed to move to state idle)
	//2. consider removing the fake use buffer if it's not needed.

	/*LOGI("Activating output port...");

	 err = OMX_SendCommand(decoder_handle, OMX_CommandPortEnable, output_port, 0);
	 if (err!=OMX_ErrorNone)
	 {
	 LOGE("ERROR OMX_SendCommand - OMX_CommandPortEnable Error=%X port=%d!!!",err,output_port);
	 } else
	 {
	 LOGI("OMX_SendCommand OMX_CommandPortEnable ok - port=%d.",output_port);
	 }*/

	/*LOGI("Activating input port...");

	 err = OMX_SendCommand(decoder_handle, OMX_CommandPortEnable, input_port, 0);
	 if (err!=OMX_ErrorNone)
	 {
	 LOGE("ERROR OMX_SendCommand - OMX_CommandPortEnable Error=%X port=%d!!!",err,input_port);
	 } else
	 {
	 LOGI("OMX_SendCommand OMX_CommandPortEnable ok - port=%d.",input_port);
	 }*/

	sleep(2);

	LOGI("Changing State...");
	// change state into OMX_Idle

	Print_CurrentState(decoder_handle);

	err
			= OMX_SendCommand(decoder_handle, OMX_CommandStateSet,
					OMX_StateIdle, 0);
	if (err != OMX_ErrorNone) {
		LOGE("ERROR OMX_SendCommand - OMX_CommandStateSet Error=%X!!!", err);
	} else {
		LOGI("OMX_SendCommand OMX_StateIdle ok.");
	}

	for (i = 0; i < PICTURE_BUFFERS_NUM_INPUT; ++i) {
		OMX_BUFFERHEADERTYPE* buffer;
		// While registering the buffer header we use fake buffer information
		// (length 0, at memory address 0x1) to fake out the "safety" check in
		// OMX_UseBuffer.  When it comes time to actually use this header in Decode
		// we set these fields to their real values (for the duration of that
		// Decode).
		OMX_ERRORTYPE result = OMX_UseBuffer(decoder_handle, &buffer,
				input_port, NULL, /* pAppPrivate gets set in Decode(). */
				0, (OMX_U8*) (0x1));
		if (err != OMX_ErrorNone) {
			LOGE("Error on OMX_UseBuffer input %d! - Error=%X!!!", i, err);
		} else {
			LOGI("OMX_UseBuffer input %d ok.", i);
		}

		buffer->nInputPortIndex = input_port;
		buffer->nOffset = 0;
		buffer->nFlags = 0;
		//free_input_buffers_.push(buffer);
	}

	err = OMX_SendCommand(decoder_handle, OMX_CommandStateSet,
			OMX_StateExecuting, 0);
	if (err != OMX_ErrorNone) {
		LOGE("ERROR OMX_SendCommand - OMX_StateExecuting Error=%X!!!", err);
	} else {
		LOGI("OMX_SendCommand OMX_StateExecuting ok.");
	}

	while (1) {
		Print_CurrentState(decoder_handle);
		sleep(1);
	}

	LOGI("Starting to decode...");

	//for (nt i=0;i<5000)

	int j = 0;

	//while (1)
	for (j = 0; j < 10; j++) {
		LOGI("Itearation (%d)", j);

		// Decode

		OMX_BUFFERHEADERTYPE *buf;

		int read_len;

		for (i = 0; i < PICTURE_BUFFERS_NUM_INPUT; i++) {

			buf = g_BuffersIn[i];

			if (!((1 << i) & buffer_in_mask))
				continue;

			//read_len = read(g_pVidFile, buf->pBuffer, input_buffer_size/4);
			read_len = fread(buf->pBuffer, 1, input_buffer_size, g_pVidFile);
			LOGI("read from file: %d bytes\n", read_len);
			buf->nFilledLen = read_len;

			err = OMX_EmptyThisBuffer(decoder_handle, buf);

			if (err == OMX_ErrorNotReady) {
				LOGI("OMX_EmptyThisBuffer input %d! - Error=OMX_ErrorNotReady",
						i);
			} else if (err != OMX_ErrorNone) {
				LOGE("Error on OMX_EmptyThisBuffer input %d! - Error=%X!!!", i,
						err);
			} else {
				LOGI("OMX_EmptyThisBuffer input %d ok.", i);
				buffer_in_mask &= (1 << i) ^ 0xFFFFFFFF;
			}
		}

		for (i = 0; i < PICTURE_BUFFERS_NUM_OUTPUT; i++) {
			if (!((1 << i) & buffer_out_mask))
				continue;

			err = OMX_FillThisBuffer(decoder_handle, g_BuffersOut[i]);
			if (err == OMX_ErrorNotReady) {
				LOGI("OMX_FillThisBuffer output %d! - Error=OMX_ErrorNotReady",
						i);
			} else if (err != OMX_ErrorNone) {
				LOGE("Error on OMX_FillThisBuffer output %d! - Error=%X!!!", i,
						err);
			} else {
				LOGI("OMX_FillThisBuffer output %d ok.", i);
				buffer_out_mask &= (1 << i) ^ 0xFFFFFFFF;
			}
		}

	}

	return instance;
}