int wait_group(char *group, int (*func) (void *), void * args , unsigned int type, unsigned int time_ms, unsigned int time_us, float ratio, unsigned int redo){
list_t *list;
group_t *my_group;
printf("going to wait group\n");
struct timespec watchdog ={0, 0};
time_t secs;
long nsecs;
int ret;
float temp;
if(!groups){
printf("No such group\n");
return 0;
}
list = search(groups, cmp_group, (void*) group);
if (!list){
printf("No such group\n");
return 0;
}
my_group = (group_t*) list->args; //get actual group
pthread_mutex_lock(&my_group->lock);
if (type & SYNC_RATIO){
#ifdef DEBUG
printf("Calculating my ratio : ");
#endif
temp = calculate_ratio(my_group);
#ifdef DEBUG
printf("%f executing num %d\n", ratio,my_group->executing_num);
#endif
if(temp >= ratio){
if(my_group->executing_num == 0 && my_group->total_sig_tasks == my_group->finished_sig_num){
my_group->schedule = 0;
#ifdef DEBUG
printf("I am going to execute sanity funct\n");
#endif
my_group->result = exec_sanity(my_group);
my_group->executed++;
pthread_mutex_unlock(&my_group->lock);
return 1;
}
}
#ifdef DEBUG
else{
printf("Number of pending tasks %d\n",my_group->finished_sig_num);
}
#endif
}
#ifdef DEBUG
else
printf("Moving on\n");
#endif
if( (type&SYNC_TIME) ){
clock_gettime(CLOCK_REALTIME, &watchdog);
secs = watchdog.tv_sec + time_ms/1000;
nsecs = watchdog.tv_nsec + (time_ms % 1000)*100000;
watchdog.tv_sec = secs + nsecs / 1000000000L;
watchdog.tv_nsec = nsecs % 1000000000L;
}
my_group->sanity_func = func;
my_group->sanity_func_args = args;
my_group->ratio = ratio;
my_group->redo = redo;
my_group->locked = 1;
if((type & SYNC_TIME)){
do {
ret =pthread_cond_timedwait(&my_group->condition, &my_group->lock, &watchdog);
if (ret == ETIMEDOUT) {
#ifdef DEBUG
printf("Watchdog timer went off\n");
#endif
if(my_group->finished_sig_num != my_group->total_sig_tasks){
my_group->ratio = 0.0;
#ifdef DEBUG
printf("Shall wait for all significant tasks\n");
#endif
pthread_cond_wait(&my_group->condition, &my_group->lock);
break;
}
else{
if(my_group->executing_num != 0){
if(!my_group->terminated){
pthread_mutex_lock(&my_group->executing_q->lock);
exec_on_elem(my_group->executing_q,force_termination);
pthread_mutex_unlock(&my_group->executing_q->lock);
my_group->terminated = 1;
pthread_mutex_unlock(&my_group->lock);
}
}
while(my_group->executing_num != 0){}
my_group->result = exec_sanity(my_group);
my_group->executed++;
}
}
#ifdef DEBUG
else if (ret == 0) {
printf("ratio of tasks achieved\n");
}
#endif
}while (ret == EINTR);
}
else if(type&SYNC_ALL){
#ifdef DEBUG
printf(" I am waiting for ALL tasks\n");
#endif
if(my_group->finished_sig_num != my_group->total_sig_tasks){
#ifdef DEBUG
printf("Locking in conditional wait\n");
#endif
pthread_cond_wait(&my_group->condition, &my_group->lock);
#ifdef DEBUG
printf("Main application just woke up\n");
#endif
}
else{
if(my_group->executing_num != 0){
if(!my_group->terminated){
pthread_mutex_lock(&my_group->executing_q->lock);
exec_on_elem(my_group->executing_q,force_termination);
pthread_mutex_unlock(&my_group->executing_q->lock);
my_group->terminated = 1;
pthread_mutex_unlock(&my_group->lock);
}
}
while(my_group->executing_num != 0){}
my_group->result = exec_sanity(my_group);
my_group->executed++;
}
}
else
pthread_cond_wait(&my_group->condition, &my_group->lock);
pthread_mutex_unlock(&my_group->lock);
return 1;
}
struct vpu_display *
v4l_display_open(struct decode *dec, int nframes, struct rot rotation, Rect cropRect)
{
int width = dec->picwidth;
int height = dec->picheight;
int left = cropRect.left;
int top = cropRect.top;
int right = cropRect.right;
int bottom = cropRect.bottom;
int disp_width = dec->cmdl->width;
int disp_height = dec->cmdl->height;
int disp_left = dec->cmdl->loff;
int disp_top = dec->cmdl->toff;
int fd = -1, err = 0, out = 0, i = 0;
char v4l_device[80], node[8];
struct v4l2_cropcap cropcap = {0};
struct v4l2_crop crop = {0};
struct v4l2_framebuffer fb = {0};
struct v4l2_format fmt = {0};
struct v4l2_requestbuffers reqbuf = {0};
struct v4l2_mxc_offset off = {0};
struct v4l2_rect icrop = {0};
struct vpu_display *disp;
int fd_fb;
char *tv_mode, *test_mode;
char motion_mode = dec->cmdl->vdi_motion;
struct mxcfb_gbl_alpha alpha;
int ratio = 1;
if (cpu_is_mx27()) {
out = 0;
} else {
out = 3;
#ifdef BUILD_FOR_ANDROID
fd_fb = open("/dev/graphics/fb0", O_RDWR, 0);
#else
fd_fb = open("/dev/fb0", O_RDWR, 0);
#endif
if (fd_fb < 0) {
err_msg("unable to open fb0\n");
return NULL;
}
alpha.alpha = 0;
alpha.enable = 1;
if (ioctl(fd_fb, MXCFB_SET_GBL_ALPHA, &alpha) < 0) {
err_msg("set alpha blending failed\n");
return NULL;
}
close(fd_fb);
}
dprintf(3, "rot_en:%d; rot_angle:%d; ipu_rot_en:%d\n", rotation.rot_en,
rotation.rot_angle, rotation.ipu_rot_en);
tv_mode = getenv("VPU_TV_MODE");
if (tv_mode) {
err = system("/bin/echo 1 > /sys/class/graphics/fb1/blank");
if (!strcmp(tv_mode, "NTSC")) {
err = system("/bin/echo U:720x480i-60 > /sys/class/graphics/fb1/mode");
out = 5;
} else if (!strcmp(tv_mode, "PAL")) {
err = system("/bin/echo U:720x576i-50 > /sys/class/graphics/fb1/mode");
out = 5;
} else if (!strcmp(tv_mode, "720P")) {
err = system("/bin/echo U:1280x720p-60 > /sys/class/graphics/fb1/mode");
out = 5;
} else {
out = 3;
warn_msg("VPU_TV_MODE should be set to NTSC, PAL, or 720P.\n"
"\tDefault display is LCD if not set this environment "
"or set wrong string.\n");
}
err = system("/bin/echo 0 > /sys/class/graphics/fb1/blank");
if (err == -1) {
warn_msg("set tv mode error\n");
}
/* make sure tvout init done */
sleep(2);
}
if (rotation.rot_en) {
if (rotation.rot_angle == 90 || rotation.rot_angle == 270) {
i = width;
width = height;
height = i;
}
dprintf(3, "VPU rot: width = %d; height = %d\n", width, height);
}
disp = (struct vpu_display *)calloc(1, sizeof(struct vpu_display));
if (disp == NULL) {
err_msg("falied to allocate vpu_display\n");
return NULL;
}
if (!dec->cmdl->video_node) {
if (cpu_is_mx6x())
dec->cmdl->video_node = 17; /* fg for mx6x */
else
dec->cmdl->video_node = 16;
}
sprintf(node, "%d", dec->cmdl->video_node);
strcpy(v4l_device, "/dev/video");
strcat(v4l_device, node);
fd = open(v4l_device, O_RDWR, 0);
if (fd < 0) {
err_msg("unable to open %s\n", v4l_device);
goto err;
}
info_msg("v4l output to %s\n", v4l_device);
if (!cpu_is_mx6x()) {
err = ioctl(fd, VIDIOC_S_OUTPUT, &out);
if (err < 0) {
err_msg("VIDIOC_S_OUTPUT failed\n");
goto err;
}
}
cropcap.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
err = ioctl(fd, VIDIOC_CROPCAP, &cropcap);
if (err < 0) {
err_msg("VIDIOC_CROPCAP failed\n");
goto err;
}
dprintf(1, "cropcap.bounds.width = %d\n\tcropcap.bound.height = %d\n\t" \
"cropcap.defrect.width = %d\n\tcropcap.defrect.height = %d\n",
cropcap.bounds.width, cropcap.bounds.height,
cropcap.defrect.width, cropcap.defrect.height);
if (rotation.ipu_rot_en == 0) {
ratio = calculate_ratio(width, height, cropcap.bounds.width,
cropcap.bounds.height);
dprintf(3, "VPU rot: ratio = %d\n", ratio);
}
crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
crop.c.top = disp_top;
crop.c.left = disp_left;
crop.c.width = width / ratio;
crop.c.height = height / ratio;
if ((disp_width != 0) && (disp_height!= 0 )) {
crop.c.width = disp_width;
crop.c.height = disp_height;
} else if (!cpu_is_mx27()) {
crop.c.width = cropcap.bounds.width;
crop.c.height = cropcap.bounds.height;
}
info_msg("Display to %d %d, top offset %d, left offset %d\n",
crop.c.width, crop.c.height, disp_top, disp_left);
dprintf(1, "crop.c.width/height: %d/%d\n", crop.c.width, crop.c.height);
err = ioctl(fd, VIDIOC_S_CROP, &crop);
if (err < 0) {
err_msg("VIDIOC_S_CROP failed\n");
goto err;
}
/* Set VDI motion algorithm. */
if (motion_mode) {
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_MXC_MOTION;
if (motion_mode == 'h') {
ctrl.value = HIGH_MOTION;
} else if (motion_mode == 'l') {
ctrl.value = LOW_MOTION;
} else if (motion_mode == 'm') {
ctrl.value = MED_MOTION;
} else {
ctrl.value = MED_MOTION;
info_msg("%c unknown motion mode, medium, the default is used\n",motion_mode);
}
err = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
if (err < 0) {
err_msg("VIDIOC_S_CTRL failed\n");
goto err;
}
}
if (cpu_is_mx6x()) {
/* Set rotation via new V4L2 interface on 2.6.38 kernel */
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_ROTATE;
if (rotation.ipu_rot_en)
ctrl.value = rotation.rot_angle;
else
ctrl.value = 0;
err = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
if (err < 0) {
err_msg("VIDIOC_S_CTRL failed\n");
goto err;
}
} else if (rotation.ipu_rot_en && (rotation.rot_angle != 0)) {
/* Set rotation via V4L2 i/f */
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_PRIVATE_BASE;
if (rotation.rot_angle == 90)
ctrl.value = V4L2_MXC_ROTATE_90_RIGHT;
else if (rotation.rot_angle == 180)
ctrl.value = V4L2_MXC_ROTATE_180;
else if (rotation.rot_angle == 270)
ctrl.value = V4L2_MXC_ROTATE_90_LEFT;
err = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
if (err < 0) {
err_msg("VIDIOC_S_CTRL failed\n");
goto err;
}
} else {
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_PRIVATE_BASE;
ctrl.value = 0;
err = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
if (err < 0) {
err_msg("VIDIOC_S_CTRL failed\n");
goto err;
}
}
if (cpu_is_mx27()) {
fb.capability = V4L2_FBUF_CAP_EXTERNOVERLAY;
fb.flags = V4L2_FBUF_FLAG_PRIMARY;
err = ioctl(fd, VIDIOC_S_FBUF, &fb);
if (err < 0) {
err_msg("VIDIOC_S_FBUF failed\n");
goto err;
}
}
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
/*
* Just consider one case:
* (top,left) = (0,0)
*/
if (top || left) {
err_msg("This case is not covered in this demo for simplicity:\n"
"croping rectangle (top, left) != (0, 0); "
"top/left = %d/%d\n", top, left);
goto err;
} else if (right || bottom) {
if (cpu_is_mx6x()) {
/* This is aligned with new V4L interface on 2.6.38 kernel */
fmt.fmt.pix.width = width;
fmt.fmt.pix.height = height;
icrop.left = left;
icrop.top = top;
icrop.width = right - left;
icrop.height = bottom - top;
fmt.fmt.pix.priv = (unsigned long)&icrop;
} else {
fmt.fmt.pix.width = right - left;
fmt.fmt.pix.height = bottom - top;
fmt.fmt.pix.bytesperline = width;
off.u_offset = width * height;
off.v_offset = off.u_offset + width * height / 4;
fmt.fmt.pix.priv = (unsigned long) &off;
fmt.fmt.pix.sizeimage = width * height * 3 / 2;
}
} else {
fmt.fmt.pix.width = width;
fmt.fmt.pix.height = height;
fmt.fmt.pix.bytesperline = width;
}
dprintf(1, "fmt.fmt.pix.width = %d\n\tfmt.fmt.pix.height = %d\n",
fmt.fmt.pix.width, fmt.fmt.pix.height);
fmt.fmt.pix.field = V4L2_FIELD_ANY;
if (dec->cmdl->mapType == LINEAR_FRAME_MAP) {
if (dec->cmdl->chromaInterleave == 0) {
if (dec->mjpg_fmt == MODE420)
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
else if (dec->mjpg_fmt == MODE422)
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
else {
err_msg("Display cannot support this MJPG format\n");
goto err;
}
} else {
if (dec->mjpg_fmt == MODE420) {
info_msg("Display: NV12\n");
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
}
else if (dec->mjpg_fmt == MODE422) {
info_msg("Display: NV16\n");
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_NV16;
}
else {
err_msg("Display cannot support this MJPG format\n");
goto err;
}
}
}
else if (dec->cmdl->mapType == TILED_FRAME_MB_RASTER_MAP) {
fmt.fmt.pix.pixelformat = IPU_PIX_FMT_TILED_NV12;
}
else if (dec->cmdl->mapType == TILED_FIELD_MB_RASTER_MAP) {
fmt.fmt.pix.pixelformat = IPU_PIX_FMT_TILED_NV12F;
}
else {
err_msg("Display cannot support mapType = %d\n", dec->cmdl->mapType);
goto err;
}
err = ioctl(fd, VIDIOC_S_FMT, &fmt);
if (err < 0) {
err_msg("VIDIOC_S_FMT failed\n");
goto err;
}
err = ioctl(fd, VIDIOC_G_FMT, &fmt);
if (err < 0) {
err_msg("VIDIOC_G_FMT failed\n");
goto err;
}
reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
reqbuf.memory = V4L2_MEMORY_MMAP;
reqbuf.count = nframes;
err = ioctl(fd, VIDIOC_REQBUFS, &reqbuf);
if (err < 0) {
err_msg("VIDIOC_REQBUFS failed\n");
goto err;
}
if (reqbuf.count < nframes) {
err_msg("VIDIOC_REQBUFS: not enough buffers\n");
goto err;
}
for (i = 0; i < nframes; i++) {
struct v4l2_buffer buffer = {0};
struct v4l_buf *buf;
buf = calloc(1, sizeof(struct v4l_buf));
if (buf == NULL) {
v4l_free_bufs(i, disp);
goto err;
}
disp->buffers[i] = buf;
buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
buffer.memory = V4L2_MEMORY_MMAP;
buffer.index = i;
err = ioctl(fd, VIDIOC_QUERYBUF, &buffer);
if (err < 0) {
err_msg("VIDIOC_QUERYBUF: not enough buffers\n");
v4l_free_bufs(i, disp);
goto err;
}
buf->start = mmap(NULL, buffer.length, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, buffer.m.offset);
if (cpu_is_mx6x()) {
/*
* Workaround for new V4L interface change, this change
* will be removed after V4L driver is updated for this.
* Need to call QUERYBUF ioctl again after mmap.
*/
err = ioctl(fd, VIDIOC_QUERYBUF, &buffer);
if (err < 0) {
err_msg("VIDIOC_QUERYBUF: not enough buffers\n");
v4l_free_bufs(i, disp);
goto err;
}
}
buf->offset = buffer.m.offset;
buf->length = buffer.length;
dprintf(3, "V4L2buf phy addr: %08x, size = %d\n",
(unsigned int)buf->offset, buf->length);
if (buf->start == MAP_FAILED) {
err_msg("mmap failed\n");
v4l_free_bufs(i, disp);
goto err;
}
}
disp->fd = fd;
disp->nframes = nframes;
/*
* Use environment VIDEO_PERFORMANCE_TEST to select different mode.
* When doing performance test, video decoding and display are in different
* threads and default display fps is controlled by cmd. Display will
* show the frame immediately if user doesn't input fps with -a option.
* This is different from normal unit test.
*/
test_mode = getenv("VIDEO_PERFORMANCE_TEST");
if (test_mode && !strcmp(test_mode, "1") && (dec->cmdl->dst_scheme == PATH_V4L2))
vpu_v4l_performance_test = 1;
if (vpu_v4l_performance_test) {
dec->disp = disp;
sem_init(&disp->avaiable_decoding_frame, 0,
dec->regfbcount - dec->minfbcount);
sem_init(&disp->avaiable_dequeue_frame, 0, 0);
pthread_mutex_init(&v4l_mutex, NULL);
/* start v4l disp loop thread */
pthread_create(&(disp->v4l_disp_loop_thread), NULL,
(void *)v4l_disp_loop_thread, (void *)dec);
}
return disp;
err:
close(fd);
free(disp);
return NULL;
}
void explicit_sync(group_t *curr_group){
float ratio;
pthread_mutex_lock(&curr_group->lock);
// Check if I have a pending barrier.
if(!curr_group->locked){
pthread_mutex_unlock(&curr_group->lock);
// If not just return.
return ;
}
// check if the current group has executed all the significant tasks
if ( curr_group->finished_sig_num == curr_group->total_sig_tasks){
ratio = calculate_ratio(curr_group);
#ifdef DEBUG
printf("Ratio is %f\n",ratio);
#endif
if(ratio < curr_group ->ratio ){
pthread_mutex_unlock(&curr_group->lock);
return ;
}
}else{
#ifdef DEBUG
printf("Finished %d --- Total %d\n",curr_group->finished_sig_num,curr_group->total_sig_tasks);
#endif
pthread_mutex_unlock(&curr_group->lock);
return;
}
// I am here only if I need to wake up the main application from
// the barrier and all requested ratios are met.
// I am stopping to scheduling tasks from this group.
curr_group->schedule = 0;
// I am forcing termination of tasks of this group.
#ifdef DEBUG
printf("Moving Here\n");
#endif
if(curr_group->executing_num != 0){
#ifdef DEBUG
printf("Tasks are still being executed\n");
#endif
if(!curr_group->terminated){
pthread_mutex_lock(&curr_group->executing_q->lock);
exec_on_elem(curr_group->executing_q,force_termination);
pthread_mutex_unlock(&curr_group->executing_q->lock);
curr_group->terminated = 1;
pthread_mutex_unlock(&curr_group->lock);
// I am returning because at this point the terminated tasks are going to check again whether
// to continute execution of this group or not.
return;
}
}
// I have no idea why I have this again. I am keeping it
//in a case of a weird bug
if (curr_group->executing_num !=0){
pthread_mutex_unlock(&curr_group->lock);
return;
}
#warning Here i need to implement possible group re-execution. I think it will be farely easy
curr_group->result = exec_sanity(curr_group);
curr_group->executed++;
#ifdef DEBUG
printf("Returned from sanity function\n");
#endif
curr_group ->locked = 0;
// wake up the main application
pthread_cond_signal(&curr_group->condition);
//release mutex of the thread.
pthread_mutex_unlock(&curr_group->lock);
#ifdef DEBUG
printf("Waking up main application\n");
#endif
return;
}
