// 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;
}
// 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;
}
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;
}
void *initLocalCamera(void *VoidPtrArgs)
{
struct cameraControl *currentArgs = VoidPtrArgs;
pthread_mutex_lock(¤tArgs->mutexPtr);
ILCLIENT_T *client = currentArgs->client;
pthread_mutex_unlock(¤tArgs->mutexPtr);
//////////////////
//VARIABLES
COMPONENT_T *camera = NULL, *video_render = NULL, *image_encode = NULL;
COMPONENT_T *component_list[3] = {camera, video_render, image_encode};
COMPONENT_T *image_encode_list[1] = {image_encode}; //needed to destroy component?
OMX_ERRORTYPE OMXstatus;
TUNNEL_T tunnel_camera_to_render, tunnel_camera_to_encode;
memset(&tunnel_camera_to_render, 0, sizeof(tunnel_camera_to_render));
memset(&tunnel_camera_to_encode, 0, sizeof(tunnel_camera_to_encode));
//////////////////
// STARTUP
//////////////////
// Initalize Components
//////////////////
////initialise camera
ilclient_create_component(client,
&camera,
"camera",
ILCLIENT_DISABLE_ALL_PORTS);
OMXstatus = ilclient_change_component_state(camera, OMX_StateIdle);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move camera component to Idle (1)");
exit(EXIT_FAILURE);
}
//change the capture resolution
setCaptureRes(camera, currentArgs->photoWidth, currentArgs->photoHeight);
//change the preview resolution
setPreviewRes(camera, currentArgs->previewWidth, currentArgs->previewHeight, currentArgs->previewFramerate);
//////////////////
////Initialise video render
ilclient_create_component(client,
&video_render,
"video_render",
ILCLIENT_DISABLE_ALL_PORTS
);
OMXstatus = ilclient_change_component_state(video_render, OMX_StateIdle);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move render component to Idle (1)\n");
exit(EXIT_FAILURE);
}
setRenderConfig(video_render, currentArgs->displayType);
////////////////////
////Initalise Image Encoder
ilclient_create_component(client,
&image_encode,
"image_encode",
ILCLIENT_DISABLE_ALL_PORTS
/*| ILCLIENT_ENABLE_INPUT_BUFFERS*/
| ILCLIENT_ENABLE_OUTPUT_BUFFERS);
OMXstatus = ilclient_change_component_state(image_encode, OMX_StateIdle);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move image encode component to Idle (1)\n");
exit(EXIT_FAILURE);
}
//image format Param set
setParamImageFormat(image_encode, JPEG_HIGH_FORMAT);
////////////////////
// enable components and tunnels
//setup tunnel of camera preview to renderer
set_tunnel(&tunnel_camera_to_render, camera, 70, video_render, 90);
ilclient_setup_tunnel(&tunnel_camera_to_render, 0, 0);
// change camera component to executing
OMXstatus = ilclient_change_component_state(camera, OMX_StateExecuting);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move camera component to Executing (1)\n");
exit(EXIT_FAILURE);
}
//change preview render to executing
OMXstatus = ilclient_change_component_state(video_render, OMX_StateExecuting);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move video render component to Executing (1)\n");
exit(EXIT_FAILURE);
}
//enable port and buffers for output port of image encode
ilclient_enable_port_buffers(image_encode, 341, NULL, NULL, NULL);
ilclient_enable_port(image_encode, 341);
//setup tunnel from camera image port too image encode
set_tunnel(&tunnel_camera_to_encode, camera, 72, image_encode, 340);
ilclient_setup_tunnel(&tunnel_camera_to_encode, 0, 0);
//change image_encode to executing
OMXstatus = ilclient_change_component_state(image_encode, OMX_StateExecuting);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move image_encode component to Executing (1) Error = %s\n", err2str(OMXstatus));
exit(EXIT_FAILURE);
}
/////////////////
// Main initLocalCamera() Loop
while(1)
{
pthread_mutex_lock(¤tArgs->mutexPtr);
if (currentArgs->previewChanged == true)
{
//working
ilclient_disable_tunnel(&tunnel_camera_to_render);
OMXstatus = ilclient_change_component_state(camera, OMX_StatePause);
setPreviewRes(camera,
currentArgs->previewWidth,
currentArgs->previewHeight,
currentArgs->previewFramerate);
OMXstatus = ilclient_change_component_state(camera, OMX_StateExecuting);
ilclient_enable_tunnel(&tunnel_camera_to_render);
currentArgs->previewChanged = false;
}
else if (currentArgs->photoChanged == true)
{
//NOT WORKING? CANT GET WORKING!!
//TUNNEL_T *tunnel_ptr = &tunnel_camera_to_encode;
ilclient_disable_tunnel(&tunnel_camera_to_encode);
ilclient_flush_tunnels(&tunnel_camera_to_encode, 30);
//ilclient_teardown_tunnels(&tunnel_camera_to_encode);
//printf("teardown done");
setCaptureRes(camera, currentArgs->photoWidth, currentArgs->photoHeight);
// DESTROY image encode and recreate (appears to be the only way)
//destory
OMXstatus = ilclient_change_component_state(image_encode, OMX_StateIdle);
OMXstatus = ilclient_change_component_state(image_encode, OMX_StateLoaded);
//OMX_FreeHandle(ilclient_get_handle(image_encode));
ilclient_cleanup_components(image_encode_list);
printf("managed to free the image_encode handle");
image_encode = NULL;
//recreate
ilclient_create_component(client,
&image_encode,
"image_encode",
ILCLIENT_DISABLE_ALL_PORTS
/*| ILCLIENT_ENABLE_INPUT_BUFFERS*/
| ILCLIENT_ENABLE_OUTPUT_BUFFERS);
OMXstatus = ilclient_change_component_state(image_encode, OMX_StateIdle);
if (OMXstatus != OMX_ErrorNone)
{
fprintf(stderr, "unable to move image encode component to Idle (1)\n");
exit(EXIT_FAILURE);
}
//image format Param set
setParamImageFormat(image_encode, JPEG_HIGH_FORMAT);
//OMXstatus = ilclient_change_component_state(camera, OMX_StateExecuting);
ilclient_enable_tunnel(&tunnel_camera_to_encode);
currentArgs->photoChanged = false;
}
else if (currentArgs->displayChanged == true)
{
//working
setRenderConfig(video_render, currentArgs->displayType);
currentArgs->displayChanged = false;
}
else if (currentArgs->takePhoto == true)
{
//working
savePhoto(camera, image_encode, "/home/pi/Desktop/photo_", "_L.jpg");
currentArgs->takePhoto = false;
}
//loop termination
else if (currentArgs->rcamDeInit == true)
{
//working
printf("~~~~~ End local camera ~~~~~\n");
break;
}
pthread_mutex_unlock(¤tArgs->mutexPtr);
usleep(500);
}
///////////////
//CLEANUP
// Teardown tunnels
ilclient_disable_tunnel(&tunnel_camera_to_render);
ilclient_disable_tunnel(&tunnel_camera_to_encode);
ilclient_teardown_tunnels(&tunnel_camera_to_render);
ilclient_teardown_tunnels(&tunnel_camera_to_encode);
// Disable components
ilclient_cleanup_components(component_list);
//Destroy ilclient
// dont do for local as its done in main program
//ilclient_destroy(currentArgs->client)
//unlock mutex before teminating
pthread_mutex_unlock(¤tArgs->mutexPtr);
//call pthread_exit so caller can join
pthread_exit(NULL);
}
