自学教程：C++ video_init函数代码示例

void fly_init (int x0, int y0, int rows, int cols, char *font){    TID       tid;    int       rc;    ULONG     reset;    tiled1 = _tmalloc (tiled_size);    if (tiled1 == NULL) fly_error ("cannot allocate tiled memory/n");    us1_16 = _tmalloc (sizeof(USHORT));    us2_16 = _tmalloc (sizeof(USHORT));    pci = _tmalloc (sizeof(VIOCURSORINFO));    rc = DosCreateMutexSem (NULL, &mtx_Queue, 0, FALSE);    debug_tools ("rc = %d after DosCreateMutexSem/n", rc);    rc = DosCreateMutexSem (NULL, &mtx_Video, 0, FALSE);    debug_tools ("rc = %d after DosCreateMutexSem/n", rc);    rc = DosCreateEventSem (NULL, &hev_NewMessage, 0, FALSE);    debug_tools ("rc = %d after DosCreateEventSem/n", rc);    rc = DosCreateEventSem (NULL, &hev_VideoReady, 0, FALSE);    debug_tools ("rc = %d after DosCreateEventSem/n", rc);        grab_video ();    if (rows != -1 && cols != -1)        video_init (rows, cols);    else        video_init (25, 80);    release_video ();    DosResetEventSem (hev_VideoReady, &reset);    rc = DosCreateThread (&tid, interface_thread, 0, 0, 32786);    debug_tools ("rc = %d after DosCreateThread/n", rc);    DosWaitEventSem (hev_VideoReady, SEM_INDEFINITE_WAIT);    fl_opt.initialized = TRUE;    DosSleep (300);    if (font != NULL)        fly_set_font (font);    //debug_tools ("rows = %d, cols = %d in fly_init/n", rows, cols);    if (rows != -1 && cols != -1)        video_set_window_size (rows, cols);        debug_tools ("x0 = %d, y0 = %d in fly_init/n", x0, y0);    if (x0 >= 0 && y0 >= 0)        video_set_window_pos (x0, y0);}

void emulator_init(int width, int height, void *user){	LOG_INIT();	video_init(width, height, user);	mapper_init();	emulator_last_tick = 0;}

kmain() {	terminal_init();	setup_IDT_entry (&idt[0x08], 0x08, (dword)&_int_08_hand, ACS_INT, 0);	setup_IDT_entry (&idt[0x09], 0x08, (dword)&_int_09_hand, ACS_INT, 0);	setup_IDT_entry (&idt[0x74], 0x08, (dword)&_int_74_hand, ACS_INT, 0);	setup_IDT_entry (&idt[0x80], 0x08, (dword)&_int_80_hand, ACS_INT, 0);		/* IDTR Setting */ 	idtr.base = 0;  	idtr.base +=(dword) &idt;	idtr.limit = sizeof(idt)-1;		_lidt(&idtr);	/* Interrupt unmasking */		_cli();	_maskPIC1(0xF8);           /*0XF8*/	_maskPIC2(0xEF);		/*0XEF*/		_sti();	video_init();	timertick_init();	rtc_init();	mouse_init();	shell_run();}

int main(int argc, char *argv[]) {    video_init(0);    audio_init(argc, argv);    game_init();    double last = glfwGetTime();    while (running) {        double current = glfwGetTime();        int delta = (current - last) * 1000;        if (delta < MIN_DELTA) {            glfwSleep((MIN_DELTA-delta)/1000.0);            continue;        }        last = current;        now += delta;        if (delta > MAX_DELTA)            continue;        game_tick(delta);    }    audio_shutdown();    video_shutdown();    return EXIT_SUCCESS;}

void PICvision_init(void) {    HardwareConfig();    timers_init(TICK_FREQ);    video_init();    sound_init(1000/TICK_FREQ);    splash_screen();}//f()

int drv_video_init(void){    int error, devices = 1 ;    struct stdio_dev vgadev ;    if (video_inited) return 1;    video_inited = 1;    video_init();    memset (&vgadev, 0, sizeof(vgadev));    strcpy(vgadev.name, VIDEO_NAME);    vgadev.flags =  DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;    vgadev.putc = video_putc;    vgadev.puts = video_puts;    vgadev.getc = NULL;    vgadev.tstc = NULL;    vgadev.start = video_start;    error = stdio_register (&vgadev);    if (error == 0)    {	char *s = getenv("stdout");	if (s && strcmp(s, VIDEO_NAME)==0)	{	    if (overwrite_console()) return 1;	    error = console_assign(stdout, VIDEO_NAME);	    if (error == 0) return 1;	    else return error;	}	return 1;    }    return error;}

//==Part1:Controlint dtvideo_init (void **video_priv, dtvideo_para_t * para, void *parent){    int ret = 0;    dtvideo_context_t *vctx = (dtvideo_context_t *) malloc (sizeof (dtvideo_context_t));    if (!vctx)    {        dt_error (TAG, "[%s:%d] video init failed /n", __FUNCTION__, __LINE__);        ret = -1;        goto ERR0;    }    memcpy (&vctx->video_para, para, sizeof (dtvideo_para_t));    vctx->video_para.extradata_size = para->extradata_size;    memcpy (&(vctx->video_para.extradata[0]), &(para->extradata[0]), para->extradata_size);    //we need to set parent early    vctx->parent = parent;    ret = video_init (vctx);    if (ret < 0)    {        dt_error (TAG, "[%s:%d] dtvideo_mgt_init failed /n", __FUNCTION__, __LINE__);        ret = -1;        goto ERR1;    }    *video_priv = (void *) vctx;    return ret;  ERR1:    free (vctx);  ERR0:    return ret;}

void appInit(){	int status;	gAppAlive = 1;	// navigation	if (!nav_thread) {      //vp_os_thread_create( thread_navdata_loop, 0, &nav_thread);	}	// video stream	if (!stream_thread) {      vp_os_thread_create( thread_stream_loop, 0, &stream_thread);	}	// AT cmds loop	if (!at_thread) {      //vp_os_thread_create( thread_at_cmds_loop, 0, &at_thread);	}#ifdef BUILD_OGLES	// video rendering	video_init();#endif}

void osd_common_t::init_subsystems(){	if (!video_init())	{		video_exit();		osd_printf_error("video_init: Initialization failed!/n/n/n");		fflush(stderr);		fflush(stdout);		exit(-1);	}	input_init();	// we need pause callbacks	machine().add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(osd_common_t::input_pause), this));	machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(osd_common_t::input_resume), this));	output_init();	m_font_module = select_module_options<font_module *>(options(), OSD_FONT_PROVIDER);	m_sound = select_module_options<sound_module *>(options(), OSD_SOUND_PROVIDER);	m_sound->m_sample_rate = options().sample_rate();	m_sound->m_audio_latency = options().audio_latency();	m_debugger = select_module_options<debug_module *>(options(), OSD_DEBUG_PROVIDER);	select_module_options<netdev_module *>(options(), OSD_NETDEV_PROVIDER);	m_midi = select_module_options<midi_module *>(options(), OSD_MIDI_PROVIDER);	m_mod_man.init(options());}

int main(int argc, const char * argv[]) {    SDL_Event event;    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) != 0) {        printf("SDL_Init failed/n");        return(1);    }    if(video_init() != 0) {        SDL_Quit();        return(2);    }        gui_init();    while(quit == 0) {        gui_draw();        while(SDL_PollEvent(&event)) {            if(event.type == SDL_QUIT) {                quit++;            }        }        video_frameend();    }        gui_kill();    video_kill();    SDL_Quit();    return(0);}

int BIKPlayer::doPlay(){	int done = 0;	//bink is always truecolor	g_truecolor = 1;	frame_wait = 0;	timer_last_sec = 0;	video_frameskip = 0;	if (sound_init( core->GetAudioDrv()->CanPlay())) {		//sound couldn't be initialized		return 1;	}	//last parameter is to enable YUV overlay	outputwidth = (int) header.width;	outputheight= (int) header.height;	video->InitMovieScreen(outputwidth,outputheight, true);	if (video_init(outputwidth,outputheight)) {		return 2;	}	while (!done && next_frame()) {		done = video->PollMovieEvents();	}	return 0;}

int video_console_init(void){	video_init();	if (console)		console_add_output_driver(&cons);	return 0;}

voidcons_init(){	memset(&cons, 0x0, sizeof(cons));	serial_init();	video_init();	spinlock_init(&cons_lk);}

int video_console_init(void){	int ret = video_init();	if (ret)		return ret;	console_add_output_driver(&cons);	return 0;}

voidvideo_config_init(void) {  screen_mask = 1 << (((int)phys_text_base-0xA0000)/4096);  video_init();  reserve_video_memory();}

voidbecninit(struct consdev *cp){	video_init((u_char *)cp->address);	kbdreset();	kbd(1);		/* read out ugly data */}

void gtkui_cb_video_refresh() {	// Refresh the Video output after changes	if (playing) {		opengl_cleanup();		video_init();	}	else { video_set_params(); }	gtkui_resize();}

int drv_video_init(void){	int error, devices = 1;	struct stdio_dev videodev;	u8 *dst;	u32 fbmem_size = LCD_X_RES * LCD_Y_RES * LCD_PIXEL_SIZE + ACTIVE_VIDEO_MEM_OFFSET;	dst = malloc(fbmem_size);	if (dst == NULL) {		printf("Failed to alloc FB memory/n");		return -1;	}#ifdef EASYLOGO_ENABLE_GZIP	unsigned char *data = EASYLOGO_DECOMP_BUFFER;	unsigned long src_len = EASYLOGO_ENABLE_GZIP;	error = gunzip(data, bfin_logo.size, bfin_logo.data, &src_len);	bfin_logo.data = data;#elif defined(EASYLOGO_ENABLE_LZMA)	unsigned char *data = EASYLOGO_DECOMP_BUFFER;	SizeT lzma_len = bfin_logo.size;	error = lzmaBuffToBuffDecompress(data, &lzma_len,		bfin_logo.data, EASYLOGO_ENABLE_LZMA);	bfin_logo.data = data;#else	error = 0;#endif	if (error) {		puts("Failed to decompress logo/n");		free(dst);		return -1;	}	memset(dst + ACTIVE_VIDEO_MEM_OFFSET, bfin_logo.data[0], fbmem_size - ACTIVE_VIDEO_MEM_OFFSET);	dma_bitblit(dst + ACTIVE_VIDEO_MEM_OFFSET, &bfin_logo,			(LCD_X_RES - bfin_logo.width) / 2,			(LCD_Y_RES - bfin_logo.height) / 2);	video_init(dst);		/* Video initialization */	memset(&videodev, 0, sizeof(videodev));	strcpy(videodev.name, "video");	videodev.ext = DEV_EXT_VIDEO;	/* Video extensions */	videodev.flags = DEV_FLAGS_SYSTEM;	/* No Output */	videodev.putc = video_putc;	/* 'putc' function */	videodev.puts = video_puts;	/* 'puts' function */	error = stdio_register(&videodev);	return (error == 0) ? devices : error;}

int main(int argc, char *argv[]){	int err;	err = video_init(640, 480);	if(err)		error("Failed to initialize video: %s", geterrmsg());	exit(EXIT_SUCCESS);}

int main(void){    video_init();    camera_init();    tilemap_init();    plan(4);    test_basic_output();    todo();    note("exercise file reading");    end_todo;    done_testing();}

intmain(int argc, char *argv[]){	options_init();	options_deal(argc, argv);	video_init();	screen_init();	screen_mainloop();	screen_quit();	video_quit();	exit(EXIT_SUCCESS);}

int openbios(void){#ifdef CONFIG_DEBUG_CONSOLE#ifdef CONFIG_DEBUG_CONSOLE_SERIAL	uart_init(CONFIG_SERIAL_PORT, CONFIG_SERIAL_SPEED);#endif	/* Clear the screen.  */	cls();#endif        collect_sys_info(&sys_info);        dict = (unsigned char *)sys_info.dict_start;        dicthead = (cell)sys_info.dict_end;        last = sys_info.dict_last;        dictlimit = sys_info.dict_limit;	forth_init();	relocate(&sys_info);#ifdef CONFIG_DEBUG_CONSOLE_VGA	video_init();#endif#ifdef CONFIG_DEBUG_BOOT	printk("forth started./n");	printk("initializing memory...");#endif	init_memory();#ifdef CONFIG_DEBUG_BOOT	printk("done/n");#endif	PUSH_xt( bind_noname_func(arch_init) );	fword("PREPOST-initializer");	PC = (ucell)findword("initialize-of");	if (!PC) {		printk("panic: no dictionary entry point./n");		return -1;	}#ifdef CONFIG_DEBUG_DICTIONARY	printk("done (%d bytes)./n", dicthead);	printk("Jumping to dictionary.../n");#endif	enterforth((xt_t)PC);	return 0;}

int drv_video_init(void){	device_t videodev;	video_init((void *)NTSC_FRAME_ADDR);	memset(&videodev, 0, sizeof(videodev));	strcpy(videodev.name, "video");	videodev.ext = DEV_EXT_VIDEO;	videodev.flags = DEV_FLAGS_SYSTEM;	return device_register(&videodev);}

// initialize the console devicesvoidcons_init(void){	if (!cpu_onboot())	// only do once, on the boot CPU		return;	video_init();	kbd_init();	serial_init();	if (!serial_exists)		warn("Serial port does not exist!/n");}

void appInit(void){   __android_log_print( ANDROID_LOG_INFO, "ARDrone", "Enter in appInit/n" );	   // video rendering	video_init();//    int status;  //  get_drone_ip();	gAppAlive = 1;	START_THREAD( mobile_main, NULL);}

static void *video_ext_init(const video_info_t *video, const input_driver_t **input, void **input_data){   ext_t *ext = (ext_t*)calloc(1, sizeof(*ext));   if (!ext)      return NULL;   const rarch_video_driver_t *(*video_init)(void) = NULL;   if (!(*g_settings.video.external_driver))   {      RARCH_ERR("External driver needs video_external_driver path to be set./n");      goto error;   }   g_lib = dylib_load(g_settings.video.external_driver);   if (!g_lib)   {      RARCH_ERR("Failed to open library: /"%s/"/n", g_settings.video.external_driver);      goto error;   }   video_init = (const rarch_video_driver_t *(*)(void))dylib_proc(g_lib, "rarch_video_init");   if (!video_init)      video_init = (const rarch_video_driver_t *(*)(void))dylib_proc(g_lib, "ssnes_video_init"); // Compat. Will be dropped on ABI break.   if (!video_init)   {      RARCH_ERR("Couldn't find function rarch_video_init in library .../n");      goto error;   }   ext->driver = video_init();   if (!ext->driver)   {      RARCH_ERR("External driver returned invalid driver handle./n");      goto error;   }   if (!setup_video(ext, video, input, input_data))   {      RARCH_ERR("Failed to start driver./n");      goto error;   }   g_video_dead = false;   return ext;error:   video_ext_free(ext);   return NULL;}

void demo(void *fdt, uint32_t el){	int nodeoffset;	char *fbparam;	uint64_t base;	uint64_t size;	uint32_t color;	const char *cmdline;	extern void *image_start;	extern void *image_end;	/*	 * Parse /chosen/bootargs for the real base	 * of tegra framebuffer.	 */	nodeoffset = fdt_path_offset(fdt,				     "/chosen");	if (nodeoffset < 0) {		goto cont;	}	cmdline = fdt_getprop(fdt, nodeoffset,			      "bootargs", NULL);	if (cmdline == NULL) {		goto cont;	}	fbparam = strstr(cmdline, "tegra_fbmem=");	if (parse_memloc(fbparam + 12, &size, &base) == 0) {		fb_base = (void *) base;	}cont:	video_init(fb_base);	printk("We are at EL%u/n", el);	printk("We are 0x%lx bytes at %p/n",	       (uint64_t) &image_end -	       (uint64_t) &image_start,	       &image_start);	/*	 * Draw some lines diagonal lines in the bottom half of screen.	 *	 * Green: we're at EL2.	 * White: we're at EL1.	 */	color = el == 2 ? 0xff00ff00 : 0xffffffff;	bres(0, FB_ROWS / 2, FB_COLS - 1, FB_ROWS - 1, color);	bres(FB_COLS - 1, FB_ROWS / 2, 0, FB_ROWS - 1, color);	bres(1, FB_ROWS / 2, FB_COLS - 1, FB_ROWS - 2, color);	bres(FB_COLS - 2, FB_ROWS / 2, 0, FB_ROWS - 2, color);}

int main(int argc, char* argv[]) {  int i,j = 0;  unsigned int frame = 0;  char *rom_file = NULL;  int rom_size = 0;  double z80_cycles = 0;  if (argc < 2) {    fprintf(stderr, "Usage: %s ROM_FILE/n", argv[0]);    return 1;  }  rom_file = argv[1];  memory_init();  rom_size = memory_load(rom_file);  if (rom_size < 0) {    fprintf(stderr, "Couldn't read ROM file %s/n", rom_file);    return 1;  }  printf("Read ROM %s (%d bytes)/n", rom_file, rom_size);  io_init();  video_init();  input_init();  vpu_init();  Z80Reset(&z80_state);  z80_state.pc = 0;  while (input_quit() == 0) {    z80_cycles += Z80Emulate(&z80_state, Z80_CYCLES_PER_STEP);    vpu_draw_screen();    video_flip();    video_wait_frame();    input_process();    Z80NonMaskableInterrupt (&z80_state);    frame++;  }  printf("Ran %d frames and %f Z80 cycles./n", frame, z80_cycles);  return 0;}

/* * init sdl2 render * args: *    width - overlay width *    height - overlay height *    flags - window flags: *              0- none *              1- fullscreen *              2- maximized * * asserts: * * returns: error code (0 ok) */ int init_render_sdl2(int width, int height, int flags) {	int err = video_init(width, height, flags);	if(err)	{		fprintf(stderr, "RENDER: Couldn't init the SDL2 rendering engine/n");		return -1;	}	assert(rending_texture != NULL);	return 0; }