uint32_t _process( struct iothreads * parent, struct iothread * thread, struct taskqueue * doqueue ) { uint32_t nprocess = 0; // 交换任务队列 msgqueue_swap( thread->queue, doqueue ); // 获取最大任务数 nprocess = QUEUE_COUNT(taskqueue)(doqueue); // 处理任务 for( ; QUEUE_COUNT(taskqueue)(doqueue) > 0; ) { struct task task; QUEUE_POP(taskqueue)( doqueue, &task ); // 网络任务处理 if ( task.type == eTaskType_User ) { parent->processor( parent->context, thread->index, task.utype, task.taskdata ); } else if ( task.type == eTaskType_Data ) { parent->processor( parent->context, thread->index, task.utype, (void *)(task.data) ); } } return nprocess; }
int32_t msgqueue_push( struct msgqueue * self, struct task * task, uint8_t isnotify ) { int32_t rc = -1; uint32_t isbc = 0; pthread_mutex_lock( &self->lock ); rc = QUEUE_PUSH(taskqueue)(&self->queue, task); if ( isnotify != 0 ) { isbc = QUEUE_COUNT(taskqueue)(&self->queue); } pthread_mutex_unlock( &self->lock ); if ( rc == 0 && isbc == 1 ) { char buf[1] = {0}; if ( write( self->pushfd, buf, 1 ) != 1 ) { // } } return rc; }
uint32_t _process( struct iothreads * parent, struct iothread * thread, struct taskqueue * doqueue ) { uint32_t nprocess = 0; // 交换任务队列 msgqueue_swap( thread->queue, doqueue ); // 获取最大任务数 nprocess = QUEUE_COUNT(taskqueue)(doqueue); // 处理任务 while ( QUEUE_COUNT(taskqueue)(doqueue) > 0 ) { struct task task; void * data = NULL; QUEUE_POP(taskqueue)( doqueue, &task ); switch ( task.type ) { case eTaskType_Null : { // 空命令 continue; } break; case eTaskType_User : { // 用户命令 data = task.taskdata; } break; case eTaskType_Data : { // 数据命令 data = (void *)(task.data); } break; } // 回调 parent->method( parent->context, thread->index, task.utype, data ); } return nprocess; }
void runloop_idle(void *globals) { globals_t *g = (globals_t*)globals; if (QUEUE_COUNT(&(g->packets_to_forward)) > 0) dequeue_packet(g); if (!g->option.hide_captured_packets_statistics) print_stats(g); }
uint32_t msgqueue_count( struct msgqueue * self ) { uint32_t rc = 0; pthread_mutex_lock( &self->lock ); rc = QUEUE_COUNT(taskqueue)(&self->queue); pthread_mutex_unlock( &self->lock ); return rc; }
/** * hp3a_update_framework- execute tasks between frames. * * No return value. **/ void hp3a_update_stats_readout_done(void) { int i; bool allow_exp_update = true; bool allow_gain_update = true; struct hp3a_internal_buffer *ibuffer; struct hp3a_sensor_param_internal sensor_param; if (unlikely(g_tc.v4l2_streaming == 0)) { hp3a_disable_histogram(); hp3a_disable_af(); return; } /* Reuse stats buffers. */ if (g_tc.histogram_buffer != NULL) { g_tc.hist_done = 0; hp3a_enqueue(&g_tc.hist_stat_queue, &g_tc.histogram_buffer); g_tc.histogram_buffer = NULL; } if (g_tc.af_buffer != NULL) { hp3a_enqueue(&g_tc.af_stat_queue, &g_tc.af_buffer); g_tc.af_buffer = NULL; } if (g_tc.raw_buffer != NULL) { hp3a_enqueue(&g_tc.raw_frame_queue, &g_tc.raw_buffer); g_tc.raw_buffer = NULL; } /* Process ready stats. */ for (i = MAX_STAT_BUFFERS_PER_FRAME; i--;) { ibuffer = NULL; if (hp3a_dequeue(&g_tc.ready_stats_queue, &ibuffer) == 0) { if (ibuffer->type == HISTOGRAM && g_tc.histogram_buffer == NULL) g_tc.histogram_buffer = ibuffer; else if (ibuffer->type == PAXEL && g_tc.af_buffer == NULL) g_tc.af_buffer = ibuffer; else if (ibuffer->type == BAYER && g_tc.raw_buffer == NULL) g_tc.raw_buffer = ibuffer; else { printk(KERN_ERR "hp3a: Error unknown " "buffer type(%d)\n", ibuffer->type); } } else { break; } } for (i = QUEUE_COUNT(g_tc.sensor_read_queue); i--;) { if (hp3a_dequeue(&g_tc.sensor_read_queue, &sensor_param) == 0) { if (sensor_param.frame_id == g_tc.frame_count) { if (sensor_param.exposure == (u32)-1) { g_tc.sensor_stats.exposure = 0; allow_exp_update = false; } else if (sensor_param.exposure && allow_exp_update) { g_tc.sensor_stats.exposure = sensor_param.exposure; } if (sensor_param.gain == (u16)-1) { g_tc.sensor_stats.gain = 0; allow_gain_update = false; } else if (sensor_param.gain && allow_gain_update) { g_tc.sensor_stats.gain = sensor_param.gain; } if (sensor_param.fps) { g_tc.sensor_stats.fps = \ sensor_param.fps; } } else if (sensor_param.frame_id > g_tc.frame_count) { hp3a_enqueue(&g_tc.sensor_read_queue, &sensor_param); } } else { break; } } /* Histogram buffer processing and HW configuration. */ hp3a_enable_histogram(); /* AF stat buffer processing and HW configuration. */ hp3a_enable_af(); /* Notify threads waiting for stats. */ complete(&g_tc.frame_done); }
/** * hp3a_set_sensor_param - Set sensor specific params. * @param: Pointer the structure containing sensor parameters. * @fh: Pointer to a hp3a_fh stucture. * * Return 0 on success, less than 0 otherwise. **/ int hp3a_set_sensor_param(struct hp3a_sensor_param *param, struct hp3a_fh *fh) { int ret = -1; struct hp3a_sensor_param_internal sensor_param = { .exposure = 0, .gain = 0, .fps = 0}; unsigned long irqflags = 0; if (likely(fh->v4l2_dev > -1)) { if (likely(g_tc.v4l2_streaming == 1)) { sensor_param.v4l2_dev = fh->v4l2_dev; ret = 0; spin_lock_irqsave(&g_tc.stats_lock, irqflags); if (!(g_tc.sensor_stats.exposure && g_tc.sensor_stats.gain) && !QUEUE_COUNT(g_tc.sensor_write_queue)) { memset(&g_tc.sensor_current, 0, \ sizeof(g_tc.sensor_current)); memset(&g_tc.sensor_requested, 0, \ sizeof(g_tc.sensor_requested)); } if (param->fps && g_tc.sensor_requested.fps != \ param->fps) { sensor_param.fps = param->fps; sensor_param.exposure = param->exposure; sensor_param.gain = param->gain; ret = hp3a_enqueue( \ &g_tc.sensor_write_queue, &sensor_param); sensor_param.fps = 0; sensor_param.exposure = 0; sensor_param.gain = 0; if (!ret) { g_tc.sensor_requested.fps = \ param->fps; g_tc.sensor_requested.exposure = param->exposure; g_tc.sensor_requested.gain = \ param->gain; } } if (param->exposure && (g_tc.sensor_requested.exposure != \ param->exposure)) { sensor_param.exposure = param->exposure; ret = hp3a_enqueue( \ &g_tc.sensor_write_queue, &sensor_param); sensor_param.exposure = 0; if (!ret) { g_tc.sensor_requested.exposure = \ param->exposure; } } if (param->gain && (g_tc.sensor_requested.gain != \ param->gain)) { sensor_param.gain = param->gain; ret = hp3a_enqueue( \ &g_tc.sensor_write_queue, &sensor_param); if (!ret) { g_tc.sensor_requested.gain = \ param->gain; } } spin_unlock_irqrestore(&g_tc.stats_lock, irqflags); } else { struct cam_sensor_settings sensor_settings = { .flags = 0, .exposure = 0, .gain = 0, .fps = 0, .regs = 0, .reg_data = 0}; sensor_settings.exposure = param->exposure; sensor_settings.gain = param->gain; sensor_settings.fps = param->fps; sensor_settings.flags = (OMAP34XXCAM_SET_GAIN | \ OMAP34XXCAM_SET_EXPOSURE); /** * Write and read sensor settings. */ ret = omap34xxcam_sensor_settings(fh->v4l2_dev, &sensor_settings); } } else { dev_err(fh->device->dev, "hp3a: Invalid sensor id(%d)\n", fh->v4l2_dev); } return ret; } /** * hp3a_set_hardpipe_param - Set hard pipe specific params to be programmed. * @param: Pointer the structure containing hard pipe parameters. * @fh: Pointer to a hp3a_fh stucture. * * Return 0 on success, less than 0 otherwise. **/ int hp3a_set_hardpipe_param(struct hp3a_hardpipe_param *param, struct hp3a_fh *fh) { unsigned long irqflags = 0; spin_lock_irqsave(&g_tc.hardpipe_lock, irqflags); memcpy(&g_tc.hpipe_param, param, sizeof(struct hp3a_hardpipe_param)); g_tc.update_hardpipe = 1; spin_unlock_irqrestore(&g_tc.hardpipe_lock, irqflags); if (g_tc.v4l2_streaming == 0) hp3a_update_hardpipe(); return 0; }