static int multiple_timer_test(void)
{
int passed;
VCOS_TIMER_T timers[32];
int i;
memset(results,0,sizeof(results));
for (i=0; i<32; i++)
{
VCOS_STATUS_T st = vcos_timer_create(timers+i,"test",multi_pfn,&results[i]);
if (st != VCOS_SUCCESS)
return 0;
}
for (i=0; i<32; i++)
{
vcos_timer_set(timers+i,1+i*10);
}
vcos_sleep(i*20);
/* check each timer fired */
passed = 1;
for (i=0; i<32; i++)
{
if (!results[i])
{
vcos_log("timer %d failed to go off", i);
passed = 0;
}
vcos_timer_delete(timers+i);
}
return passed;
}
void _vcos_task_timer_set(void (*pfn)(void*), void *cxt, VCOS_UNSIGNED ms)
{
VCOS_THREAD_T *thread = vcos_thread_current();
VCOS_STATUS_T status;
status = vcos_timer_create(&thread->task_timer, "vcos_task_timer", pfn, cxt);
vcos_assert(status == VCOS_SUCCESS);
vcos_timer_set(&thread->task_timer, ms);
}
void _vcos_task_timer_set(void (*pfn)(void *), void *cxt, VCOS_UNSIGNED ms)
{
VCOS_THREAD_T *self = vcos_thread_current();
vcos_assert(self);
vcos_assert(self->_timer.pfn == NULL);
vcos_timer_create( &self->_timer.timer, "TaskTimer", pfn, cxt );
vcos_timer_set(&self->_timer.timer, ms);
}
static VCOS_STATUS_T create_base(VCOS_THREAD_T *thread, const char *name)
{
VCOS_STATUS_T status;
thread->magic = VCOS_THREAD_MAGIC;
thread->legacy = 0;
thread->joined = 0;
thread->legacy = 0;
thread->stack = 0;
thread->next = NULL;
#ifdef VCOS_WANT_TLS_EMULATION
memset(&thread->_tls, 0, sizeof(thread->_tls));
#endif
memset(thread->at_exit, 0, sizeof(thread->at_exit));
if (!name)
{
vcos_assert(0);
return VCOS_EINVAL;
}
strncpy(thread->name, name, sizeof(thread->name));
thread->name[sizeof(thread->name)-1] = '\0';
status = vcos_semaphore_create(&thread->wait, thread->name, 0);
if (status != VCOS_SUCCESS)
goto fail_wait_sem;
status = vcos_semaphore_create(&thread->suspend, thread->name, 0);
if (status != VCOS_SUCCESS)
goto fail_suspend_sem;
thread->_timer.pfn = NULL;
thread->_timer.cxt = NULL;
if (CREATE_THREAD_TIMER)
{
status = vcos_timer_create(&thread->_timer.timer, thread->name, thread_timer_func, thread);
if (status != VCOS_SUCCESS)
goto fail_timer;
}
else
{
memset(&thread->_timer, 0, sizeof(thread->_timer));
}
return VCOS_SUCCESS;
fail_timer:
vcos_semaphore_delete(&thread->suspend);
fail_suspend_sem:
vcos_semaphore_delete(&thread->wait);
fail_wait_sem:
return status;
}
VCOS_STATUS_T vcos_thread_create(VCOS_THREAD_T *thread,
const char *name,
VCOS_THREAD_ATTR_T *attrs,
VCOS_THREAD_ENTRY_FN_T entry,
void *arg)
{
VCOS_STATUS_T st;
struct task_struct *kthread;
memset(thread, 0, sizeof(*thread));
thread->magic = VCOS_THREAD_MAGIC;
strlcpy( thread->name, name, sizeof( thread->name ));
thread->legacy = attrs ? attrs->legacy : 0;
thread->entry = entry;
thread->arg = arg;
if (!name)
{
vcos_assert(0);
return VCOS_EINVAL;
}
st = vcos_semaphore_create(&thread->wait, NULL, 0);
if (st != VCOS_SUCCESS)
{
return st;
}
st = vcos_semaphore_create(&thread->suspend, NULL, 0);
if (st != VCOS_SUCCESS)
{
return st;
}
/*required for event groups */
vcos_timer_create(&thread->_timer.timer, thread->name, NULL, NULL);
kthread = kthread_create((int (*)(void *))vcos_thread_wrapper, (void*)thread, name);
vcos_assert(kthread != NULL);
set_user_nice(kthread, attrs->ta_priority);
thread->thread.thread = kthread;
wake_up_process(kthread);
return VCOS_SUCCESS;
}
/* create a single timer, and check it does as expected */
static int basic_timer_test(void)
{
VCOS_TIMER_T timer;
VCOS_STATUS_T status = vcos_timer_create(&timer, "test",
basic_pfn, (void*)42);
basic_cxt = 0;
if (status != VCOS_SUCCESS)
return 0;
vcos_timer_set(&timer, 100);
vcos_sleep(200);
if (basic_cxt != (void*)42)
return 0;
vcos_timer_delete(&timer);
return 1;
}
void _vcos_task_timer_set(void (*pfn)(void*), void *cxt, VCOS_UNSIGNED ms)
{
VCOS_THREAD_T *thread = vcos_thread_current();
if (thread == NULL)
return;
vcos_assert(thread->orig_task_timer_expiration_routine == NULL);
if (!thread->task_timer_created)
{
VCOS_STATUS_T st = vcos_timer_create(&thread->task_timer, NULL,
_task_timer_expiration_routine, thread);
(void)st;
vcos_assert(st == VCOS_SUCCESS);
thread->task_timer_created = 1;
}
thread->orig_task_timer_expiration_routine = pfn;
thread->orig_task_timer_context = cxt;
vcos_timer_set(&thread->task_timer, ms);
}
/* Create Simple Video Player instance. */
SVP_T *svp_create(const char *uri, SVP_CALLBACKS_T *callbacks, const SVP_OPTS_T *opts)
{
SVP_T *svp;
MMAL_STATUS_T st;
VCOS_STATUS_T vst;
MMAL_PORT_T *reader_output = NULL;
MMAL_COMPONENT_T *video_decode = NULL;
MMAL_PORT_T *video_output = NULL;
LOG_TRACE("Creating player for %s", (uri ? uri : "camera preview"));
vcos_assert(callbacks->video_frame_cb);
vcos_assert(callbacks->stop_cb);
svp = vcos_calloc(1, sizeof(*svp), "svp");
CHECK_STATUS((svp ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to allocate context");
svp->opts = *opts;
svp->callbacks = *callbacks;
/* Semaphore used for synchronising buffer handling for decoded frames */
vst = vcos_semaphore_create(&svp->sema, "svp-sem", 0);
CHECK_STATUS((vst == VCOS_SUCCESS ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to create semaphore");
svp->created |= SVP_CREATED_SEM;
vst = vcos_mutex_create(&svp->mutex, "svp-mutex");
CHECK_STATUS((vst == VCOS_SUCCESS ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to create mutex");
svp->created |= SVP_CREATED_MUTEX;
vst = vcos_timer_create(&svp->timer, "svp-timer", svp_timer_cb, svp);
CHECK_STATUS((vst == VCOS_SUCCESS ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to create timer");
svp->created |= SVP_CREATED_TIMER;
vst = vcos_timer_create(&svp->wd_timer, "svp-wd-timer", svp_watchdog_cb, svp);
CHECK_STATUS((vst == VCOS_SUCCESS ? MMAL_SUCCESS : MMAL_ENOMEM), "Failed to create timer");
svp->created |= SVP_CREATED_WD_TIMER;
/* Create components */
svp->reader = NULL;
svp->video_decode = NULL;
svp->camera = NULL;
svp->connection = NULL;
if (uri)
{
/* Video from URI: setup container_reader -> video_decode */
/* Create and set up container reader */
st = mmal_component_create(MMAL_COMPONENT_DEFAULT_CONTAINER_READER, &svp->reader);
CHECK_STATUS(st, "Failed to create container reader");
st = svp_setup_reader(svp->reader, uri, &reader_output);
if (st != MMAL_SUCCESS)
goto error;
st = mmal_component_enable(svp->reader);
CHECK_STATUS(st, "Failed to enable container reader");
st = svp_port_enable(svp, svp->reader->control, svp_bh_control_cb);
CHECK_STATUS(st, "Failed to enable container reader control port");
/* Create and set up video decoder */
st = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, &svp->video_decode);
CHECK_STATUS(st, "Failed to create video decoder");
video_decode = svp->video_decode;
video_output = video_decode->output[0];
st = mmal_component_enable(video_decode);
CHECK_STATUS(st, "Failed to enable video decoder");
st = svp_port_enable(svp, video_decode->control, svp_bh_control_cb);
CHECK_STATUS(st, "Failed to enable video decoder control port");
}
else
{
/* Camera preview */
MMAL_PARAMETER_CAMERA_CONFIG_T config;
st = mmal_component_create(MMAL_COMPONENT_DEFAULT_CAMERA, &svp->camera);
CHECK_STATUS(st, "Failed to create camera");
st = mmal_component_enable(svp->camera);
CHECK_STATUS(st, "Failed to enable camera");
st = svp_port_enable(svp, svp->camera->control, svp_bh_control_cb);
CHECK_STATUS(st, "Failed to enable camera control port");
video_output = svp->camera->output[0]; /* Preview port */
}
st = mmal_port_parameter_set_boolean(video_output, MMAL_PARAMETER_ZERO_COPY, MMAL_TRUE);
CHECK_STATUS((st == MMAL_ENOSYS ? MMAL_SUCCESS : st), "Failed to enable zero copy");
if (uri)
{
/* Create connection: container_reader -> video_decoder */
st = mmal_connection_create(&svp->connection, reader_output, video_decode->input[0],
MMAL_CONNECTION_FLAG_TUNNELLING);
CHECK_STATUS(st, "Failed to create connection");
}
/* Set video output port format.
* Opaque encoding ensures we get buffer data as handles to relocatable heap. */
video_output->format->encoding = MMAL_ENCODING_OPAQUE;
if (!uri)
{
/* Set video format for camera preview */
MMAL_VIDEO_FORMAT_T *vfmt = &video_output->format->es->video;
CHECK_STATUS((video_output->format->type == MMAL_ES_TYPE_VIDEO) ? MMAL_SUCCESS : MMAL_EINVAL,
"Output port isn't video format");
vfmt->width = SVP_CAMERA_WIDTH;
vfmt->height = SVP_CAMERA_HEIGHT;
vfmt->crop.x = 0;
vfmt->crop.y = 0;
vfmt->crop.width = vfmt->width;
vfmt->crop.height = vfmt->height;
vfmt->frame_rate.num = SVP_CAMERA_FRAMERATE;
vfmt->frame_rate.den = 1;
}
st = mmal_port_format_commit(video_output);
CHECK_STATUS(st, "Failed to set output port format");
/* Finally, set buffer num/size. N.B. For container_reader/video_decode, must be after
* connection created, in order for port format to propagate.
* Don't enable video output port until want to produce frames. */
video_output->buffer_num = video_output->buffer_num_recommended;
video_output->buffer_size = video_output->buffer_size_recommended;
/* Pool + queue to hold decoded video frames */
svp->out_pool = mmal_port_pool_create(video_output, video_output->buffer_num,
video_output->buffer_size);
CHECK_STATUS((svp->out_pool ? MMAL_SUCCESS : MMAL_ENOMEM), "Error allocating pool");
svp->queue = mmal_queue_create();
CHECK_STATUS((svp ? MMAL_SUCCESS : MMAL_ENOMEM), "Error allocating queue");
svp->video_output = video_output;
return svp;
error:
svp_destroy(svp);
return NULL;
}
