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