int main(int argc, char *argv[]) { const unsigned int width = 640; const unsigned int height = 480; struct display *display; struct window *window; display = display_open(); if (!display) { fprintf(stderr, "failed to open display\n"); return 1; } window = window_create(display, argv[0], 0, 0, width, height); if (!window) { fprintf(stderr, "failed to create window\n"); return 1; } window_show(window); event_loop(window); window_close(window); display_close(display); return 0; }
int main(int argc, char *argv[]) { display_init(); intro_display(); /*User function calls */ getch(); display_close(); return 0; }
static gboolean gst_sh_video_sink_stop (GstBaseSink *bsink) { GstSHVideoSink *sink = GST_SH_VIDEO_SINK (bsink); GST_DEBUG_OBJECT(sink,"STOP, closing devices."); display_close(sink->display); return TRUE; }
/** * @brief Initialize the console * * Initialize the console system. This will initialize the video properly, so * a call to the display_init() fuction is not necessary. */ void console_init() { /* In case they initialized the display already */ display_close(); display_init( RESOLUTION_320x240, DEPTH_16_BPP, 2, GAMMA_NONE, ANTIALIAS_RESAMPLE ); render_buffer = malloc(CONSOLE_SIZE); console_clear(); console_set_render_mode(RENDER_AUTOMATIC); /* Register ourselves with newlib */ hook_stdio_calls( &console_calls ); }
void file_is_unloaded() { // stop decode window display_close(engine); engine = NULL; set_GOP_selected(0); // toggle our file options gtk_widget_set_sensitive(menu_load_mpeg2, TRUE); gtk_widget_set_sensitive(menu_load_clip_list, TRUE); gtk_widget_set_sensitive(menu_save_clip_list, FALSE); gtk_widget_set_sensitive(menu_export_mpeg2, FALSE); gtk_widget_set_sensitive(menu_close, FALSE); gtk_widget_set_sensitive(menu_delete, FALSE); gtk_widget_set_sensitive(menu_clear, FALSE); gtk_widget_set_sensitive(menu_video_window, FALSE); gtk_widget_set_sensitive(button_run, FALSE); gtk_widget_set_sensitive(button_prev, FALSE); gtk_widget_set_sensitive(button_next, FALSE); gtk_widget_set_sensitive(button_refresh, FALSE); gtk_widget_set_sensitive(button_start_mark, FALSE); gtk_widget_set_sensitive(button_end_mark, FALSE); // adjust the slider scales gtk_range_set_range(GTK_RANGE(GOP_selector), 0.0, 0.1); gtk_spin_button_set_range(GTK_SPIN_BUTTON(GOP_selector_spinbutton), 0.0, 0.1); // wipe out GOP info window clear_GOP_info(); // wipe out clip window clear_GOP_slices(); // reset parser mpeg2parser->reset(); if (error_dialog) { // hide the errors (no errors now!) gtk_widget_hide(error_dialog); } }
void sig_die (char *str, ...) { char *out; va_list argp; display_close (); va_start (argp, str); vasprintf (&out, str, argp); va_end (argp); printf ("%s", out); free (out); exit (1); }
void file_is_loaded() { List *GOPs; List *pictures; gchar buf[128]; char *pathname; int picture_count = 0; // toggle our file options gtk_widget_set_sensitive(menu_load_mpeg2, FALSE); gtk_widget_set_sensitive(menu_load_clip_list, FALSE); gtk_widget_set_sensitive(menu_save_clip_list, TRUE); gtk_widget_set_sensitive(menu_export_mpeg2, TRUE); gtk_widget_set_sensitive(menu_close, TRUE); gtk_widget_set_sensitive(menu_delete, TRUE); gtk_widget_set_sensitive(menu_clear, TRUE); gtk_widget_set_sensitive(menu_video_window, TRUE); gtk_widget_set_sensitive(button_run, TRUE); gtk_widget_set_sensitive(button_prev, TRUE); gtk_widget_set_sensitive(button_next, TRUE); gtk_widget_set_sensitive(button_refresh, TRUE); gtk_widget_set_sensitive(button_start_mark, TRUE); gtk_widget_set_sensitive(button_end_mark, FALSE); // adjust the slider scales gtk_range_set_range(GTK_RANGE(GOP_selector), 0.0, (gdouble) (mpeg2parser->numGOPs())); gtk_spin_button_set_range(GTK_SPIN_BUTTON(GOP_selector_spinbutton), 0.0, (gdouble) (mpeg2parser->numGOPs()-1)); // start decode window display_close(engine); engine = display_open(desired_output,opt_pipe,opt_videoout,opt_show_states); set_GOP_selected(0); flush(); slider_updated_actions(0); pathname = mpeg2parser->getFilename(); if (!pathname) pathname = "unknown"; gtk_label_set_text(GTK_LABEL(GOP_label_filename), pathname); }
void sig_cleanexit (char *str, ...) { char *out; va_list argp; display_close (); editor_fini (); va_start (argp, str); vasprintf (&out, str, argp); va_end (argp); printf ("%s", out); free (out); exit (0); }
/* main code entry point */ int main(void) { display_context_t _dc; char temp[128]; int res = 0; unsigned short buttons, previous = 0; init_n64(); while (1) { int j; int width[4] = { 320, 640, 256, 512 }; int height[4] = { 240, 480, 240, 480 }; unsigned int color; _dc = lockVideo(1); color = graphics_make_color(0xCC, 0xCC, 0xCC, 0xFF); graphics_fill_screen(_dc, color); color = graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF); graphics_draw_line(_dc, 0, 0, width[res]-1, 0, color); graphics_draw_line(_dc, width[res]-1, 0, width[res]-1, height[res]-1, color); graphics_draw_line(_dc, width[res]-1, height[res]-1, 0, height[res]-1, color); graphics_draw_line(_dc, 0, height[res]-1, 0, 0, color); graphics_draw_line(_dc, 0, 0, width[res]-1, height[res]-1, color); graphics_draw_line(_dc, 0, height[res]-1, width[res]-1, 0, color); color = graphics_make_color(0x00, 0x00, 0x00, 0xFF); graphics_set_color(color, 0); printText(_dc, "Video Resolution Test", width[res]/16 - 10, 3); switch (res) { case 0: printText(_dc, "320x240", width[res]/16 - 3, 5); break; case 1: printText(_dc, "640x480", width[res]/16 - 3, 5); break; case 2: printText(_dc, "256x240", width[res]/16 - 3, 5); break; case 3: printText(_dc, "512x480", width[res]/16 - 3, 5); break; } for (j=0; j<8; j++) { sprintf(temp, "Line %d", j); printText(_dc, temp, 3, j); sprintf(temp, "Line %d", height[res]/8 - j - 1); printText(_dc, temp, 3, height[res]/8 - j - 1); } printText(_dc, "0123456789", 0, 16); printText(_dc, "9876543210", width[res]/8 - 10, 16); unlockVideo(_dc); while (1) { // wait for change in buttons buttons = getButtons(0); if (buttons ^ previous) break; delay(1); } if (A_BUTTON(buttons ^ previous)) { // A changed if (!A_BUTTON(buttons)) { resolution_t mode[4] = { RESOLUTION_320x240, RESOLUTION_640x480, RESOLUTION_256x240, RESOLUTION_512x480 }; res = (res+1) & 3; display_close(); display_init(mode[res], DEPTH_16_BPP, 2, GAMMA_NONE, ANTIALIAS_RESAMPLE); } } previous = buttons; } return 0; }
int main (int argc, char **argv) { SADisplay *display; VisVideo *video; VisInput *input; VisActor *actor; VisEventQueue *localqueue; VisVideoAttributeOptions *vidoptions; int running = TRUE; int fullscreen = FALSE; int visible = TRUE; int depth; //visual_mem_alloc_install_vtable (visual_mem_alloc_vtable_profile ()); visual_init (&argc, &argv); display = display_new (sdl_driver_new ()); /* Libvisual stuff */ if (argc > 1) actor = visual_actor_new (argv[1]); else actor = visual_actor_new ("projectM"); if (argc > 3) { depth = visual_video_depth_enum_from_value (atoi (argv[3])); } else depth = visual_video_depth_get_highest (visual_actor_get_supported_depth (actor)); vidoptions = visual_actor_get_video_attribute_options (actor); display_create (display, depth, vidoptions, 480, 360, TRUE); visual_actor_realize (actor); video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, 0, FALSE, FALSE); if (argc > 2) input = visual_input_new (argv[2]); else input = visual_input_new ("alsa"); visual_input_realize (input); localqueue = visual_event_queue_new (); while (running) { VisEventQueue *pluginqueue; VisEvent *ev; /* Handle all events */ display_drain_events (display, localqueue); pluginqueue = visual_plugin_get_eventqueue (visual_actor_get_plugin (actor)); while (visual_event_queue_poll_by_reference (localqueue, &ev)) { if (ev->type != VISUAL_EVENT_RESIZE) visual_event_queue_add (pluginqueue, ev); switch (ev->type) { case VISUAL_EVENT_RESIZE: video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, depth, FALSE, FALSE); break; case VISUAL_EVENT_MOUSEMOTION: break; case VISUAL_EVENT_MOUSEBUTTONDOWN: break; case VISUAL_EVENT_MOUSEBUTTONUP: break; case VISUAL_EVENT_KEYDOWN: switch (ev->event.keyboard.keysym.sym) { case VKEY_ESCAPE: running = FALSE; break; case VKEY_TAB: fullscreen = !fullscreen; display_set_fullscreen (display, fullscreen, TRUE); /* Resync video */ video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, depth, FALSE, FALSE); break; default: printf ("key: %c\n", ev->event.keyboard.keysym.sym); break; } break; case VISUAL_EVENT_KEYUP: break; case VISUAL_EVENT_QUIT: running = FALSE; break; case VISUAL_EVENT_VISIBILITY: visible = ev->event.visibility.is_visible; break; default: break; } } if (visible == FALSE) { visual_input_run (input); visual_time_usleep (10000); continue; } /* Do a run cycle */ visual_input_run (input); display_lock (display); visual_actor_run (actor, input->audio); display_unlock (display); display_update_all (display); display_fps_limit (display, 30); } /* Termination procedure */ display_set_fullscreen (display, FALSE, TRUE); display_close (display); visual_quit (); //visual_mem_alloc_profile (); printf ("Total frames: %d, average fps: %f\n", display_fps_total (display), display_fps_average (display)); return 0; }
void display_cycle(void) { unsigned long counter; int ch; counter = loopDelay; while (--counter); if (!(cycle & keyDelay)) { #if defined(DJGPP) || defined(WATCOM) #if defined(DOSALLGRAPHX) if (displayMode == TEXT) #ifdef CONIOGRAPHX CacheScreenUpdate(Screen[CORE_PAGE]); #else ScreenUpdate((void *) Screen[CORE_PAGE]); #endif #else #if defined(DOSTXTGRAPHX) #ifdef CONIOGRAPHX CacheScreenUpdate(Screen[CORE_PAGE]); #else ScreenUpdate((void *) Screen[CORE_PAGE]); #endif #endif /* DOSTXTGRAPHX */ #endif /* DOSALLGRAPHX */ #endif /* DJGPP */ #if defined(DOSALLGRAPHX) if (displayMode != TEXT) bgi_update_cycle_meter(); #else #if defined(DOSGRXGRAPHX) bgi_update_cycle_meter(); #endif #endif if (KEYPRESSED && !inputRedirection) { switch (ch = getch()) { case '0': displayLevel = 0; break; case '1': displayLevel = 1; break; case '2': displayLevel = 2; break; case '3': displayLevel = 3; break; case '4': displayLevel = 4; break; case 'd': debugState = STEP; /* stepping = FALSE; */ break; case '>': if (displaySpeed > 0) { --displaySpeed; loopDelay = loopDelayAr[displaySpeed]; keyDelay = keyDelayAr[displaySpeed]; } break; case '<': if (displaySpeed < SPEEDLEVELS - 1) { ++displaySpeed; loopDelay = loopDelayAr[displaySpeed]; keyDelay = keyDelayAr[displaySpeed]; } break; case ' ': case 'r': #if defined(DOSALLGRAPHX) if (displayMode == TEXT) text_display_clear(); else bgi_clear_arena(); #else #if defined(DOSTXTGRAPHX) text_display_clear(); #else bgi_clear_arena(); #endif #endif break; case 27: /* escape */ case 'q': display_close(); Exit(USERABORT); #if defined(DOSALLGRAPHX) case 'v': if (displayMode == TEXT) displayMode = GRX; else bgi_display_close(NOWAIT); display_init(); break; #endif #if 0 #if defined(DOSALLGRAPHX) case '?': case 'h': if (displayMode == TEXT) disp_help(); break; #else #if defined(DOSTXTGRAPHX) case '?': case 'h': disp_help(); break; #endif #endif #endif /* 0 */ default: if (ch > 32 && ch < 128) ch += 128; ungetch(ch); debugState = STEP; break; } #if defined(DOSALLGRAPHX) if (displayMode != TEXT) write_menu(); #else #if defined(DOSGRXGRAPHX) write_menu(); #endif #endif } } }
int main(int argc, char **argv) { struct hostent * host = NULL; int net_preopen_result; #ifdef ENABLE_IPV6 struct addrinfo hints, *res; int error; struct hostent trhost; char * alptr[2]; struct sockaddr_in * sa4; struct sockaddr_in6 * sa6; #endif /* Get the raw sockets first thing, so we can drop to user euid immediately */ if ( ( net_preopen_result = net_preopen () ) ) { fprintf( stderr, "mtr: unable to get raw sockets.\n" ); exit( EXIT_FAILURE ); } /* Now drop to user permissions */ if (setgid(getgid()) || setuid(getuid())) { fprintf (stderr, "mtr: Unable to drop permissions.\n"); exit(1); } /* Double check, just in case */ if ((geteuid() != getuid()) || (getegid() != getgid())) { fprintf (stderr, "mtr: Unable to drop permissions.\n"); exit(1); } /* reset the random seed */ srand (getpid()); display_detect(&argc, &argv); /* The field options are now in a static array all together, but that requires a run-time initialization. */ init_fld_options (); parse_mtr_options (getenv ("MTR_OPTIONS")); parse_arg (argc, argv); while (optind < argc) { char* name = argv[optind++]; append_to_names(argv[0], name); } /* Now that we know mtrtype we can select which socket to use */ if (net_selectsocket() != 0) { fprintf( stderr, "mtr: Couldn't determine raw socket type.\n" ); exit( EXIT_FAILURE ); } if (PrintVersion) { printf ("mtr " MTR_VERSION "\n"); exit(0); } if (PrintHelp) { printf("usage: %s [-hvrwctglspniuT46] [--help] [--version] [--report]\n" "\t\t[--report-wide] [--report-cycles=COUNT] [--curses] [--gtk]\n" "\t\t[--csv|-C] [--raw] [--split] [--mpls] [--no-dns] [--show-ips]\n" "\t\t[--address interface] [--filename=FILE|-F]\n" /* BL */ #ifdef IPINFO "\t\t[--ipinfo=item_no|-y item_no]\n" "\t\t[--aslookup|-z]\n" #endif "\t\t[--psize=bytes/-s bytes]\n" /* ok */ "\t\t[--report-wide|-w] [-u|-T] [--port=PORT] [--timeout=SECONDS]\n" /* rew */ "\t\t[--interval=SECONDS] HOSTNAME\n", argv[0]); exit(0); } time_t now = time(NULL); if (!names) append_to_names (argv[0], "localhost"); // default: localhost. names_t* head = names; while (names != NULL) { Hostname = names->name; // if (Hostname == NULL) Hostname = "localhost"; // no longer necessary. if (gethostname(LocalHostname, sizeof(LocalHostname))) { strcpy(LocalHostname, "UNKNOWNHOST"); } if (net_preopen_result != 0) { fprintf(stderr, "mtr: Unable to get raw socket. (Executable not suid?)\n"); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } #ifdef ENABLE_IPV6 /* gethostbyname2() is deprecated so we'll use getaddrinfo() instead. */ bzero( &hints, sizeof hints ); hints.ai_family = af; hints.ai_socktype = SOCK_DGRAM; error = getaddrinfo( Hostname, NULL, &hints, &res ); if ( error ) { if (error == EAI_SYSTEM) perror ("Failed to resolve host"); else fprintf (stderr, "Failed to resolve host: %s\n", gai_strerror(error)); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } /* Convert the first addrinfo into a hostent. */ host = &trhost; bzero( host, sizeof trhost ); host->h_name = res->ai_canonname; host->h_aliases = NULL; host->h_addrtype = res->ai_family; af = res->ai_family; host->h_length = res->ai_addrlen; host->h_addr_list = alptr; switch ( af ) { case AF_INET: sa4 = (struct sockaddr_in *) res->ai_addr; alptr[0] = (void *) &(sa4->sin_addr); break; case AF_INET6: sa6 = (struct sockaddr_in6 *) res->ai_addr; alptr[0] = (void *) &(sa6->sin6_addr); break; default: fprintf( stderr, "mtr unknown address type\n" ); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } alptr[1] = NULL; #else host = gethostbyname(Hostname); if (host == NULL) { herror("mtr gethostbyname"); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } af = host->h_addrtype; #endif if (net_open(host) != 0) { fprintf(stderr, "mtr: Unable to start net module.\n"); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } if (net_set_interfaceaddress (InterfaceAddress) != 0) { fprintf( stderr, "mtr: Couldn't set interface address.\n" ); if ( DisplayMode != DisplayCSV ) exit(EXIT_FAILURE); else { names = names->next; continue; } } lock(argv[0], stdout); display_open(); dns_open(); display_mode = 0; display_loop(); net_end_transit(); display_close(now); unlock(argv[0], stdout); if ( DisplayMode != DisplayCSV ) break; else names = names->next; } net_close(); while (head != NULL) { names_t* item = head; free(item->name); item->name = NULL; head = head->next; free(item); item = NULL; } head=NULL; return 0; }
extern "C" int main(int argc , char** argv) { int preview_width = 640; int preview_height = 480; V4l2 * camera = new V4l2(NULL, preview_width, preview_height); camera->v4l2_config(preview_width, preview_height, V4l2_YUV422P); display_cfg * disconf = NULL; int ret = display_open(&disconf); if(ret != 0) { printf("display_open is error %d\n", ret); } disconf->bpp = 16; disconf->format = FORMAT_PLANAR_422; disconf->screen_width = 320; disconf->screen_height = 480; disconf->screen_pos_x = 0; disconf->screen_pos_y = 0; disconf->step = 640; disconf->height = 480; ret = display_config(disconf); if( ret != 0 ) { display_close(&disconf); printf("overlay2 config error... close"); } unsigned char * src[3] = {0}; while(1) { if(!camera->getNextFrameAsYuv422(src)) { printf("getNextFrameAsYuv422 is error\n"); goto camera_stop; break; } ret = copy_to_overlay(disconf, src); if(ret != 0) { printf("copy_to_overlay is error %d\n", ret); goto camera_stop; break; } }; camera_stop: delete camera; display_close(&disconf); return 0; };
void * evas_software_wince_gapi_init(HWND window, int width, int height) { WCHAR oemstr[100]; _GAPI_Display_Properties prop; HMODULE gapi_lib; Evas_Engine_WinCE_GAPI_Priv *priv; gapi_display_open display_open = NULL; gapi_display_close display_close = NULL; gapi_display_properties_get display_properties_get = NULL; gapi_draw_begin draw_begin = NULL; gapi_draw_end draw_end = NULL; priv = (Evas_Engine_WinCE_GAPI_Priv *)malloc(sizeof(Evas_Engine_WinCE_GAPI_Priv)); if (!priv) return NULL; gapi_lib = LoadLibrary(L"\\Windows\\gx.dll"); if (!gapi_lib) { gapi_lib = LoadLibrary(L"gx.dll"); if (!gapi_lib) { ERR("[Engine] [WinCE GAPI] Can not load gx.dll"); goto free_priv; } } LINK(display_open, display_open, L"?GXOpenDisplay@@YAHPAUHWND__@@K@Z"); LINK(display_close, display_close, L"?GXCloseDisplay@@YAHXZ"); LINK(display_properties_get, display_properties_get, L"?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ"); LINK(draw_begin, draw_begin, L"?GXBeginDraw@@YAPAXXZ"); LINK(draw_end, draw_end, L"?GXEndDraw@@YAHXZ"); LINK(suspend, suspend, L"?GXSuspend@@YAHXZ" ); LINK(resume, resume, L"?GXResume@@YAHXZ" ); if (!display_open || !display_close || !display_properties_get || !draw_begin || !draw_end || !suspend || !resume) { ERR("[Engine] [WinCE GAPI] Can not find valid symbols"); goto free_lib; } if (!display_open(window, GX_FULLSCREEN)) { ERR("[Engine] [WinCE GAPI] Can not open display"); goto free_lib; } prop = display_properties_get(); // verify pixel format if(!(prop.ffFormat & kfDirect565) || (prop.cBPP != 16)) { ERR("[Engine] [WinCE GAPI] display format mismatch\n"); goto close_display; } // verify we have a vga device if ((GetSystemMetrics(SM_CXSCREEN) != (int)prop.cxWidth) || (GetSystemMetrics(SM_CYSCREEN) != (int)prop.cyHeight)) { ERR("[Engine] [WinCE GAPI] display size mismatch\n"); goto close_display; } priv->lib = gapi_lib; priv->close_display = display_close; priv->draw_begin = draw_begin; priv->draw_end = draw_end; /* GAPI on Ipaq H38** and H39** is completely buggy */ /* They are detected as portrait device (width = 240 and height = 320) */ /* but the framebuffer is managed like a landscape device : */ /* 240 +---------+ | | | | | | | | | | 320 | ^^^ | | ||| | | ||| | | ||| | +---------+ ----> */ /* So these devices are considered as landscape devices */ /* and width and height are switched. */ /* Other devices are managed normally : */ /* 240 +---------+ | |---> | | |---> | | |---> | v | | | | 320 | | | | | | | | +---------+ */ SystemParametersInfo (SPI_GETOEMINFO, sizeof (oemstr), oemstr, 0); if (((oemstr[12] == 'H') && (oemstr[13] == '3') && (oemstr[14] == '8')) || ((oemstr[12] == 'H') && (oemstr[13] == '3') && (oemstr[14] == '9'))) { _GXDeviceInfo gxInfo = { 0 }; HDC dc; int result; priv->width = prop.cyHeight; priv->height = prop.cxWidth; priv->stride = prop.cbxPitch; dc = GetDC (window); if (!dc) { ERR("[Engine] [WinCE GAPI] Can not get device\n"); goto close_display; } gxInfo.Version = 100; result = ExtEscape(dc, GETGXINFO, 0, NULL, sizeof(gxInfo), (char *) &gxInfo); if (result <= 0) { ERR("[Engine] [WinCE GAPI] ExtEscape failed\n"); ReleaseDC(window, dc); goto close_display; } priv->buffer = gxInfo.pvFrameBuffer; ReleaseDC(window, dc); } else { priv->width = prop.cxWidth; priv->height = prop.cyHeight; priv->stride = prop.cbyPitch; priv->buffer = NULL; } if ((priv->width != width) || (priv->height != height)) { ERR("[Engine] [WinCE GAPI] Size mismatch\n"); ERR("[Engine] [WinCE GAPI] asked: %dx%d\n", width, height); ERR("[Engine] [WinCE GAPI] got : %dx%d\n", priv->width, priv->height); goto close_display; } return priv; close_display: display_close(); free_lib: FreeLibrary(gapi_lib); free_priv: free(priv); return NULL; }
int main ( int argc, char* argv[] ) { // We have to be told where MPD is running. char* host = "guanaco"; // Well, that's mine. Maybe this should be localhost. int port = 6600; // The standard MPD port. // Default database. char* database = "album_art.sqlite3"; bool bad_argument = false; int c; // Start the logger. main_data.logger = log_init(); while ( 1 ) { int option_index = 0; static struct option long_options[] = { { "host", required_argument, 0, 'h' }, { "port", required_argument, 0, 'p' }, { "database", required_argument, 0, 'd' }, { 0, 0, 0, 0 } }; c = getopt_long( argc, argv, "h:p:d:", long_options, &option_index ); if ( c == -1 ) { break; } switch ( c ) { case 'h': if ( *optarg == '\0' ) { bad_argument = true; printf( "--host argument must be non-empty\n" ); } host = optarg; break; case 'p': #if 0 port = optarg; { int port_n = convert_int( optarg ); if ( errno != 0 ) { bad_argument = true; printf( "--port argument was not a valid integer: '%s' (%s)\n", optarg, strerror( errno ) ); } if ( port_n <= 0 ) { bad_argument = true; printf( "--port argument must be positive (%s)\n", port ); } } #else { port = convert_int( optarg ); if ( errno != 0 ) { bad_argument = true; printf( "--port argument was not a valid integer: '%s' (%s)\n", optarg, strerror( errno ) ); } if ( port <= 0 ) { bad_argument = true; printf( "--port argument must be positive (%d)\n", port ); } } #endif break; case 'd': if ( *optarg == '\0' ) { bad_argument = true; printf( "--database argument must be non-empty\n" ); } database = optarg; break; default: bad_argument = true; printf( "?? getopt returned character code 0%o ??\n", c ); } } if ( bad_argument ) { printf( USAGE, argv[0] ); return 1; } log_message_info( main_data.logger, "MPD host: '%s'", host ); log_message_info( main_data.logger, "MPD port: '%d'", port ); log_message_info( main_data.logger, "Database: '%s'", database ); main_data.mpd = mpd_create( host, port, main_data.logger ); if ( mpd_status( main_data.mpd ) < 0 ) { printf( USAGE, argv[0] ); return 1; } // Try to open the image database connection. main_data.image_db = image_db_create( database, main_data.logger ); // If we get this far, we can try to initialize the graphics. main_data.display = display_init( main_data.image_db, main_data.mpd ); if ( display_status( main_data.display ) < 0 ) { return 1; } // Well, after all that, we can now start polling MPD to see what's up. main_data.loop = g_main_loop_new( NULL, FALSE ); // Poll MPD periodically. (void)g_timeout_add_seconds( 1, poll_mpd, &main_data ); // Also try to poll the buttons on the Pibrella (if it is configured // properly). add_pibrella_button10( &main_data ); add_pibrella_button11( &main_data ); // Mouse or touch screen events. add_event( &main_data ); g_main_loop_run( main_data.loop ); log_message_info( main_data.logger, "Done with main loop. Cleaning up." ); g_main_loop_unref( main_data.loop ); display_close( main_data.display ); mpd_free( main_data.mpd ); log_close( main_data.logger ); return 0; }
int main(int argc, char *argv[]) { int col, row; /* to menage start (source) raster map */ struct Range start_range; CELL start_range_min, start_range_max; int start_is_time; /* 0 or 1 */ struct { struct Option *max, *dir, *base, *start, *spotdist, *velocity, *mois, *least, *comp_dens, *init_time, *time_lag, *backdrop, *out, *x_out, *y_out; } parm; struct { /* please, remove display before GRASS 7 released */ struct Flag *display, *spotting, *start_is_time; } flag; struct GModule *module; /* initialize access to database and create temporary files */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("fire")); G_add_keyword(_("spread")); G_add_keyword(_("hazard")); module->label = _("Simulates elliptically anisotropic spread."); module->description = _("Generates a raster map of the cumulative time of spread, " "given raster maps containing the rates of spread (ROS), " "the ROS directions and the spread origins. " "It optionally produces raster maps to contain backlink UTM " "coordinates for tracing spread paths. " "Usable for fire spread simulations."); parm.max = G_define_option(); parm.max->key = "max"; parm.max->type = TYPE_STRING; parm.max->required = YES; parm.max->gisprompt = "old,cell,raster"; parm.max->guisection = _("Input maps"); parm.max->label = _("Raster map containing maximal ROS (cm/min)"); parm.max->description = _("Name of an existing raster map layer in the user's current " "mapset search path containing the maximum ROS values (cm/minute)."); parm.dir = G_define_option(); parm.dir->key = "dir"; parm.dir->type = TYPE_STRING; parm.dir->required = YES; parm.dir->gisprompt = "old,cell,raster"; parm.dir->guisection = _("Input maps"); parm.dir->label = _("Raster map containing directions of maximal ROS (degree)"); parm.dir->description = _("Name of an existing raster map layer in the user's " "current mapset search path containing directions of the maximum ROSes, " "clockwise from north (degree)."); /* TODO: clockwise from north? see r.ros */ parm.base = G_define_option(); parm.base->key = "base"; parm.base->type = TYPE_STRING; parm.base->required = YES; parm.base->gisprompt = "old,cell,raster"; parm.base->guisection = _("Input maps"); parm.base->label = _("Raster map containing base ROS (cm/min)"); parm.base->description = _("Name of an existing raster map layer in the user's " "current mapset search path containing the ROS values in the directions " "perpendicular to maximum ROSes' (cm/minute). These ROSes are also the ones " "without the effect of directional factors."); parm.start = G_define_option(); parm.start->key = "start"; parm.start->type = TYPE_STRING; parm.start->required = YES; parm.start->gisprompt = "old,cell,raster"; parm.start->guisection = _("Input maps"); parm.start->description = _("Raster map containing starting sources"); parm.start->description = _("Name of an existing raster map layer in the " "user's current mapset search path containing starting locations of the " "spread phenomenon. Any positive integers in this map are recognized as " "starting sources (seeds)."); parm.spotdist = G_define_option(); parm.spotdist->key = "spot_dist"; parm.spotdist->type = TYPE_STRING; parm.spotdist->gisprompt = "old,cell,raster"; parm.spotdist->guisection = _("Input maps"); parm.spotdist->label = _("Raster map containing maximal spotting distance (m, required with -s)"); parm.spotdist->description = _("Name of an existing raster map layer in " "the user's current mapset search path containing the maximum potential " "spotting distances (meters)."); parm.velocity = G_define_option(); parm.velocity->key = "w_speed"; parm.velocity->type = TYPE_STRING; parm.velocity->gisprompt = "old,cell,raster"; parm.velocity->guisection = _("Input maps"); parm.velocity->label = _("Raster map containing midflame wind speed (ft/min, required with -s)"); parm.velocity->description = _("Name of an existing raster map layer in the " "user's current mapset search path containing wind velocities at half of " "the average flame height (feet/minute)."); parm.mois = G_define_option(); parm.mois->key = "f_mois"; parm.mois->type = TYPE_STRING; parm.mois->gisprompt = "old,cell,raster"; parm.mois->guisection = _("Input maps"); parm.mois->label = _("Raster map containing fine fuel moisture of the cell receiving a spotting firebrand (%, required with -s)"); parm.mois->description = _("Name of an existing raster map layer in the " "user's current mapset search path containing the 1-hour (<.25\") fuel " "moisture (percentage content multiplied by 100)."); parm.least = G_define_option(); parm.least->key = "least_size"; parm.least->type = TYPE_STRING; parm.least->key_desc = "odd int"; parm.least->options = "3,5,7,9,11,13,15"; parm.least->description = _("Basic sampling window size needed to meet certain accuracy (3)"); /* TODO: what is 3 here? default? */ parm.least->description = _("An odd integer ranging 3 - 15 indicating " "the basic sampling window size within which all cells will be considered " "to see whether they will be reached by the current spread cell. The default " "number is 3 which means a 3x3 window."); parm.comp_dens = G_define_option(); parm.comp_dens->key = "comp_dens"; parm.comp_dens->type = TYPE_STRING; parm.comp_dens->key_desc = "decimal"; parm.comp_dens->label = _("Sampling density for additional computing (range: 0.0 - 1.0 (0.5))"); /* TODO: again, what is 0.5?, TODO: range not set */ parm.comp_dens->description = _("A decimal number ranging 0.0 - 1.0 indicating " "additional sampling cells will be considered to see whether they will be " "reached by the current spread cell. The closer to 1.0 the decimal number " "is, the longer the program will run and the higher the simulation accuracy " "will be. The default number is 0.5."); parm.init_time = G_define_option(); parm.init_time->key = "init_time"; parm.init_time->type = TYPE_STRING; parm.init_time->key_desc = "int (>= 0)"; /* TODO: move to ->options */ parm.init_time->answer = "0"; parm.init_time->label = _("Initial time for current simulation (0) (min)"); parm.init_time->description = _("A non-negative number specifying the initial " "time for the current spread simulation (minutes). This is useful when multiple " "phase simulation is conducted. The default time is 0."); parm.time_lag = G_define_option(); parm.time_lag->key = "lag"; parm.time_lag->type = TYPE_STRING; parm.time_lag->key_desc = "int (>= 0)"; /* TODO: move to ->options */ parm.time_lag->description = _("Simulating time duration LAG (fill the region) (min)"); /* TODO: what does this mean? */ parm.time_lag->description = _("A non-negative integer specifying the simulating " "duration time lag (minutes). The default is infinite, but the program will " "terminate when the current geographic region/mask has been filled. It also " "controls the computational time, the shorter the time lag, the faster the " "program will run."); /* TODO: what's this? probably display, so remove */ parm.backdrop = G_define_option(); parm.backdrop->key = "backdrop"; parm.backdrop->type = TYPE_STRING; parm.backdrop->gisprompt = "old,cell,raster"; parm.backdrop->label = _("Name of raster map as a display backdrop"); parm.backdrop->description = _("Name of an existing raster map layer in the " "user's current mapset search path to be used as the background on which " "the \"live\" movement will be shown."); parm.out = G_define_option(); parm.out->key = "output"; parm.out->type = TYPE_STRING; parm.out->required = YES; parm.out->gisprompt = "new,cell,raster"; parm.out->guisection = _("Output maps"); parm.out->label = _("Raster map to contain output spread time (min)"); parm.out->description = _("Name of the new raster map layer to contain " "the results of the cumulative spread time needed for a phenomenon to reach " "each cell from the starting sources (minutes)."); parm.x_out = G_define_option(); parm.x_out->key = "x_output"; parm.x_out->type = TYPE_STRING; parm.x_out->gisprompt = "new,cell,raster"; parm.x_out->guisection = _("Output maps"); parm.x_out->label = _("Name of raster map to contain X back coordinates"); parm.x_out->description = _("Name of the new raster map layer to contain " "the results of backlink information in UTM easting coordinates for each " "cell."); parm.y_out = G_define_option(); parm.y_out->key = "y_output"; parm.y_out->type = TYPE_STRING; parm.y_out->gisprompt = "new,cell,raster"; parm.y_out->guisection = _("Output maps"); parm.y_out->label = _("Name of raster map to contain Y back coordinates"); parm.y_out->description = _("Name of the new raster map layer to contain " "the results of backlink information in UTM northing coordinates for each " "cell."); flag.display = G_define_flag(); flag.display->key = 'd'; #if 0 flag.display->label = _("DISPLAY 'live' spread process on screen"); flag.display->description = _("Display the 'live' simulation on screen. A graphics window " "must be opened and selected before using this option."); #else flag.display->description = _("Live display - disabled and depreciated"); #endif flag.spotting = G_define_flag(); flag.spotting->key = 's'; flag.spotting->description = _("Consider spotting effect (for wildfires)"); flag.start_is_time = G_define_flag(); flag.start_is_time->key = 'i'; flag.start_is_time->label = _("Use start raster map values in" " output spread time raster map"); flag.start_is_time->description = _("Designed to be used with output" " of previous run of r.spread when computing spread iteratively." " The values in start raster map are considered as time." " Allowed values in raster map are from zero" " to the value of init_time option." " If not enabled, init_time is used in the area of start raster map"); /* Parse command line */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* FIXME - allow seed to be specified for repeatability */ G_srand48_auto(); display = flag.display->answer; #if 1 if (display) G_fatal_error(_("The display feature is disabled")); #endif spotting = flag.spotting->answer; max_layer = parm.max->answer; dir_layer = parm.dir->answer; base_layer = parm.base->answer; start_layer = parm.start->answer; backdrop_layer = parm.backdrop->answer; out_layer = parm.out->answer; if (parm.x_out->answer) { x_out = 1; x_out_layer = parm.x_out->answer; } if (parm.y_out->answer) { y_out = 1; y_out_layer = parm.y_out->answer; } if (spotting) { if (! (parm.spotdist->answer && parm.velocity->answer && parm.mois->answer)) { G_warning ("SPOTTING DISTANCE, fuel MOISTURE, or wind VELOCITY map not given w/ -s"); G_usage(); exit(EXIT_FAILURE); } else { spotdist_layer = parm.spotdist->answer; velocity_layer = parm.velocity->answer; mois_layer = parm.mois->answer; } } /*Check the given the least sampling size, assign the default if needed */ if (parm.least->answer) least = atoi(parm.least->answer); else least = 3; /*Check the given computing density, assign the default if needed */ if (parm.comp_dens->answer) { comp_dens = atof(parm.comp_dens->answer); if (comp_dens < 0.0 || comp_dens > 1.0) { G_warning("Illegal computing density <%s>", parm.comp_dens->answer); G_usage(); exit(EXIT_FAILURE); } } else { comp_dens = 0.5; } /*Check the given initial time and simulation time lag, assign the default if needed */ init_time = atoi(parm.init_time->answer); if (init_time < 0) { G_warning("Illegal initial time <%s>", parm.init_time->answer); G_usage(); exit(EXIT_FAILURE); } if (parm.time_lag->answer) { time_lag = atoi(parm.time_lag->answer); if (time_lag < 0) { G_warning("Illegal simulating time lag <%s>", parm.time_lag->answer); G_usage(); exit(EXIT_FAILURE); } } else { time_lag = 99999; } /* Get database window parameters */ G_get_window(&window); /* find number of rows and columns in window */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); /*transfor measurement unit from meters to centimeters due to ROS unit *if the input ROSs are in m/min units, cancell the following*/ window.ns_res = 100 * window.ns_res; window.ew_res = 100 * window.ew_res; /* Initialize display screens */ #if 0 if (display) display_init(); #endif /* Check if input layers exists in data base */ if (G_find_raster2(max_layer, "") == NULL) G_fatal_error("Raster map <%s> not found", max_layer); if (G_find_raster2(dir_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), dir_layer); if (G_find_raster2(base_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), base_layer); if (G_find_raster2(start_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), start_layer); if (spotting) { if (G_find_raster2(spotdist_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), spotdist_layer); if (G_find_raster2(velocity_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), velocity_layer); if (G_find_raster2(mois_layer, "") == NULL) G_fatal_error(_("Raster map <%s> not found"), mois_layer); } /* Open input cell layers for reading */ max_fd = Rast_open_old(max_layer, G_find_raster2(max_layer, "")); dir_fd = Rast_open_old(dir_layer, G_find_raster2(dir_layer, "")); base_fd = Rast_open_old(base_layer, G_find_raster2(base_layer, "")); if (spotting) { spotdist_fd = Rast_open_old(spotdist_layer, G_find_raster2(spotdist_layer, "")); velocity_fd = Rast_open_old(velocity_layer, G_find_raster2(velocity_layer, "")); mois_fd = Rast_open_old(mois_layer, G_find_raster2(mois_layer, "")); } /* Allocate memories for a row */ cell = Rast_allocate_c_buf(); if (x_out) x_cell = Rast_allocate_c_buf(); if (y_out) y_cell = Rast_allocate_c_buf(); /* Allocate memories for a map */ map_max = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_dir = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_base = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_visit = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_out = (float *)G_calloc(nrows * ncols + 1, sizeof(float)); if (spotting) { map_spotdist = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_velocity = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); map_mois = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); } if (x_out) map_x_out = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); if (y_out) map_y_out = (CELL *) G_calloc(nrows * ncols + 1, sizeof(CELL)); /* Write the input layers in the map "arrays" */ G_message(_("Reading inputs...")); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_c_row(max_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_max, row, col) = cell[col]; Rast_get_c_row(dir_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_dir, row, col) = cell[col]; Rast_get_c_row(base_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_base, row, col) = cell[col]; if (spotting) { Rast_get_c_row(spotdist_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_spotdist, row, col) = cell[col]; Rast_get_c_row(velocity_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_velocity, row, col) = cell[col]; Rast_get_c_row(mois_fd, cell, row); for (col = 0; col < ncols; col++) DATA(map_mois, row, col) = cell[col]; } } G_percent(row, nrows, 2); /* Scan the START layer searching for starting points. * Create an array of starting points (min_heap) ordered by costs. */ start_fd = Rast_open_old(start_layer, G_find_raster2(start_layer, "")); Rast_read_range(start_layer, G_find_file("cell", start_layer, ""), &start_range); Rast_get_range_min_max(&start_range, &start_range_min, &start_range_max); start_is_time = flag.start_is_time->answer; /* values higher than init_time are unexpected and may cause segfaults */ if (start_is_time && start_range_max > init_time) G_fatal_error(_("Maximum of start raster map is grater than init_time" " (%d > %d)"), start_range_max, init_time); /* values lower then zero does not make sense for time */ if (start_is_time && start_range_min < 0) G_fatal_error(_("Minimum of start raster map is less than zero" " (%d < 0)"), start_range_min, init_time); /* Initialize the heap */ heap = (struct costHa *)G_calloc(nrows * ncols + 1, sizeof(struct costHa)); heap_len = 0; G_message(_("Reading %s..."), start_layer); G_debug(1, "Collecting origins..."); collect_ori(start_fd, start_is_time); G_debug(1, "Done"); /* Major computation of spread time */ G_debug(1, "Spreading..."); spread(); G_debug(1, "Done"); /* Open cumulative cost layer (and x, y direction layers) for writing */ cum_fd = Rast_open_c_new(out_layer); if (x_out) x_fd = Rast_open_c_new(x_out_layer); if (y_out) y_fd = Rast_open_c_new(y_out_layer); /* prepare output -- adjust from cm to m */ window.ew_res = window.ew_res / 100; window.ns_res = window.ns_res / 100; /* copy maps in ram to output maps */ ram2out(); G_free(map_max); G_free(map_dir); G_free(map_base); G_free(map_out); G_free(map_visit); if (x_out) G_free(map_x_out); if (y_out) G_free(map_y_out); if (spotting) { G_free(map_spotdist); G_free(map_mois); G_free(map_velocity); } Rast_close(max_fd); Rast_close(dir_fd); Rast_close(base_fd); Rast_close(start_fd); Rast_close(cum_fd); if (x_out) Rast_close(x_fd); if (y_out) Rast_close(y_fd); if (spotting) { Rast_close(spotdist_fd); Rast_close(velocity_fd); Rast_close(mois_fd); } /* close graphics */ #if 0 if (display) display_close(); #endif exit(EXIT_SUCCESS); }