gpointer display_thread(gpointer data) { GCContext *context = (GCContext*)data; GCConfig *config = context->config; GCVDPAUContext *vdpau = &context->VDPAU_context; Movie *movie = context->movie_context; gint64 timeout = 0; int current_direction = DIRECTION_FORWARD; if (!context) g_error("Missing context\n"); movie->pre_load_surface = vdpau->surface_queue.next; load_frame(context, movie->frame_offset, movie->pre_load_surface); do { movie->pre_load_surface = display_surface(context, movie->pre_load_surface); timeout = g_get_monotonic_time() + config->seconds_per_frame * G_TIME_SPAN_SECOND; g_mutex_lock(&movie->tick_lock); if (movie->ease_to) { movie->new_frame = FALSE; easeout_to_frame(context, movie->ease_to_frame, config->easing_factor); movie->ease_to = FALSE; } while (!movie->new_frame && !movie->ease_to && !context->exit) { if (!g_cond_wait_until(&movie->tick_cond, &movie->tick_lock, timeout)) { movie->frame_offset++; movie->fract_frame_count++; movie->play_direction = DIRECTION_FORWARD; movie->new_frame = TRUE; //g_message("tick: %lu", movie->frame_offset); break; } } movie->new_frame = FALSE; g_mutex_unlock(&movie->tick_lock); load_frame(context, movie->frame_offset, movie->pre_load_surface); } while (!context->exit); munmap(movie->planes, config->movie_size); close(movie->fd_movie); vdpau_exit(context); x11_exit(context); g_main_loop_quit(context->g_main_loop); return NULL; }
static gboolean run_tests(gpointer data) { struct xdata *xdata = static_cast<struct xdata*>(data); static bool xv = false; static int i = 0; char *filename = g_strconcat(formats[i++ % G_N_ELEMENTS(formats)], ".rgb", NULL); load_frame(filename); if (frame) g_printerr("frame loaded: %s\n", filename); g_free(filename); if (create_xwindow(xv, xdata)) { xv = !xv; g_timeout_add(33, test, xdata); return FALSE; } g_printerr("xwin failed\n"); destroy_xwindow(xdata); return TRUE; }
unsigned long easeout_to_frame(GCContext *context, unsigned long destination_frame, int seconds) { GCVDPAUContext *vdpau = &context->VDPAU_context; Movie *movie = context->movie_context; unsigned long frames = 0; unsigned long sf = movie->frame_offset; long df = 0; int i = 0; // GTimer *timer = g_timer_new(); df = destination_frame - sf; frames = seconds * FPS; // g_timer_start(timer); for (i=0; i < frames; i++) { float c = (float)df * (powf((float)i / (float)frames - 1, 3) + 1); movie->frame_offset = sf + c; movie->fract_frame_count = movie->frame_offset; movie->pre_load_surface = display_surface(context, movie->pre_load_surface); load_frame(context, movie->frame_offset, movie->pre_load_surface); if (movie->new_frame) break; } // g_message("Ease done in %f seconds, at frame %lu", g_timer_elapsed(timer, NULL), movie->frame_offset); // g_timer_destroy(timer); return movie->frame_offset; }
void Metalib::reset () { Frame::reset (); load_frame_t load_frame = impl->load_frame; impl.reset (new Implementation (load_frame)); load_frame (*this); impl->initialize (*this); }
int V4LCapture::read_frame(uint8_t **data, struct v4l2_buffer *buf) { if (param.replay_mode) { int ret = load_frame(&(buffers->start), &buf_now); *data = (uint8_t *) buffers->start; *buf = buf_now; return ret; } if( (int)buf_now.index != -1 ) { if( -1 == xioctl(fd, VIDIOC_QBUF, &buf_now) ){ errno_exit("VIDIOC_QBUF"); } } CLEAR( buf_now ); buf_now.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf_now.memory = V4L2_MEMORY_MMAP; if( -1 == xioctl(fd, VIDIOC_DQBUF, &buf_now) ){ if (EAGAIN == errno) { return -1; errno_exit("EAGAIN"); } else if (EINVAL == errno) { errno_exit("EINVAL"); } else if (ENOMEM == errno) { errno_exit("ENOMEM"); } else if (EIO == errno) { errno_exit("EIO"); } else { errno_exit("VIDIOC_DQBUF"); } } struct buffer *pbuf = &buffers[buf_now.index]; if (param.record_prefix != NULL) { dump_frame((uint8_t *)pbuf->start, &buf_now); } *data = (uint8_t *) pbuf->start; *buf = buf_now; return buf_now.bytesused; }
int main(int argc, char *argv[]) { char line[PATH_MAX+10]; SDL_Surface *screen; const SDL_VideoInfo* screen_info; struct frame first_frame = blank_frame; struct frame *current_frame = &first_frame; /* Initialize SDL */ if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) < 0) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } atexit(SDL_Quit); while(fgets(line, PATH_MAX+10, stdin)) { if(line[0] && line[0] != '\n') { load_frame(line, current_frame); current_frame->next = xmalloc(sizeof(*current_frame)); *current_frame->next = blank_frame; current_frame->next->prev = current_frame; current_frame = current_frame->next; } } /* XXX Inefficient */ current_frame->prev->next = NULL; /* Get screen resolution and initialize window */ screen_info = SDL_GetVideoInfo(); if(!screen_info) { fprintf(stderr, "SDL_GetVideoInfo: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } if(!(screen = SDL_SetVideoMode(screen_info->current_w, screen_info->current_h, 0, SDL_HWSURFACE))) { fprintf(stderr, "Unable to init SDL screen: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } /* Fake the first timer event */ timer_event(0, &first_frame); /* Wait for exit events */ while(1) { SDL_Rect rect; SDL_Event event; event.type = 0; if(!SDL_WaitEvent(&event)) { fprintf(stderr, "Unable to get event: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } switch(event.type) { case SDL_USEREVENT: switch(event.user.code) { case TIMER_EVENT: current_frame = event.user.data1; /* This may already be the last slide */ if(!current_frame) { goto mainloopend; } /* Calculate where to draw the image */ rect.x = (screen->w/2)-current_frame->image->w; rect.y = (screen->h/2)-current_frame->image->h; rect.w = current_frame->image->w; rect.h = current_frame->image->h; /* Redraw dirtied background */ if(SDL_FillRect(screen, &rect, 0) != 0) { fprintf(stderr, "Unable to draw rectangle: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } /* Draw image */ if(SDL_BlitSurface(current_frame->image, NULL, screen, &rect) != 0) { fprintf(stderr, "Unable to blit frame: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } /* Update dirty rects */ SDL_UpdateRects(screen, 1, &rect); /* Wait until this slide is done before advancing */ SDL_AddTimer(current_frame->length*1000, &timer_event, current_frame->next); break; } break; case SDL_QUIT: goto mainloopend; } } mainloopend: exit(EXIT_SUCCESS); }
int mfx_encode(int cid) { mfxStatus sts = MFX_ERR_NONE; mfxSyncPoint vppsync = NULL; mfxSyncPoint encsync = NULL; mfxFrameInfo vppdefinfo; unsigned long long id = 0; unsigned long long fpsunit = 90000 / fps; memset(&vppdefinfo, 0, sizeof(vppdefinfo)); vppdefinfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE; vppdefinfo.FourCC = MFX_FOURCC_YV12; // the only difference vppdefinfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420; vppdefinfo.Width = MFX_ALIGN16(w); vppdefinfo.Height = MFX_ALIGN16(h); vppdefinfo.CropW = w; vppdefinfo.CropH = h; vppdefinfo.FrameRateExtN = fps; vppdefinfo.FrameRateExtD = 1; // while(sts >= MFX_ERR_NONE || sts == MFX_ERR_MORE_DATA) { mfxFrameSurface1 *svppin, *svppout; int framesize; unsigned char *frame = load_frame(&framesize); // if(frame == NULL) { ga_error("END-OF-FRAME\n"); break; } // svppin = frame_pool_get(_vpppool[cid][0], &_vppresponse[cid][0]); svppout = frame_pool_get(_vpppool[cid][1], &_vppresponse[cid][1]); if(svppin == NULL || svppout == NULL) { ga_error("No surface available (%p, %p)\n", svppin, svppout); break; } if(fa_lock(NULL, svppin->Data.MemId, &svppin->Data) != MFX_ERR_NONE) { ga_error("Unable to lock VPP frame\n"); break; } // fill frame info memcpy(&svppin->Info, &vppdefinfo, sizeof(mfxFrameInfo)); memcpy(&svppout->Info, &vppdefinfo, sizeof(mfxFrameInfo)); svppin->Info.FourCC = MFX_FOURCC_YV12; svppout->Info.FourCC = MFX_FOURCC_NV12; svppin->Data.TimeStamp = id * fpsunit; id++; //ga_error("In timestamp = %llu\n", svppin->Data.TimeStamp); // copy the frame do { mfxU8 *dst; int i, w2 = w/2, h2 = h/2, p2 = svppin->Data.Pitch/2; unsigned char *src = frame; // Copy Y for(dst = svppin->Data.Y, i = 0; i < h; i++) { memcpy(dst, src, w); dst += svppin->Data.Pitch; src += w; } // Copy U for(dst = svppin->Data.U, i = 0; i < h2; i++) { memcpy(dst, src, w2); dst += p2; src += w2; } // Copy V for(dst = svppin->Data.V, i = 0; i < h2; i++) { memcpy(dst, src, w2); dst += p2; src += w2; } } while(0); // if(fa_unlock(NULL, svppin->Data.MemId, &svppin->Data) != MFX_ERR_NONE) { ga_error("Unable to unlock VPP frame\n"); break; } // do VPP sts = mfx_encode_vpp(_session[cid], svppin, svppout, &vppsync); // VPP errors? if(sts == MFX_ERR_MORE_DATA) continue; if(sts == MFX_ERR_MORE_SURFACE) continue; if(sts != MFX_ERR_NONE) { mfx_invalid_status(sts); ga_error("video encoder: VPP failed.\n"); break; } // //MFXVideoCORE_SyncOperation(_session[cid], vppsync, MFX_INFINITE); // do ENCODE sts = mfx_encode_encode(_session[cid], svppout, &_mfxbs[cid], &encsync); // if(sts == MFX_ERR_MORE_DATA) continue; if(sts != MFX_ERR_NONE) { mfx_invalid_status(sts); ga_error("video encoder: encode failed.\n"); break; } // //ga_error("Out timestamp = d:%lld t:%llu\n", _mfxbs[cid].DecodeTimeStamp, _mfxbs[cid].TimeStamp); // save frame MFXVideoCORE_SyncOperation(_session[cid], encsync, MFX_INFINITE); #if 1 unsigned char *ptr = _mfxbs[cid].Data, *nextptr; int naltype, nalsize, nali = 0; int off, nextoff; // each frame can have only 1 nal ... if(ptr != NULL) ptr += _mfxbs[cid].DataOffset; off = nextoff = 4; while(ptr != NULL) { // search for startcode 00 00 01 or 00 00 00 01 for(nextptr = ptr+3; nextptr < _mfxbs[cid].Data+_mfxbs[cid].DataOffset+_mfxbs[cid].DataLength-4; nextptr++) { if(*nextptr == 0 && *(nextptr+1) == 0) { if(*(nextptr+2) == 1) { // 00 00 01 nextoff = 3; break; } else if(*(nextptr+2) == 0 && *(nextptr+3) == 1) { // 00 00 00 01 nextoff = 4; break; } } } // if(nextptr < _mfxbs[cid].Data+_mfxbs[cid].DataOffset+_mfxbs[cid].DataLength-4) { nalsize = nextptr - ptr; ga_error("XXX: nal[%d] type=%d size=%d\n", nali, *(ptr+off) & 0x1f, nalsize); ptr = nextptr; } else { nalsize = _mfxbs[cid].Data+_mfxbs[cid].DataOffset+_mfxbs[cid].DataLength-ptr; ga_error("XXX: nal[%d] type=%d size=%d\n", nali, *(ptr+off) & 0x1f, nalsize); ptr = NULL; } nali++; off = nextoff; }; #endif write_frame(_mfxbs[cid].Data, _mfxbs[cid].DataLength); _mfxbs[cid].DataLength = _mfxbs[cid].DataOffset = 0; } // while(sts >= MFX_ERR_NONE) { sts = mfx_encode_encode(_session[cid], NULL, &_mfxbs[cid], &encsync); } // return 0; }
int main(int argc, char *argv[]) { int opt; char caption[32]; regex_t reg; regmatch_t pm; int result; char picsize[32]=""; int used_s_opt = 0; int play_yuv = 0; unsigned int start_ticks = 0; Uint32 vflags; if (argc == 1) { print_usage(); return 1; } else { while((opt = getopt(argc, argv, "f:s:")) != -1) switch(opt){ case 's': if (sscanf(optarg, "%dx%d", &width, &height) != 2) { fprintf(stdout, "No geometry information provided by -s parameter.\n"); return 1; } used_s_opt = 1; break; case 'f': if (sscanf(optarg, "%d", &cfidc) != 1 || (cfidc<0 && cfidc>3)) { fprintf(stdout, "Invalid format provided by -f parameter.\n"); return 1; } break; default: print_usage(); return 1; break; } } argv += optind; argc -= optind; vfilename = argv[0]; if(!used_s_opt) { // try to find picture size from filename or path if (regcomp(®, "_[0-9]+x[0-9]+", REG_EXTENDED) != 0) return -1; result = regexec(®, vfilename, 1, &pm, REG_NOTBOL); if(result == 0){ strncpy(picsize, (vfilename + pm.rm_so + 1), (pm.rm_eo - pm.rm_so -1 )); strcat(picsize, "\0"); } if (sscanf(picsize, "%dx%d", &width, &height) != 2) { fprintf(stdout, "No geometry information found in path/filename.\nPlease use -s <width>x<height> paramter.\n"); return 1; } } // some WM can't handle small windows... if (width < 100){ zoom = 2; min_zoom = 2; } //printf("using x=%d y=%d\n", width, height); // SDL init if(SDL_Init(SDL_INIT_VIDEO) < 0){ fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError()); exit(1); } atexit(SDL_Quit); info = SDL_GetVideoInfo(); if( !info ) { fprintf(stderr, "SDL ERROR Video query failed: %s\n", SDL_GetError() ); SDL_Quit(); exit(0); } bpp = info->vfmt->BitsPerPixel; if(info->hw_available) vflags = SDL_HWSURFACE; else vflags = SDL_SWSURFACE; if( (screen = SDL_SetVideoMode(width*zoom, height*zoom, bpp, vflags)) == 0 ) { fprintf(stderr, "SDL ERROR Video mode set failed: %s\n", SDL_GetError() ); SDL_Quit(); exit(0); } // DEBUG output // printf("SDL Video mode set successfully. \nbbp: %d\nHW: %d\nWM: %d\n", // info->vfmt->BitsPerPixel, info->hw_available, info->wm_available); SDL_EnableKeyRepeat(500, 10); my_overlay = SDL_CreateYUVOverlay(width, height, SDL_YV12_OVERLAY, screen); if(!my_overlay){ //Couldn't create overlay? fprintf(stderr, "Couldn't create overlay\n"); //Output to stderr and quit exit(1); } /* should allocate memory for y_data, cr_data, cb_data here */ y_data = malloc(width * height * sizeof(Uint8)); if (cfidc > 0) { cb_data = malloc(width * height * sizeof(Uint8) / SubSizeC[cfidc]); cr_data = malloc(width * height * sizeof(Uint8) / SubSizeC[cfidc]); } fpointer = fopen(vfilename, "rb"); if (fpointer == NULL){ fprintf(stderr, "Error opening %s\n", vfilename); return 1; } // send event to display first frame event.type = SDL_KEYDOWN; event.key.keysym.sym = SDLK_RIGHT; SDL_PushEvent(&event); // main loop while (!quit){ sprintf(caption, "frame %d, zoom=%d", frame, zoom); SDL_WM_SetCaption( caption, NULL ); // wait for SDL event SDL_WaitEvent(&event); switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_SPACE: { play_yuv = 1; // play it, sam! while(play_yuv){ start_ticks = SDL_GetTicks(); sprintf(caption, "frame %d, zoom=%d", frame, zoom); SDL_WM_SetCaption( caption, NULL ); // check for next frame existing if(load_frame()){ draw_frame(); //insert delay for real time viewing if(SDL_GetTicks() - start_ticks < 40) SDL_Delay(40 - (SDL_GetTicks() - start_ticks)); frame++; } else { play_yuv = 0; } // check for any key event if(SDL_PollEvent(&event)){ if(event.type == SDL_KEYDOWN){ // stop playing play_yuv = 0; } } } break; } case SDLK_RIGHT: { // check for next frame existing if(load_frame()){ draw_frame(); frame++; } break; } case SDLK_BACKSPACE: case SDLK_LEFT: { if(frame>1){ frame--; fseek(fpointer, ((frame-1)*height*width*FrameSize2C[cfidc])/2 , SEEK_SET); //if(draw_frame()) load_frame(); draw_frame(); } break; } case SDLK_UP: { zoom++; screen = SDL_SetVideoMode(width*zoom, height*zoom, bpp, vflags); video_rect.w = width*zoom; video_rect.h = height*zoom; SDL_DisplayYUVOverlay(my_overlay, &video_rect); break; } case SDLK_DOWN: { if(zoom>min_zoom){ zoom--; screen = SDL_SetVideoMode(width*zoom, height*zoom, bpp, vflags); video_rect.w = width*zoom; video_rect.h = height*zoom; SDL_DisplayYUVOverlay(my_overlay, &video_rect); } break; } case SDLK_r: { if(frame>1){ frame=1; fseek(fpointer, 0, SEEK_SET); //if(draw_frame()) load_frame(); draw_frame(); } break; } case SDLK_g: grid = ~grid; draw_frame(); break; case SDLK_q: quit = 1; break; case SDLK_f: SDL_WM_ToggleFullScreen(screen); break; default: break; } // switch key break; case SDL_QUIT: quit = 1; break; case SDL_VIDEOEXPOSE: SDL_DisplayYUVOverlay(my_overlay, &video_rect); break; default: break; } // switch event type } // while // clean up SDL_FreeYUVOverlay(my_overlay); free(y_data); free(cb_data); free(cr_data); fclose(fpointer); if (!used_s_opt) regfree(®); return 0; }
int main(int argc, char* argv[]) { // parse cli arguments char* filepath; if (argc == 2) { filepath = argv[1]; } else { printf("usage: %s some-led-data.dat\n", argv[0]); exit(1); } prussdrv_init(); int ret = prussdrv_open(PRU_EVTOUT_0); if (ret) { printf("prussdrv_open open failed\n"); exit(1); } tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_pruintc_init(&pruss_intc_initdata); // initialize memory shared between PRU and host application init_memory(); // initialize interface to PRU pru_ctrl_init(mem_fd); // put the LED data in the file where the PRU can get it load_frame(filepath); // tell the PRU where to find the data pru_write_reg(REG_ADDRESS, (uint32_t)get_ddr_address()); // tell the PRU how many slices we have pru_write_reg(REG_SLICE_TOTAL, sliceCount); // display! ret = prussdrv_exec_program(PRU_NUM, "./driver.bin"); if (ret == -1) { printf("failed to open driver.bin\n"); exit(1); } printf("running...\nhit enter to stop.\n"); getchar(); // stall until enter is hit // cleanup // disable pru prussdrv_pru_disable(PRU_NUM); // exit PRU interfaces prussdrv_exit(); pru_ctrl_exit(); // undo memory mapping munmap(ddrMem, get_ddr_size()); close(mem_fd); return 0; }
static int app_run (App * app) { GstVaapiImage *image; GstVaapiVideoPool *pool; GThread *buffer_thread; gsize id; int ret = EXIT_FAILURE; image = gst_vaapi_image_new (app->display, GST_VIDEO_FORMAT_I420, app->parser->width, app->parser->height); { GstVideoInfo vi; gst_video_info_set_format (&vi, GST_VIDEO_FORMAT_ENCODED, app->parser->width, app->parser->height); pool = gst_vaapi_surface_pool_new_full (app->display, &vi, 0); } buffer_thread = g_thread_new ("get buffer thread", get_buffer_thread, app); while (1) { GstVaapiSurfaceProxy *proxy; GstVaapiSurface *surface; if (!load_frame (app, image)) break; if (!gst_vaapi_image_unmap (image)) break; proxy = gst_vaapi_surface_proxy_new_from_pool (GST_VAAPI_SURFACE_POOL (pool)); if (!proxy) { g_warning ("Could not get surface proxy from pool."); break; } surface = gst_vaapi_surface_proxy_get_surface (proxy); if (!surface) { g_warning ("Could not get surface from proxy."); break; } if (!gst_vaapi_surface_put_image (surface, image)) { g_warning ("Could not update surface"); break; } if (!upload_frame (app->encoder, proxy)) { g_warning ("put frame failed"); break; } app->read_frames++; id = gst_vaapi_surface_get_id (surface); g_debug ("input frame %d, surface id = %" G_GSIZE_FORMAT, app->read_frames, id); gst_vaapi_surface_proxy_unref (proxy); } app->input_stopped = TRUE; g_thread_join (buffer_thread); if (!app->encode_failed && feof (app->parser->fp)) ret = EXIT_SUCCESS; gst_vaapi_video_pool_replace (&pool, NULL); gst_vaapi_object_unref (image); return ret; }