#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;
}