#include <stdio.h>

#include <assert.h>

#include "audio.h"

#include "bcm_host.h"

#include "ilclient.h"

#include "threadlib.h"

#define NUM_SAMPLES 1024

ILCLIENT_T *client;

COMPONENT_T *audio_render;

pthread_t audio_thread;

int scaled_buffer_size(int samples) {

return (samples * 16 * 2) >> 3;

}

uint32_t audio_get_latency() {

OMX_PARAM_U32TYPE param;

OMX_ERRORTYPE error;

memset(&param, 0, sizeof(OMX_PARAM_U32TYPE));

param.nSize = sizeof(OMX_PARAM_U32TYPE);

param.nVersion.nVersion = OMX_VERSION;

param.nPortIndex = 100;

error = OMX_GetConfig(ILC_GET_HANDLE(audio_render), OMX_IndexConfigAudioRenderingLatency, &param);

assert(error == OMX_ErrorNone);

return param.nU32;

}

void* audio_exec(void* udata) {

float buffer_time_us = (float)(1e6 * NUM_SAMPLES) / SAMPLE_FREQ;

while(1) {

/* get a buffer */

OMX_BUFFERHEADERTYPE *hdr;

while((hdr = ilclient_get_input_buffer(audio_render, 100, 0)) == NULL) {

usleep(buffer_time_us / 4); // wait 1/4 of the time to drain a buffer

}

// fill the buffer

audio_fill_buffer((int16_t*)hdr->pBuffer, NUM_SAMPLES * 2);

hdr->nOffset = 0;

hdr->nFilledLen = scaled_buffer_size(NUM_SAMPLES);

// submit the buffer

OMX_ERRORTYPE error;

error = OMX_EmptyThisBuffer(ILC_GET_HANDLE(audio_render), hdr);

assert(error == OMX_ErrorNone);

// drive down the latency to a buffer's length or less

uint32_t latency;

while(audio_get_latency() > NUM_SAMPLES) {

usleep(buffer_time_us / 2);

}

}

}

void native_audio_init() {

OMX_ERRORTYPE error;

OMX_PARAM_PORTDEFINITIONTYPE param;

OMX_AUDIO_PARAM_PCMMODETYPE pcm;

int32_t s;

// create and start up everything

client = ilclient_init();

assert(client != NULL);

error = OMX_Init();

assert(error == OMX_ErrorNone);

ilclient_create_component(client, &audio_render, "audio_render", ILCLIENT_ENABLE_INPUT_BUFFERS | ILCLIENT_DISABLE_ALL_PORTS);

assert(audio_render != NULL);

// set up the number/size of buffers

memset(&param, 0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));

param.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);

param.nVersion.nVersion = OMX_VERSION;

param.nPortIndex = 100;

error = OMX_GetParameter(ILC_GET_HANDLE(audio_render),

OMX_IndexParamPortDefinition, &param);

assert(error == OMX_ErrorNone);

int size = scaled_buffer_size(NUM_SAMPLES);

size = (size + 15) & ~15;

param.nBufferSize = size;

param.nBufferCountActual = 2;

error = OMX_SetParameter(ILC_GET_HANDLE(audio_render),

OMX_IndexParamPortDefinition, &param);

assert(error == OMX_ErrorNone);

// set the pcm parameters

memset(&pcm, 0, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));

pcm.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);

pcm.nVersion.nVersion = OMX_VERSION;

pcm.nPortIndex = 100;

pcm.nChannels = 2;

pcm.eNumData = OMX_NumericalDataSigned;

pcm.eEndian = OMX_EndianLittle;

pcm.nSamplingRate = SAMPLE_FREQ;

pcm.bInterleaved = OMX_TRUE;

pcm.nBitPerSample = 16;

pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;

pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;

pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;

error = OMX_SetParameter(ILC_GET_HANDLE(audio_render), OMX_IndexParamAudioPcm, &pcm);

assert(error == OMX_ErrorNone);

assert(ilclient_change_component_state(audio_render, OMX_StateIdle) == 0);

if(ilclient_enable_port_buffers(audio_render, 100, NULL, NULL, NULL) < 0) {

// error

ilclient_change_component_state(audio_render, OMX_StateLoaded);

COMPONENT_T* list[2];

list[0] = audio_render;

list[1] = 0;

ilclient_cleanup_components(list);

error = OMX_Deinit();

assert(error == OMX_ErrorNone);

ilclient_destroy(client);

exit(-1);

}

assert(ilclient_change_component_state(audio_render, OMX_StateExecuting) == 0);

// set the destination

OMX_CONFIG_BRCMAUDIODESTINATIONTYPE ar_dest;

const char* name = "hdmi";

memset(&ar_dest, 0, sizeof(ar_dest));

ar_dest.nSize = sizeof(OMX_CONFIG_BRCMAUDIODESTINATIONTYPE);

ar_dest.nVersion.nVersion = OMX_VERSION;

strcpy((char *)ar_dest.sName, name);

error = OMX_SetConfig(ILC_GET_HANDLE(audio_render), OMX_IndexConfigBrcmAudioDestination, &ar_dest);

assert(error == OMX_ErrorNone);

// get the buffer flow going

pthread_create(&audio_thread, NULL, audio_exec, NULL);

}