ILCLIENT_T * encode_init(COMPONENT_T **video_encode)
{
ILCLIENT_T *client = ilclient_init();
if (client == NULL)
{
return NULL;
}
if (OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(client);
return NULL;
}
// create video_encode
int omx_return = ilclient_create_component(client, video_encode, "video_encode",
(ILCLIENT_CREATE_FLAGS_T)(ILCLIENT_DISABLE_ALL_PORTS |
ILCLIENT_ENABLE_INPUT_BUFFERS |
ILCLIENT_ENABLE_OUTPUT_BUFFERS));
if (omx_return != 0)
{
fprintf(stderr, "ilclient_create_component() for video_encode failed with %x!\n", omx_return);
ilclient_destroy(client);
return NULL;
}
return client;
}
// this function run the boilerplate to setup the openmax components;
int
setupOpenMaxJpegDecoder(OPENMAX_JPEG_DECODER ** pDecoder)
{
*pDecoder = malloc(sizeof(OPENMAX_JPEG_DECODER));
if (pDecoder[0] == NULL) {
perror("malloc decoder");
return OMXJPEG_ERROR_MEMORY;
}
memset(*pDecoder, 0, sizeof(OPENMAX_JPEG_DECODER));
if ((pDecoder[0]->client = ilclient_init()) == NULL) {
perror("ilclient_init");
return OMXJPEG_ERROR_ILCLIENT_INIT;
}
if (OMX_Init() != OMX_ErrorNone) {
ilclient_destroy(pDecoder[0]->client);
perror("OMX_Init");
return OMXJPEG_ERROR_OMX_INIT;
}
// prepare the image decoder
int ret = prepareImageDecoder(pDecoder[0]);
if (ret != OMXJPEG_OK)
return ret;
ret = prepareResizer(pDecoder[0]);
if (ret != OMXJPEG_OK)
return ret;
ret = startupImageDecoder(pDecoder[0]);
if (ret != OMXJPEG_OK)
return ret;
return OMXJPEG_OK;
}
int32_t ilctts_delete(TTSRENDER_STATE_T *st) {
int32_t ret;
OMX_ERRORTYPE omx_err;
ret = ilclient_change_component_state(st->audio_render, OMX_StateIdle);
if (ret < 0) {
ERROR("ilctts_change_component_state returned error in ilctts_delete: %d", ret);
return -1;
}
omx_err = OMX_SendCommand(ILC_GET_HANDLE(st->audio_render), OMX_CommandStateSet, OMX_StateLoaded, NULL);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_SendCommand returned error in ilctts_delete: %d", omx_err);
return -1;
}
ilclient_disable_port_buffers(st->audio_render, 100, st->user_buffer_list, NULL, NULL);
ilclient_change_component_state(st->audio_render, OMX_StateLoaded);
ilclient_cleanup_components(st->list);
ilclient_destroy(st->client);
//sem_destroy(&st->buffer_list_sema);
destroy_semaphores(st);
destroy_mutexes(st);
free(st);
return 0;
} // end ilctts_delete
void encode_deinit(COMPONENT_T *handle, ILCLIENT_T *client)
{
COMPONENT_T *list[] = {handle , NULL};
ilclient_state_transition(list, OMX_StateIdle);
ilclient_state_transition(list, OMX_StateLoaded);
ilclient_cleanup_components(list);
OMX_Deinit();
ilclient_destroy(client);
}
// Modified function prototype to work with pthreads
void *video_decode_test(void* arg)
{
const char* filename = "/opt/vc/src/hello_pi/hello_video/test.h264";
eglImage = arg;
if (eglImage == 0)
{
printf("eglImage is null.\n");
exit(1);
}
OMX_VIDEO_PARAM_PORTFORMATTYPE format;
OMX_TIME_CONFIG_CLOCKSTATETYPE cstate;
COMPONENT_T *video_decode = NULL, *video_scheduler = NULL, *clock = NULL;
COMPONENT_T *list[5];
TUNNEL_T tunnel[4];
ILCLIENT_T *client;
FILE *in;
int status = 0;
unsigned int data_len = 0;
int packet_size = 80<<10;
memset(list, 0, sizeof(list));
memset(tunnel, 0, sizeof(tunnel));
if((in = fopen(filename, "rb")) == NULL)
return (void *)-2;
if((client = ilclient_init()) == NULL)
{
fclose(in);
return (void *)-3;
}
if(OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(client);
fclose(in);
return (void *)-4;
}
// callback
ilclient_set_fill_buffer_done_callback(client, my_fill_buffer_done, 0);
// create video_decode
if(ilclient_create_component(client, &video_decode, "video_decode", ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_INPUT_BUFFERS) != 0)
status = -14;
list[0] = video_decode;
// create video_render
//if(status == 0 && ilclient_create_component(client, &video_render, "video_render", ILCLIENT_DISABLE_ALL_PORTS) != 0)
if(status == 0 && ilclient_create_component(client, &video_render, "egl_render", ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_OUTPUT_BUFFERS) != 0)
status = -14;
list[1] = video_render;
// create clock
if(status == 0 && ilclient_create_component(client, &clock, "clock", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[2] = clock;
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = 1;
if(clock != NULL && OMX_SetParameter(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeClockState, &cstate) != OMX_ErrorNone)
status = -13;
// create video_scheduler
if(status == 0 && ilclient_create_component(client, &video_scheduler, "video_scheduler", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[3] = video_scheduler;
set_tunnel(tunnel, video_decode, 131, video_scheduler, 10);
//set_tunnel(tunnel+1, video_scheduler, 11, video_render, 90);
set_tunnel(tunnel+1, video_scheduler, 11, video_render, 220);
set_tunnel(tunnel+2, clock, 80, video_scheduler, 12);
// setup clock tunnel first
if(status == 0 && ilclient_setup_tunnel(tunnel+2, 0, 0) != 0)
status = -15;
else
ilclient_change_component_state(clock, OMX_StateExecuting);
if(status == 0)
ilclient_change_component_state(video_decode, OMX_StateIdle);
memset(&format, 0, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
format.nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE);
format.nVersion.nVersion = OMX_VERSION;
format.nPortIndex = 130;
format.eCompressionFormat = OMX_VIDEO_CodingAVC;
if(status == 0 &&
OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamVideoPortFormat, &format) == OMX_ErrorNone &&
ilclient_enable_port_buffers(video_decode, 130, NULL, NULL, NULL) == 0)
{
OMX_BUFFERHEADERTYPE *buf;
int port_settings_changed = 0;
int first_packet = 1;
ilclient_change_component_state(video_decode, OMX_StateExecuting);
while((buf = ilclient_get_input_buffer(video_decode, 130, 1)) != NULL)
{
// feed data and wait until we get port settings changed
unsigned char *dest = buf->pBuffer;
// loop if at end
if (feof(in))
rewind(in);
data_len += fread(dest, 1, packet_size-data_len, in);
if(port_settings_changed == 0 &&
((data_len > 0 && ilclient_remove_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0) ||
(data_len == 0 && ilclient_wait_for_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10000) == 0)))
{
port_settings_changed = 1;
if(ilclient_setup_tunnel(tunnel, 0, 0) != 0)
{
status = -7;
break;
}
ilclient_change_component_state(video_scheduler, OMX_StateExecuting);
// now setup tunnel to video_render
if(ilclient_setup_tunnel(tunnel+1, 0, 1000) != 0)
{
status = -12;
break;
}
// Set egl_render to idle
ilclient_change_component_state(video_render, OMX_StateIdle);
// Enable the output port and tell egl_render to use the texture as a buffer
//ilclient_enable_port(video_render, 221); THIS BLOCKS SO CANT BE USED
if (OMX_SendCommand(ILC_GET_HANDLE(video_render), OMX_CommandPortEnable, 221, NULL) != OMX_ErrorNone)
{
printf("OMX_CommandPortEnable failed.\n");
exit(1);
}
if (OMX_UseEGLImage(ILC_GET_HANDLE(video_render), &eglBuffer, 221, NULL, eglImage) != OMX_ErrorNone)
{
printf("OMX_UseEGLImage failed.\n");
exit(1);
}
// Set egl_render to executing
ilclient_change_component_state(video_render, OMX_StateExecuting);
// Request egl_render to write data to the texture buffer
if(OMX_FillThisBuffer(ILC_GET_HANDLE(video_render), eglBuffer) != OMX_ErrorNone)
{
printf("OMX_FillThisBuffer failed.\n");
exit(1);
}
}
if(!data_len)
break;
buf->nFilledLen = data_len;
data_len = 0;
buf->nOffset = 0;
if(first_packet)
{
buf->nFlags = OMX_BUFFERFLAG_STARTTIME;
first_packet = 0;
}
else
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
{
status = -6;
break;
}
}
buf->nFilledLen = 0;
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN | OMX_BUFFERFLAG_EOS;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
status = -20;
// wait for EOS from render
ilclient_wait_for_event(video_render, OMX_EventBufferFlag, 90, 0, OMX_BUFFERFLAG_EOS, 0,
ILCLIENT_BUFFER_FLAG_EOS, 10000);
// need to flush the renderer to allow video_decode to disable its input port
ilclient_flush_tunnels(tunnel, 0);
ilclient_disable_port_buffers(video_decode, 130, NULL, NULL, NULL);
}
fclose(in);
ilclient_disable_tunnel(tunnel);
ilclient_disable_tunnel(tunnel+1);
ilclient_disable_tunnel(tunnel+2);
ilclient_teardown_tunnels(tunnel);
ilclient_state_transition(list, OMX_StateIdle);
ilclient_state_transition(list, OMX_StateLoaded);
ilclient_cleanup_components(list);
OMX_Deinit();
ilclient_destroy(client);
return (void *)status;
}
// this function cleans up the decoder.
void
cleanup(OPENMAX_JPEG_DECODER * decoder)
{
// flush everything through
OMX_SendCommand(decoder->imageDecoder->handle,
OMX_CommandFlush, decoder->imageDecoder->outPort,
NULL);
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete, OMX_CommandFlush, 0,
decoder->imageDecoder->outPort, 0, 0,
TIMEOUT_MS);
OMX_SendCommand(decoder->imageDecoder->handle, OMX_CommandPortDisable,
decoder->imageDecoder->inPort, NULL);
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete, OMX_CommandPortDisable,
0, decoder->imageDecoder->outPort, 0, 0,
TIMEOUT_MS);
int i = 0;
for (i = 0; i < decoder->inputBufferHeaderCount; i++) {
OMX_BUFFERHEADERTYPE *vpBufHeader =
decoder->ppInputBufferHeader[i];
OMX_FreeBuffer(decoder->imageDecoder->handle,
decoder->imageDecoder->inPort, vpBufHeader);
}
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete, OMX_CommandPortDisable,
0, decoder->imageDecoder->inPort, 0, 0,
TIMEOUT_MS);
OMX_FreeBuffer(decoder->imageDecoder->handle,
decoder->imageDecoder->outPort,
decoder->pOutputBufferHeader);
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete, OMX_CommandPortDisable,
0, decoder->imageDecoder->outPort, 0, 0,
TIMEOUT_MS);
ilclient_change_component_state(decoder->imageDecoder->component,
OMX_StateIdle);
ilclient_change_component_state(decoder->imageDecoder->component,
OMX_StateLoaded);
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventCmdComplete, OMX_CommandStateSet, 0,
OMX_StateLoaded, 0, 0, TIMEOUT_MS);
OMX_Deinit();
if (decoder->client != NULL) {
ilclient_destroy(decoder->client);
}
}
static int video_decode_test(char *filename)
{
OMX_VIDEO_PARAM_PORTFORMATTYPE format;
OMX_TIME_CONFIG_CLOCKSTATETYPE cstate;
COMPONENT_T *video_decode = NULL, *video_scheduler = NULL, *video_render = NULL, *clock = NULL;
COMPONENT_T *list[5];
TUNNEL_T tunnel[4];
ILCLIENT_T *client;
FILE *in;
int status = 0;
unsigned int data_len = 0;
memset(list, 0, sizeof(list));
memset(tunnel, 0, sizeof(tunnel));
if((in = fopen(filename, "rb")) == NULL)
return -2;
if((client = ilclient_init()) == NULL)
{
fclose(in);
return -3;
}
if(OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(client);
fclose(in);
return -4;
}
// create video_decode
if(ilclient_create_component(client, &video_decode, "video_decode", ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_INPUT_BUFFERS) != 0)
status = -14;
list[0] = video_decode;
// create video_render
if(status == 0 && ilclient_create_component(client, &video_render, "video_render", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[1] = video_render;
// create clock
if(status == 0 && ilclient_create_component(client, &clock, "clock", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[2] = clock;
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = 1;
if(clock != NULL && OMX_SetParameter(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeClockState, &cstate) != OMX_ErrorNone)
status = -13;
// create video_scheduler
if(status == 0 && ilclient_create_component(client, &video_scheduler, "video_scheduler", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[3] = video_scheduler;
set_tunnel(tunnel, video_decode, 131, video_scheduler, 10);
set_tunnel(tunnel+1, video_scheduler, 11, video_render, 90);
set_tunnel(tunnel+2, clock, 80, video_scheduler, 12);
// setup clock tunnel first
if(status == 0 && ilclient_setup_tunnel(tunnel+2, 0, 0) != 0)
status = -15;
else
ilclient_change_component_state(clock, OMX_StateExecuting);
if(status == 0)
ilclient_change_component_state(video_decode, OMX_StateIdle);
memset(&format, 0, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
format.nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE);
format.nVersion.nVersion = OMX_VERSION;
format.nPortIndex = 130;
format.eCompressionFormat = OMX_VIDEO_CodingAVC;
if(status == 0 &&
OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamVideoPortFormat, &format) == OMX_ErrorNone &&
ilclient_enable_port_buffers(video_decode, 130, NULL, NULL, NULL) == 0)
{
OMX_BUFFERHEADERTYPE *buf;
int port_settings_changed = 0;
int first_packet = 1;
ilclient_change_component_state(video_decode, OMX_StateExecuting);
while((buf = ilclient_get_input_buffer(video_decode, 130, 1)) != NULL)
{
// feed data and wait until we get port settings changed
unsigned char *dest = buf->pBuffer;
data_len += fread(dest, 1, buf->nAllocLen-data_len, in);
if(port_settings_changed == 0 &&
((data_len > 0 && ilclient_remove_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0) ||
(data_len == 0 && ilclient_wait_for_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10000) == 0)))
{
port_settings_changed = 1;
if(ilclient_setup_tunnel(tunnel, 0, 0) != 0)
{
status = -7;
break;
}
ilclient_change_component_state(video_scheduler, OMX_StateExecuting);
// now setup tunnel to video_render
if(ilclient_setup_tunnel(tunnel+1, 0, 1000) != 0)
{
status = -12;
break;
}
ilclient_change_component_state(video_render, OMX_StateExecuting);
}
if(!data_len)
break;
buf->nFilledLen = data_len;
data_len = 0;
buf->nOffset = 0;
if(first_packet)
{
buf->nFlags = OMX_BUFFERFLAG_STARTTIME;
first_packet = 0;
}
else
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
{
status = -6;
break;
}
}
buf->nFilledLen = 0;
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN | OMX_BUFFERFLAG_EOS;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
status = -20;
// wait for EOS from render
ilclient_wait_for_event(video_render, OMX_EventBufferFlag, 90, 0, OMX_BUFFERFLAG_EOS, 0,
ILCLIENT_BUFFER_FLAG_EOS, 10000);
// need to flush the renderer to allow video_decode to disable its input port
ilclient_flush_tunnels(tunnel, 0);
}
fclose(in);
ilclient_disable_tunnel(tunnel);
ilclient_disable_tunnel(tunnel+1);
ilclient_disable_tunnel(tunnel+2);
ilclient_disable_port_buffers(video_decode, 130, NULL, NULL, NULL);
ilclient_teardown_tunnels(tunnel);
ilclient_state_transition(list, OMX_StateIdle);
ilclient_state_transition(list, OMX_StateLoaded);
ilclient_cleanup_components(list);
OMX_Deinit();
ilclient_destroy(client);
return status;
}
int main(int argc, char **argv)
{
int i;
char *decodeComponentName;
char *renderComponentName;
int err;
ILCLIENT_T *handle;
COMPONENT_T *decodeComponent;
COMPONENT_T *renderComponent;
COMPONENT_T *fxComponent;
int do_deinterlace = 0;
if (argc >= 2)
{
IMG = argv[1];
}
if (argc >= 3)
{
if (strcmp(argv[2],"d")==0)
do_deinterlace = 1;
}
FILE *fp = fopen(IMG, "r");
int toread = get_file_size(IMG);
OMX_BUFFERHEADERTYPE *buff_header;
decodeComponentName = "video_decode";
renderComponentName = "video_render";
bcm_host_init();
handle = ilclient_init();
if (handle == NULL)
{
fprintf(stderr, "IL client init failed\n");
exit(1);
}
if (OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(handle);
fprintf(stderr, "OMX init failed\n");
exit(1);
}
ilclient_set_error_callback(handle,
error_callback,
NULL);
ilclient_set_eos_callback(handle,
eos_callback,
NULL);
setup_decodeComponent(handle, decodeComponentName, &decodeComponent);
setup_renderComponent(handle, renderComponentName, &renderComponent);
if (do_deinterlace)
setup_fxComponent(handle, "image_fx", &fxComponent);
// both components now in Idle state, no buffers, ports disabled
// input port
ilclient_enable_port_buffers(decodeComponent, 130,
NULL, NULL, NULL);
ilclient_enable_port(decodeComponent, 130);
err = ilclient_change_component_state(decodeComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change state to Executing\n");
exit(1);
}
printState(ilclient_get_handle(decodeComponent));
// Read the first block so that the decodeComponent can get
// the dimensions of the video and call port settings
// changed on the output port to configure it
while (toread > 0)
{
buff_header =
ilclient_get_input_buffer(decodeComponent,
130,
1 /* block */);
if (buff_header != NULL)
{
read_into_buffer_and_empty(fp,
decodeComponent,
buff_header,
&toread);
// If all the file has been read in, then
// we have to re-read this first block.
// Broadcom bug?
if (toread <= 0)
{
printf("Rewinding\n");
// wind back to start and repeat
fp = freopen(IMG, "r", fp);
toread = get_file_size(IMG);
}
}
if (toread > 0 && ilclient_remove_event(decodeComponent, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0)
{
printf("Removed port settings event\n");
break;
}
else
{
printf("No port setting seen yet\n");
}
// wait for first input block to set params for output port
if (toread == 0)
{
// wait for first input block to set params for output port
err = ilclient_wait_for_event(decodeComponent,
OMX_EventPortSettingsChanged,
131, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED,
2000);
if (err < 0)
{
fprintf(stderr, "No port settings change\n");
//exit(1);
}
else
{
printf("Port settings changed\n");
break;
}
}
}
// set the decode component to idle and disable its ports
err = ilclient_change_component_state(decodeComponent,
OMX_StateIdle);
if (err < 0)
{
fprintf(stderr, "Couldn't change state to Idle\n");
exit(1);
}
ilclient_disable_port(decodeComponent, 131);
ilclient_disable_port_buffers(decodeComponent, 131,
NULL, NULL, NULL);
if (do_deinterlace)
{
// set up the tunnel between decode and fx ports
err = OMX_SetupTunnel(ilclient_get_handle(decodeComponent),
131,
ilclient_get_handle(fxComponent),
190);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel 1 %X\n", err);
exit(1);
}
else
{
printf("Tunnel 1 set up ok\n");
}
// set up the tunnel between fx and render ports
err = OMX_SetupTunnel(ilclient_get_handle(fxComponent),
191,
ilclient_get_handle(renderComponent),
90);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel 2 %X\n", err);
exit(1);
}
else
{
printf("Tunnel 2 set up ok\n");
}
}
else
{
// set up the tunnel between decode and render ports
err = OMX_SetupTunnel(ilclient_get_handle(decodeComponent),
131,
ilclient_get_handle(renderComponent),
90);
if (err != OMX_ErrorNone)
{
fprintf(stderr, "Error setting up tunnel %X\n", err);
exit(1);
}
else
{
printf("Tunnel set up ok\n");
}
}
// Okay to go back to processing data
// enable the decode output ports
//UNNECESSARY?? PGB OMX_SendCommand(ilclient_get_handle(decodeComponent),
//UNNECESSARY?? PGB OMX_CommandPortEnable, 131, NULL);
ilclient_enable_port(decodeComponent, 131);
if (do_deinterlace)
{
setup_shared_buffer_format(decodeComponent, 131, fxComponent, 191);
// enable fx ports
ilclient_enable_port(fxComponent, 190);
ilclient_enable_port(fxComponent, 191);
//UNNECESSARY?? PGB OMX_SendCommand(ilclient_get_handle(renderComponent),
//UNNECESSARY?? PGB OMX_CommandPortEnable, 90, NULL);
// setup_shared_buffer_format(fxComponent, renderComponent);
}
// enable the render output ports
ilclient_enable_port(renderComponent, 90);
// set all components to executing state
err = ilclient_change_component_state(decodeComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change decode to Executing\n");
exit(1);
}
if (do_deinterlace)
{
err = ilclient_change_component_state(fxComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change fx to Executing\n");
exit(1);
}
}
err = ilclient_change_component_state(renderComponent,
OMX_StateExecuting);
if (err < 0)
{
fprintf(stderr, "Couldn't change render to Executing\n");
exit(1);
}
print_port_info(ilclient_get_handle(decodeComponent), 131);
if (do_deinterlace)
{
print_port_info(ilclient_get_handle(fxComponent), 190);
print_port_info(ilclient_get_handle(fxComponent), 191);
}
print_port_info(ilclient_get_handle(renderComponent), 90);
// now work through the file
while (toread > 0)
{
OMX_ERRORTYPE r;
// do we have a decode input buffer we can fill and empty?
buff_header =
ilclient_get_input_buffer(decodeComponent,
130,
1 /* block */);
if (buff_header != NULL)
{
read_into_buffer_and_empty(fp,
decodeComponent,
buff_header,
&toread);
}
usleep(100000);
// print_port_info(ilclient_get_handle(renderComponent), 90);
}
ilclient_wait_for_event(renderComponent,
OMX_EventBufferFlag,
90, 0, OMX_BUFFERFLAG_EOS, 0,
ILCLIENT_BUFFER_FLAG_EOS, 10000);
printf("EOS on render\n");
sleep(100);
exit(0);
}
static int brcm_omx_vc03_stop(void)
{
OMX_ERRORTYPE error;
//check if done?
if (client==NULL)
return 0;
DEBUG("\n %lx:brcm_omx_vc03_stop\n",jiffies);
// cleanup
// playback stuff
if (play_init)
{
ilclient_change_component_state(&st_play, OMX_StateIdle);
error = OMX_SendCommand(st_play.comp, OMX_CommandStateSet, OMX_StateLoaded, NULL);
ERROR_RETURN("OMX_SendCommand",error);
if (st_play.out_list)
{
DEBUG("\n OMX_FreeBuffer=%x %x\n",(int)st_play.out_list,(int)st_play.out_list->pAppPrivate);
error = OMX_FreeBuffer(st_play.comp, 100, st_play.out_list);
ERROR_RETURN("OMX_FreeBuffer",error);
}
ilclient_cleanup_components(list_play);
play_init=0;
}
// record stuff
if (recd_init)
{
ilclient_change_component_state(&st_recd, OMX_StateIdle);
error = OMX_SendCommand(st_recd.comp, OMX_CommandStateSet, OMX_StateLoaded, NULL);
ERROR_RETURN("OMX_SendCommand",error);
while (st_recd.out_list)
{
OMX_BUFFERHEADERTYPE *next = st_recd.out_list->pAppPrivate;
DEBUG("\n OMX_FreeBuffer=%x %x\n",(int)st_recd.out_list,(int)st_recd.out_list->pAppPrivate);
error = OMX_FreeBuffer(st_recd.comp, 180, st_recd.out_list);
ERROR_RETURN("OMX_FreeBuffer",error);
st_recd.out_list = next;
}
ilclient_cleanup_components(list_recd);
recd_init=0;
}
//
//
error = OMX_Deinit();
ERROR_RETURN("OMX_Deinit",error);
//
ilclient_destroy(client);
client=NULL;
//
return 0;
}
static int image_decode_test(char *filename)
{
OMX_BUFFERHEADERTYPE *pIbuf;
int bytes_read;
int status = 0, ret;
int port_settings_changed = 0;
OMX_IMAGE_PARAM_PORTFORMATTYPE imagePortFormat;
COMPONENT_T *image_decode = NULL;
COMPONENT_T *video_render = NULL;
COMPONENT_T *list[3];
TUNNEL_T tunnel[2];
ILCLIENT_T *client;
FILE *fin;
memset(list, 0, sizeof(list));
memset(tunnel, 0, sizeof(tunnel));
if((fin = fopen(filename, "rb")) == NULL ) {
perror(filename);
return -1;
}
if((client = ilclient_init()) == NULL) {
return -3;
}
if(OMX_Init() != OMX_ErrorNone) {
ilclient_destroy(client);
fclose(fin);
return -4;
}
#if 0 //this was an attempt to use the image_read component
COMPONENT_T *image_read;
// create image_read
if(ilclient_create_component(client, &image_read, "image_read",
ILCLIENT_DISABLE_ALL_PORTS ) != 0)
status = -14;
//set URI
OMX_PARAM_CONTENTURITYPE *pUri;
sz = sizeof(pUri)+strlen(filename);
pUri = (OMX_PARAM_CONTENTURITYPE*)calloc(1, sz);
pUri->nSize = sz;
pUri->nVersion.nVersion = OMX_VERSION;
strcpy(pUri->contentURI, filename);
if(image_read != NULL && OMX_SetParameter(ILC_GET_HANDLE(image_read), OMX_IndexParamContentURI, pUri) != 0)
status = -17;
//enable port
ilclient_enable_port(image_read, 310);
//get OMX_IndexParamPortDefinition
{
OMX_PARAM_PORTDEFINITIONTYPE portDef;
portDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portDef.nVersion.nVersion = OMX_VERSION;
portDef.nPortIndex = 310;
ret = OMX_GetParameter(ILC_GET_HANDLE(image_read), OMX_IndexParamPortDefinition, &portDef);
}
//get OMX_IndexParamImagePortFormat
i=0;
while(ret == 0) {
OMX_IMAGE_PARAM_PORTFORMATTYPE portFormat;
portFormat.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE);
portFormat.nVersion.nVersion = OMX_VERSION;
portFormat.nPortIndex = 310;
portFormat.nIndex = i;
ret = OMX_GetParameter(ILC_GET_HANDLE(image_read), OMX_IndexParamImagePortFormat, &portFormat);
i++;
}
{
OMX_IMAGE_PARAM_PORTFORMATTYPE portFormat;
portFormat.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE);
portFormat.nVersion.nVersion = OMX_VERSION;
portFormat.nPortIndex = 310;
portFormat.eCompressionFormat = OMX_IMAGE_CodingJPEG;
ret = OMX_SetParameter(ILC_GET_HANDLE(image_read), OMX_IndexParamImagePortFormat, &portFormat);
}
if((ret = ilclient_change_component_state(image_read, OMX_StateIdle) < 0)) //this fails
printf("Cannot change image_read component state to OMX_StateIdle\n");
#endif //image_read attempt
// create image_decode
ret = ilclient_create_component(client, &image_decode, "image_decode",
ILCLIENT_DISABLE_ALL_PORTS |
ILCLIENT_ENABLE_INPUT_BUFFERS );
if (ret != 0)
status = -15;
list[0] = image_decode;
// create video_render
ret = ilclient_create_component(client, &video_render, "video_render",
ILCLIENT_DISABLE_ALL_PORTS);
if (ret != 0)
status = -14;
list[1] = video_render;
list[2] = NULL;
ret = ilclient_change_component_state(image_decode, OMX_StateIdle);
set_tunnel(tunnel, image_decode, 321, video_render, 90);
#if 0 //not necessary
{
//get OMX_IndexParamPortDefinition
OMX_PARAM_PORTDEFINITIONTYPE portDef;
portDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portDef.nVersion.nVersion = OMX_VERSION;
portDef.nPortIndex = 320;
ret = OMX_GetParameter(ILC_GET_HANDLE(image_decode), OMX_IndexParamPortDefinition, &portDef);
}
#endif
{
// OMX_IndexParamImagePortFormat
imagePortFormat.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE);
imagePortFormat.nVersion.nVersion = OMX_VERSION;
imagePortFormat.nPortIndex = 320;
imagePortFormat.eCompressionFormat = OMX_IMAGE_CodingJPEG;
// imagePortFormat.eCompressionFormat = OMX_IMAGE_CodingPNG; //does not seem to work
// imagePortFormat.eCompressionFormat = OMX_IMAGE_CodingAutoDetect; //does not seem to work.
ret = OMX_SetParameter(ILC_GET_HANDLE(image_decode), OMX_IndexParamImagePortFormat, &imagePortFormat);
}
ret = ilclient_enable_port_buffers(image_decode, 320, NULL, NULL, NULL);
ret = ilclient_change_component_state(image_decode, OMX_StateExecuting);
while( (pIbuf = ilclient_get_input_buffer(image_decode, 320, 1)) != NULL ) {
bytes_read = fread(pIbuf->pBuffer, 1, pIbuf->nAllocLen, fin);
if( port_settings_changed == 0 &&
(( bytes_read > 0 && ilclient_remove_event(image_decode, OMX_EventPortSettingsChanged, 321, 0, 0, 1) == 0) ||
( bytes_read == 0 && ilclient_wait_for_event(image_decode, OMX_EventPortSettingsChanged, 321, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10000) == 0)))
{
port_settings_changed = 1;
if(ilclient_setup_tunnel(tunnel, 0, 0) != 0)
{
status = -7;
break;
}
ilclient_change_component_state(video_render, OMX_StateExecuting);
}
if(!bytes_read)
break;
pIbuf->nFilledLen = bytes_read;
pIbuf->nOffset = 0;
pIbuf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(image_decode), pIbuf) != OMX_ErrorNone)
{
status = -6;
break;
}
}
pIbuf->nFilledLen = 0;
pIbuf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN | OMX_BUFFERFLAG_EOS;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(image_decode), pIbuf) != OMX_ErrorNone)
status = -20;
// wait for EOS from render
ilclient_wait_for_event(video_render, OMX_EventBufferFlag, 90, 0, OMX_BUFFERFLAG_EOS, 0,
ILCLIENT_BUFFER_FLAG_EOS, 10000);
printf("Press ENTER to continue...\n");
fflush(stdout);
getchar();
// need to flush the renderer to allow video_decode to disable its input port
// ilclient_flush_tunnels(tunnel, 0);
ilclient_disable_port_buffers(image_decode, 320, NULL, NULL, NULL);
fclose(fin);
ilclient_disable_tunnel(tunnel);
ilclient_teardown_tunnels(tunnel);
ret = ilclient_change_component_state(image_decode, OMX_StateIdle);
ret = ilclient_change_component_state(image_decode, OMX_StateLoaded);
ilclient_cleanup_components(list);
OMX_Deinit();
ilclient_destroy(client);
return status;
}
// Modified function prototype to work with pthreads
void *video_decode_test(void* arg)
{
pthread_mutex_init(&m_lock, NULL);
printf("OMX version : %d.%d.%d-%d\n",OMX_VERSION_MAJOR, OMX_VERSION_MINOR, OMX_VERSION_REVISION, OMX_VERSION_STEP);
printf("file to read : %s\n", filename);
eglImage = arg;
if (eglImage == 0)
{
printf("eglImage is null.\n");
exit(1);
}
int status = 0;
unsigned int data_len = 0;
int packet_size = 80<<10;
memset(list, 0, sizeof(list));
memset(tunnel, 0, sizeof(tunnel));
if((in = fopen(filename, "rb")) == NULL)
return (void *)-2;
if((client = ilclient_init()) == NULL)
{
fclose(in);
return (void *)-3;
}
if(OMX_Init() != OMX_ErrorNone)
{
ilclient_destroy(client);
fclose(in);
return (void *)-4;
}
// callback
ilclient_set_fill_buffer_done_callback(client, my_fill_buffer_done, 0);
// create video_decode
if(ilclient_create_component(client, &video_decode, "video_decode", ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_INPUT_BUFFERS) != 0)
status = -14;
list[0] = video_decode;
// create video_render
//if(status == 0 && ilclient_create_component(client, &video_render, "video_render", ILCLIENT_DISABLE_ALL_PORTS) != 0)
if(status == 0 && ilclient_create_component(client, &video_render, "egl_render", ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_OUTPUT_BUFFERS) != 0)
status = -14;
list[1] = video_render;
// create clock
if(status == 0 && ilclient_create_component(client, &omx_clock, "clock", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[2] = omx_clock;
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = 1;
if(omx_clock != NULL && OMX_SetParameter(ILC_GET_HANDLE(omx_clock), OMX_IndexConfigTimeClockState, &cstate) != OMX_ErrorNone)
status = -13;
// set the clock refenrece to "none"
memset(&cref,0,sizeof(cref));
cref.nSize = sizeof(cref);
cref.nVersion.nVersion = OMX_VERSION;
cref.eClock = OMX_TIME_RefClockNone;
if(omx_clock != NULL && OMX_SetParameter(ILC_GET_HANDLE(omx_clock), OMX_IndexConfigTimeActiveRefClock, &cref) != OMX_ErrorNone){
status = -13;
printf("error setting refclock\n");
}
// create video_scheduler
if(status == 0 && ilclient_create_component(client, &video_scheduler, "video_scheduler", ILCLIENT_DISABLE_ALL_PORTS) != 0)
status = -14;
list[3] = video_scheduler;
set_tunnel(tunnel, video_decode, 131, video_scheduler, 10);
//set_tunnel(tunnel+1, video_scheduler, 11, video_render, 90);
set_tunnel(tunnel+1, video_scheduler, 11, video_render, 220);
set_tunnel(tunnel+2, omx_clock, 80, video_scheduler, 12);
// setup clock tunnel first
if(status == 0 && ilclient_setup_tunnel(tunnel+2, 0, 0) != 0)
status = -15;
else
ilclient_change_component_state(omx_clock, OMX_StateExecuting);
if(status == 0)
ilclient_change_component_state(video_decode, OMX_StateIdle);
memset(&format, 0, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
format.nSize = sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE);
format.nVersion.nVersion = OMX_VERSION;
format.nPortIndex = 130;
format.eCompressionFormat = OMX_VIDEO_CodingAVC;
if(status == 0 &&
OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamVideoPortFormat, &format) == OMX_ErrorNone &&
ilclient_enable_port_buffers(video_decode, 130, NULL, NULL, NULL) == 0)
{
OMX_BUFFERHEADERTYPE *buf;
int port_settings_changed = 0;
int first_packet = 1;
ilclient_change_component_state(video_decode, OMX_StateExecuting);
while((buf = ilclient_get_input_buffer(video_decode, 130, 1)) != NULL && stop_flag==0 )
{
// feed data and wait until we get port settings changed
unsigned char *dest = buf->pBuffer;
// loop if at end
if (feof(in))
rewind(in);
data_len += fread(dest, 1, packet_size-data_len, in);
if(port_settings_changed == 0 &&
((data_len > 0 && ilclient_remove_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0) ||
(data_len == 0 && ilclient_wait_for_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10000) == 0)))
{
port_settings_changed = 1;
if(ilclient_setup_tunnel(tunnel, 0, 0) != 0)
{
status = -7;
break;
}
ilclient_change_component_state(video_scheduler, OMX_StateExecuting);
// now setup tunnel to video_render
if(ilclient_setup_tunnel(tunnel+1, 0, 1000) != 0)
{
status = -12;
break;
}
// Set egl_render to idle
ilclient_change_component_state(video_render, OMX_StateIdle);
// Enable the output port and tell egl_render to use the texture as a buffer
//ilclient_enable_port(video_render, 221); THIS BLOCKS SO CANT BE USED
if (OMX_SendCommand(ILC_GET_HANDLE(video_render), OMX_CommandPortEnable, 221, NULL) != OMX_ErrorNone)
{
printf("OMX_CommandPortEnable failed.\n");
exit(1);
}
if (OMX_UseEGLImage(ILC_GET_HANDLE(video_render), &eglBuffer, 221, NULL, eglImage) != OMX_ErrorNone)
{
printf("OMX_UseEGLImage failed.\n");
exit(1);
}
// Set egl_render to executing
ilclient_change_component_state(video_render, OMX_StateExecuting);
// Request egl_render to write data to the texture buffer
if(OMX_FillThisBuffer(ILC_GET_HANDLE(video_render), eglBuffer) != OMX_ErrorNone)
{
printf("OMX_FillThisBuffer failed.\n");
//~ exit(1);
}
}
if(!data_len)
break;
buf->nFilledLen = data_len;
data_len = 0;
buf->nOffset = 0;
if(first_packet)
{
buf->nFlags = OMX_BUFFERFLAG_STARTTIME;
first_packet = 0;
}
else
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
{
status = -6;
break;
}
}
printf("loop ends, now flush the buffer\n");
OMX_SendCommand(ILC_GET_HANDLE(video_decode),OMX_CommandFlush,130,NULL);
OMX_SendCommand(ILC_GET_HANDLE(video_decode),OMX_CommandFlush,131,NULL);
ilclient_wait_for_event(video_decode, OMX_EventCmdComplete, OMX_CommandFlush, 0, 130, 0, ILCLIENT_PORT_FLUSH, -1);
ilclient_wait_for_event(video_decode, OMX_EventCmdComplete, OMX_CommandFlush, 0, 131, 0, ILCLIENT_PORT_FLUSH, -1);
data_len=0;
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateStopped;
cstate.nWaitMask = 1;
OMX_SetParameter(ILC_GET_HANDLE(omx_clock), OMX_IndexConfigTimeClockState, &cstate);
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = 1;
OMX_SetParameter(ILC_GET_HANDLE(omx_clock), OMX_IndexConfigTimeClockState, &cstate);
//~ scheduler should be stopped...
buf->nFilledLen = 0;
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN | OMX_BUFFERFLAG_EOS;
if(OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone)
status = -20;
// wait for EOS from render
//~ printf("wait for EOS from render\n");
//~ ilclient_wait_for_event(video_render, OMX_EventBufferFlag, 90, 0, OMX_BUFFERFLAG_EOS, 0,
//~ ILCLIENT_BUFFER_FLAG_EOS, 10000);
while ((ilclient_remove_event(video_render, OMX_EventBufferFlag, 90, 0, OMX_BUFFERFLAG_EOS, 0) <0 ) && !stop_flag){
}
printf("flush the render\n");
// need to flush the renderer to allow video_decode to disable its input port
ilclient_flush_tunnels(tunnel, 0);
ilclient_disable_port_buffers(video_decode, 130, NULL, NULL, NULL);
}
printf("close file\n");
fclose(in);
ilclient_disable_tunnel(tunnel);
ilclient_disable_tunnel(tunnel+1);
ilclient_disable_tunnel(tunnel+2);
ilclient_teardown_tunnels(tunnel);
ilclient_state_transition(list, OMX_StateIdle);
ilclient_state_transition(list, OMX_StateLoaded);
ilclient_cleanup_components(list);
OMX_Deinit();
ilclient_destroy(client);
printf("thread will return...\n");
pthread_mutex_destroy(&m_lock);
return (void *)status;
}
/* -------------------------------------------------
/ audioplay_create()
/ Create audio decoder & render & other hardware component
/---------------------------------------------------*/
static INT32 audioplay_create(
AUDIOPLAY_STATE_T **handle,
UINT32 sample_rate,
UINT32 num_channels,
UINT32 bit_depth,
UINT32 num_buffers, ///< 100
UINT32 buffer_size ///< 480*(16/8)*2 = 1920
){
OMX_AUDIO_PARAM_PCMMODETYPE pcm;
UINT32 bytes_per_sample = (bit_depth * num_channels) >> 3;
INT32 ret = -1;
int rv;
*handle = NULL;
/* TODO basic sanity check on arguments */
if(sample_rate >= 8000 && sample_rate <= 96000 &&
(num_channels == 1 || num_channels == 2 || num_channels == 4 || num_channels == 8) &&
(bit_depth == 16 || bit_depth == 32) &&
(num_buffers > 0) &&
(buffer_size >= bytes_per_sample)){
/* TODO buffer length must be 16 bytes aligned for VCHI */
int size = (buffer_size + 15) & ~15;
/* TODO buffer length must be 16 bytes aligned for VCHI */
st = calloc(1, sizeof(AUDIOPLAY_STATE_T));
assert(st != NULL);
OMX_ERRORTYPE error;
OMX_PARAM_PORTDEFINITIONTYPE param;
INT32 s;
ret = 0;
/* TODO combine with st = calloc()?*/
*handle = st;
/* create and start up audio codec hardware component */
/* TODO semaphore */
s = sem_init(&st->sema, 0 ,1);
assert(s == 0);
st->bytes_per_sample = bytes_per_sample;
st->num_buffers = num_buffers;
st->client = ilclient_init();
assert(st->client != NULL);
/*TODO input_buffer_callback*/
ilclient_set_empty_buffer_done_callback(st->client, input_buffer_callback, st);
error = OMX_Init();
assert(error == OMX_ErrorNone);
/* Create audio render */
ilclient_create_component(st->client,
&(st->audio_render),
"audio_render",
ILCLIENT_ENABLE_INPUT_BUFFERS | ILCLIENT_DISABLE_ALL_PORTS);
assert(st->audio_render != NULL);
st->list[0] = st->audio_render;
/* Create clock component */
ilclient_create_component(st->client,
&(st->clock),
"clock",
ILCLIENT_DISABLE_ALL_PORTS);
assert(st->clock != NULL);
st->list[1] = st->clock;
/* Configure clock */
OMX_TIME_CONFIG_CLOCKSTATETYPE cstate;
memset(&cstate, 0, sizeof(cstate));
cstate.nSize = sizeof(cstate);
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = 1; //TODO
error = OMX_SetParameter(ILC_GET_HANDLE(st->clock),
OMX_IndexConfigTimeClockState,
&cstate);
assert(error == 0);
/* Setup tunnel to connect clock and audio render */
set_tunnel(&st->tunnel, st->clock, 80, st->audio_render, 101);
rv = ilclient_setup_tunnel(&st->tunnel, 0, 0);
assert(rv == 0);
/* kick off clock */
ilclient_change_component_state(st->clock, OMX_StateExecuting);
/* Set audio render port definition */
/* Set up the number/size of buffers */
memset(¶m, 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(st->audio_render), OMX_IndexParamPortDefinition, ¶m);
assert(error == OMX_ErrorNone);
param.nBufferSize = size;
param.nBufferCountActual = num_buffers;
error = OMX_SetParameter(ILC_GET_HANDLE(st->audio_render), OMX_IndexParamPortDefinition, ¶m);
assert(error == OMX_ErrorNone);
/* Set audio render PCM definition */
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 = num_channels;
pcm.eNumData = OMX_NumericalDataSigned; //TODO
pcm.eEndian = OMX_EndianLittle;
pcm.nSamplingRate = sample_rate;
pcm.bInterleaved = OMX_TRUE;
pcm.nBitPerSample = bit_depth;
pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
switch(num_channels){
case 1:
{
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelCF;
break;
}
case 8:
{ /*TODO*/
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
pcm.eChannelMapping[2] = OMX_AUDIO_ChannelCF;
pcm.eChannelMapping[3] = OMX_AUDIO_ChannelLFE;
pcm.eChannelMapping[4] = OMX_AUDIO_ChannelLR;
pcm.eChannelMapping[5] = OMX_AUDIO_ChannelRR;
pcm.eChannelMapping[6] = OMX_AUDIO_ChannelLS;
pcm.eChannelMapping[7] = OMX_AUDIO_ChannelRS;
break;
}
case 4:
{
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
pcm.eChannelMapping[2] = OMX_AUDIO_ChannelLR;
pcm.eChannelMapping[3] = OMX_AUDIO_ChannelRR;
break;
}
case 2:
{
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
break;
}
}
error = OMX_SetParameter(ILC_GET_HANDLE(st->audio_render),
OMX_IndexParamAudioPcm,
&pcm);
assert(error == OMX_ErrorNone);
/* Set audio reference clock */
OMX_CONFIG_BOOLEANTYPE ref_clock;
memset(&ref_clock, 0, sizeof(OMX_CONFIG_BOOLEANTYPE));
param.nSize = sizeof(OMX_CONFIG_BOOLEANTYPE);
param.nVersion.nVersion = OMX_VERSION;
param.bEnabled = OMX_FALSE;
error = OMX_SetConfig(ILC_GET_HANDLE(st->audio_render),
OMX_IndexConfigBrcmClockReferenceSource,
&ref_clock);
assert(error == OMX_ErrorNone);
/* Enable audio render */
ilclient_change_component_state(st->audio_render, OMX_StateIdle);
if(ilclient_enable_port_buffers(st->audio_render, 100, NULL, NULL, NULL) < 0){
/* Error situation */
ilclient_change_component_state(st->audio_render, OMX_StateLoaded);
ilclient_cleanup_components(st->list);
error = OMX_Deinit();
assert(error == OMX_ErrorNone);
ilclient_destroy(st->client);
sem_destroy(&st->sema);
free(st);
*handle = NULL;
return -1;
}
ilclient_change_component_state(st->audio_render, OMX_StateExecuting);
}
return ret;
}
int32_t ilctts_create(
TTSRENDER_STATE_T **component,
uint32_t sample_rate,
uint32_t num_channels,
uint32_t bit_depth,
uint32_t num_buffers,
uint32_t buffer_size_ms,
BUFFER_SIZE_TYPE_T buffer_size_type,
uint32_t ringbuffer_length
)
{
ENTER(LOGLEVEL_1, "ilctts_create");
SHOW(LOGLEVEL_5, "Sample rate: %d", sample_rate);
SHOW(LOGLEVEL_5, "Number of channels: %d", num_channels);
SHOW(LOGLEVEL_5, "Bit depth: %d", bit_depth);
SHOW(LOGLEVEL_5, "Number of buffers: %d", num_buffers);
SHOW(LOGLEVEL_5, "Buffer size: %d", buffer_size_ms);
SHOW(LOGLEVEL_5, "Ring buffer length: %d", ringbuffer_length);
int32_t ret;
uint32_t buffer_size;
OMX_ERRORTYPE omx_err;
TTSRENDER_STATE_T *st;
*component = NULL;
st = calloc(1, sizeof(TTSRENDER_STATE_T));
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_AUDIO_PARAM_PCMMODETYPE pcm;
int32_t s;
*component = st;
// create and start up everything
// initialise buffer list semaphore
s = sem_init(&st->buffer_list_sema, 0, 1);
if (s < 0) {
ERROR("sem_init returned error initializing buffer list semaphore in ilctts_create: %d", s);
return -1;
}
// initial value of ringbuffer_empty_sema is 1 because at startup there is space
s = sem_init(&st->ringbuffer_empty_sema, 0, 1);
if (s < 0) {
ERROR("sem_init returned error initializing ringbuffer_empty_sema in ilctts_create: %d", s);
return -1;
}
// initial value of ringbuffer_data_sema is 0 because at startup there is no data
s = sem_init(&st->ringbuffer_data_sema, 0, 0);
if (s < 0) {
ERROR("sem_init returned error initializing ringbuffer_data_sema in ilctts_create: %d", s);
return -1;
}
// free_buffer mutex and cv
pthread_mutex_init(&st->free_buffer_mutex, NULL);
pthread_cond_init(&st->free_buffer_cv, NULL);
// ringbuffer mutex
pthread_mutex_init(&st->ringbuffer_mutex, NULL);
//pthread_cond_init(&st->ringbuffer_cv, NULL);
st->sample_rate = sample_rate;
st->num_channels = num_channels;
st->bit_depth = bit_depth;
st->bytes_per_sample = (bit_depth * OUT_CHANNELS(num_channels)) >> 3;
if (buffer_size_type == BS_MILLISECONDS) {
// supplied buffer size was in milliseconds, calculate the byte size
// note: calc_buffer_size_from_ms returns buffer size aligned for VCHI
buffer_size = calc_buffer_size_from_ms(sample_rate, bit_depth, num_channels, buffer_size_ms, 1);
} else {
// supplied buffer size was in bytes
// buffer size must be 16 byte aligned for VCHI
buffer_size = (buffer_size_ms + 15) & ~15;
}
SHOW(LOGLEVEL_5, "Bytes per sample: %d", st->bytes_per_sample);
SHOW(LOGLEVEL_5, "Calculated buffer size: %d", buffer_size);
st->num_buffers = num_buffers;
st->client = ilclient_init();
st->tts_stop = 0;
st->tts_pause_state = TTS_PAUSE_OFF;
st->ringbuffer = ringbuffer_init(ringbuffer_length);
if (st->ringbuffer == NULL) {
ERROR("ringbuffer_init failed in ilctts_create", "");
return -1;
}
// set up callbacks
ilclient_set_empty_buffer_done_callback(st->client, input_buffer_callback, st);
//ilclient_set_configchanged_callback(st->client, config_changed_callback, st);
//ilclient_set_port_settings_callback(st->client, port_settings_changed_callback, st);
ret = ilclient_create_component(st->client, &st->audio_render, "audio_render", ILCLIENT_ENABLE_INPUT_BUFFERS | ILCLIENT_DISABLE_ALL_PORTS);
if (ret == -1) {
ERROR("ilclcient_create_component returned error in ilctts_create: %d", ret);
return ret;
}
st->list[0] = st->audio_render;
// set up the number/size of buffers
OMX_INIT_STRUCTURE(param);
param.nPortIndex = 100;
omx_err = OMX_GetParameter(ILC_GET_HANDLE(st->audio_render), OMX_IndexParamPortDefinition, ¶m);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_GetParameter returned error in ilctts_create: %d", omx_err);
return -1;
}
// set the buffer size to the requested size, or the minimum size returned, whichever is greater
st->buffer_size = max(buffer_size, param.nBufferSize);
SHOW(LOGLEVEL_3, "Buffer size set to: %d", st->buffer_size);
param.nBufferSize = st->buffer_size;
param.nBufferCountActual = max(st->buffer_count, param.nBufferCountMin);
omx_err = OMX_SetParameter(ILC_GET_HANDLE(st->audio_render), OMX_IndexParamPortDefinition, ¶m);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_SetParameter returned error in ilctts_create: %d", omx_err);
return -1;
}
// set the pcm parameters
OMX_INIT_STRUCTURE(pcm);
pcm.nPortIndex = 100;
pcm.nChannels = OUT_CHANNELS(num_channels);
pcm.eNumData = OMX_NumericalDataSigned;
pcm.eEndian = OMX_EndianLittle;
pcm.nSamplingRate = sample_rate;
pcm.bInterleaved = OMX_TRUE;
pcm.nBitPerSample = bit_depth;
pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
switch(st->num_channels) {
case 1:
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelCF;
break;
case 3:
pcm.eChannelMapping[2] = OMX_AUDIO_ChannelCF;
pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
break;
case 8:
pcm.eChannelMapping[7] = OMX_AUDIO_ChannelRS;
case 7:
pcm.eChannelMapping[6] = OMX_AUDIO_ChannelLS;
case 6:
pcm.eChannelMapping[5] = OMX_AUDIO_ChannelRR;
case 5:
pcm.eChannelMapping[4] = OMX_AUDIO_ChannelLR;
case 4:
pcm.eChannelMapping[3] = OMX_AUDIO_ChannelLFE;
pcm.eChannelMapping[2] = OMX_AUDIO_ChannelCF;
case 2:
pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
break;
}
omx_err = OMX_SetParameter(ILC_GET_HANDLE(st->audio_render), OMX_IndexParamAudioPcm, &pcm);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_SetParameter returned error in ilctts_create: %d", omx_err);
return -1;
}
// this function waits for the command to complete
ret = ilclient_change_component_state(st->audio_render, OMX_StateIdle);
if (ret < 0) {
ERROR("ilctts_change_component_state returned error in ilctts_create: %d", ret);
return -1;
}
ret = ilclient_enable_port_buffers(st->audio_render, 100, NULL, NULL, NULL);
if (ret < 0) {
ERROR("ilclient_enable_port_buffers returned error in ilctts_create: %d", ret);
ilclient_change_component_state(st->audio_render, OMX_StateLoaded);
ilclient_cleanup_components(st->list);
omx_err = OMX_Deinit();
ilclient_destroy(st->client);
destroy_semaphores(st);
destroy_mutexes(st);
ringbuffer_destroy(st->ringbuffer);
// need to destroy and free other stuff here?
free(st);
*component = NULL;
return -1;
}
INFO(LOGLEVEL_1, "Setting state to executing in ilctts_create");
return ilclient_change_component_state(st->audio_render, OMX_StateExecuting);
} // end ilctts_create
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(¶m, 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, ¶m);
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, ¶m);
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);
}
