Beispiel #1
0
/**
 * \param fence  if non-null, returns pointer to a fence which can be waited on
 */
void
llvmpipe_flush( struct pipe_context *pipe,
                struct pipe_fence_handle **fence,
                const char *reason)
{
   struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);

   draw_flush(llvmpipe->draw);

   /* ask the setup module to flush */
   lp_setup_flush(llvmpipe->setup, fence, reason);

   /* Enable to dump BMPs of the color/depth buffers each frame */
   if (0) {
      static unsigned frame_no = 1;
      char filename[256];
      unsigned i;

      for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++) {
         util_snprintf(filename, sizeof(filename), "cbuf%u_%u", i, frame_no);
         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.cbufs[i]);
      }

      if (0) {
         util_snprintf(filename, sizeof(filename), "zsbuf_%u", frame_no);
         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.zsbuf);
      }

      ++frame_no;
   }
}
/* Sets "Link" header, if content manager is on */
NSAPI_PUBLIC void CM_set_link_header(Request *rq)
{
  char link[CM_BUFF_LEN];
  char *uri;

  if ( !CM_get_status() )  /* if cm is off. don't do anything */
	return;
  
  uri = pblock_findkeyval(pb_key_uri, rq->reqpb);

  /* e.g. Link: <http://www.glyphica.com/index.html?services>; rel="services" */
  if (pervs_vars()->Vsecurity_active) {
	if (pervs_vars()->Vport == 443)
	  util_snprintf(link, CM_BUFF_LEN, "<https://%s%s?%s>; rel=\"%s\"", 
					pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );
	else
	  util_snprintf(link, CM_BUFF_LEN, "<https://%s:%d%s?%s>; rel=\"%s\"", 
					pervs_vars()->Vserver_hostname, pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS );
  } else {
	if (pervs_vars()->Vport == 80)
	  util_snprintf( link, CM_BUFF_LEN, "<http://%s%s?%s>; rel=\"%s\"", 
					 pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS );
	else
	  util_snprintf( link, CM_BUFF_LEN, "<http://%s:%d%s?%s>; rel=\"%s\"", 
					 pervs_vars()->Vserver_hostname,  pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS );
  }
  pblock_nvinsert("Link", link, rq->srvhdrs);  
}
Beispiel #3
0
struct util_dl_library *
pipe_loader_find_module(struct pipe_loader_device *dev,
                        const char *library_paths)
{
   struct util_dl_library *lib;
   const char *next;
   char path[PATH_MAX];
   int len, ret;

   for (next = library_paths; *next; library_paths = next + 1) {
      next = util_strchrnul(library_paths, ':');
      len = next - library_paths;

      if (len)
         ret = util_snprintf(path, sizeof(path), "%.*s/%s%s%s",
                             len, library_paths,
                             MODULE_PREFIX, dev->driver_name, UTIL_DL_EXT);
      else
         ret = util_snprintf(path, sizeof(path), "%s%s%s",
                             MODULE_PREFIX, dev->driver_name, UTIL_DL_EXT);

      if (ret > 0 && ret < sizeof(path)) {
         lib = util_dl_open(path);
         if (lib) {
            return lib;
         }
      }
   }

   return NULL;
}
Beispiel #4
0
static struct vg_shader * setup_lookup_single(struct vg_context *ctx, void *user_data)
{
   char buffer[1024];
   VGImageChannel channel = (VGImageChannel)(user_data);
   struct vg_shader *shader;

   switch(channel) {
   case VG_RED:
      util_snprintf(buffer, 1023, lookup_single_asm, "xxxx");
      break;
   case VG_GREEN:
      util_snprintf(buffer, 1023, lookup_single_asm, "yyyy");
      break;
   case VG_BLUE:
      util_snprintf(buffer, 1023, lookup_single_asm, "zzzz");
      break;
   case VG_ALPHA:
      util_snprintf(buffer, 1023, lookup_single_asm, "wwww");
      break;
   default:
      debug_assert(!"Unknown color channel");
   }

   shader = shader_create_from_text(ctx->pipe, buffer, 200,
                                    PIPE_SHADER_FRAGMENT);

   return shader;
}
/* returns "Link" header, if content manager is on. Null otherwise */
NSAPI_PUBLIC int CM_get_link_header(char *uri, char *link, int size )
{
  if ( !CM_get_status() )  /* if cm is off. don't do anything */
	return 0;
  
  /* e.g. Link: <http://www.glyphica.com/index.html?services>; rel ="services" */
  if (pervs_vars()->Vsecurity_active) {
	if (pervs_vars()->Vport == 443)
	  util_snprintf(link, size, "Link: <https://%s%s?%s>; rel=\"%s\"", 
					pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );
	else
	  util_snprintf(link, size, "Link: <https://%s:%d%s?%s>; rel=\"%s\"", 
					pervs_vars()->Vserver_hostname, 
			  pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS  );
  } else {
	if (pervs_vars()->Vport == 80)
	  util_snprintf( link, size, "Link: <http://%s%s?%s>; rel=\"%s\"", 
					 pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );
	else
	  util_snprintf( link, size, "Link: <http://%s:%d%s?%s>; rel=\"%s\"", 
					 pervs_vars()->Vserver_hostname, 
			   pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS  );
  }
  return 1;
}
Beispiel #6
0
static void
init_logging(struct pipe_screen *screen)
{
   static const char *log_prefix = "Mesa: ";
   char host_log[1000];

   /* Log Version to Host */
   util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),
                 "%s%s", log_prefix, svga_get_name(screen));
   svga_host_log(host_log);

   util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),
                 "%s%s"
#ifdef MESA_GIT_SHA1
                 " (" MESA_GIT_SHA1 ")"
#endif
                 , log_prefix, PACKAGE_VERSION);
   svga_host_log(host_log);

   /* If the SVGA_EXTRA_LOGGING env var is set, log the process's command
    * line (program name and arguments).
    */
   if (debug_get_bool_option("SVGA_EXTRA_LOGGING", FALSE)) {
      char cmdline[1000];
      if (os_get_command_line(cmdline, sizeof(cmdline))) {
         util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),
                       "%s%s", log_prefix, cmdline);
         svga_host_log(host_log);
      }
   }
}
Beispiel #7
0
void
softpipe_flush( struct pipe_context *pipe,
                unsigned flags,
                struct pipe_fence_handle **fence )
{
   struct softpipe_context *softpipe = softpipe_context(pipe);
   uint i;

   draw_flush(softpipe->draw);

   if (flags & SP_FLUSH_TEXTURE_CACHE) {
      unsigned sh;

      for (sh = 0; sh < Elements(softpipe->tex_cache); sh++) {
         for (i = 0; i < softpipe->num_sampler_views[sh]; i++) {
            sp_flush_tex_tile_cache(softpipe->tex_cache[sh][i]);
         }
      }
   }

   /* If this is a swapbuffers, just flush color buffers.
    *
    * The zbuffer changes are not discarded, but held in the cache
    * in the hope that a later clear will wipe them out.
    */
   for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)
      if (softpipe->cbuf_cache[i])
         sp_flush_tile_cache(softpipe->cbuf_cache[i]);

   if (softpipe->zsbuf_cache)
      sp_flush_tile_cache(softpipe->zsbuf_cache);

   softpipe->dirty_render_cache = FALSE;

   /* Enable to dump BMPs of the color/depth buffers each frame */
#if 0
   if (flags & PIPE_FLUSH_END_OF_FRAME) {
      static unsigned frame_no = 1;
      static char filename[256];
      util_snprintf(filename, sizeof(filename), "cbuf_%u.bmp", frame_no);
      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.cbufs[0]);
      util_snprintf(filename, sizeof(filename), "zsbuf_%u.bmp", frame_no);
      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.zsbuf);
      ++frame_no;
   }
#endif

   if (fence)
      *fence = (void*)(intptr_t)1;
}
void
StatsVirtualServerNode::setInterfaces(const VirtualServer* vs)
{
    interfaces.clear();
    interfaces.ensureCapacity(128);
    int nIndex = 0;
    int nItfCount = vs->getHttpListenerNameCount();
    // Calculate the length requirement for assignment
    const Configuration* configuration =
        ConfigurationManager::getConfiguration();
    for (nIndex = 0; configuration && (nIndex < nItfCount); nIndex++)
    {
        const ListenSocketConfig* lsc;
        lsc = configuration->getLsc(*vs->getHttpListenerName(nIndex));
        if (lsc)
        {
            char iface[70] = "";
            util_snprintf(iface, sizeof(iface), "%s:%d",
                          lsc->ip.getStringValue(), lsc->port.getInt32Value());
            interfaces.append(iface);
            const char* spaceSeparater = " ";
            if (nIndex != nItfCount - 1)
            {
                interfaces.append(" ");
            }
        }
    }
    if (configuration) configuration->unref();
}
Beispiel #9
0
ast_expression *fold_constgen_string(fold_t *fold, const char *str, bool translate) {
    hash_table_t *table = (translate) ? fold->imm_string_untranslate : fold->imm_string_dotranslate;
    ast_value    *out   = NULL;
    size_t        hash  = util_hthash(table, str);

    if ((out = (ast_value*)util_htgeth(table, str, hash)))
        return (ast_expression*)out;

    if (translate) {
        char name[32];
        util_snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(fold->parser->translated++));
        out                    = ast_value_new(parser_ctx(fold->parser), name, TYPE_STRING);
        out->expression.flags |= AST_FLAG_INCLUDE_DEF; /* def needs to be included for translatables */
    } else
        out                    = ast_value_new(fold_ctx(fold), "#IMMEDIATE", TYPE_STRING);

    out->cvq              = CV_CONST;
    out->hasvalue         = true;
    out->isimm            = true;
    out->constval.vstring = parser_strdup(str);

    vec_push(fold->imm_string, out);
    util_htseth(table, str, hash, out);

    return (ast_expression*)out;
}
char *_add_table_event(EVENT_HANDLER *handler)
{
	HANDLE event;
	char *err;
	EVENT_HANDLER *tmp;

	if(!(event = CreateEvent(NULL, FALSE, FALSE, handler->event_name))) {
		err = (char *)MALLOC(ERR_MSG_LEN);
        util_snprintf(err, ERR_MSG_LEN, "could not open create event %s (%s)", 
            handler->event_name, system_errmsg());
		TERMINATE_HANDLER_THREAD();
        return err;
	}

	if (!events) {
		events = (HANDLE *)MALLOC(sizeof(HANDLE));
	} else {
		events = (HANDLE *)REALLOC(events, (sizeof(events) + sizeof(HANDLE)));
	}

	events[event_number -1] = event;
	if (!handler_table) {
		handler_table = handler;
	} else {
		/* Prevent duplicate handlers from being entered */
		for (tmp = handler_table; tmp; tmp = tmp->next) {
			if (!strcmp(tmp->event_name, handler->event_name)) {
				return NULL;
			}
		}
		handler->next = handler_table;
		handler_table = handler;
	}
    return NULL;
}
char *delete_handler(char *event)
{
	char *err;
	
    ENTER_EVENT_LOCK;
	if (!handler_thread) {
		err = (char *)MALLOC(ERR_MSG_LEN);
        util_snprintf(err, ERR_MSG_LEN, "handler thread is not present");
        RELEASE_EVENT_LOCK;
        return err;
	}

	/* suspend handler */
	if (err = _suspend_handler()) {
        RELEASE_EVENT_LOCK;
		return err;
	}
	 
	if (err = _delete_event(event)) {
        RELEASE_EVENT_LOCK;
		return err;
	}
	/* reset the handler to wake up and listen on the new event */

	if (err = _resume_handler()) {
        RELEASE_EVENT_LOCK;
		return err;
	}
    RELEASE_EVENT_LOCK;
	return NULL;
}
Beispiel #12
0
static const char *
fd_screen_get_name(struct pipe_screen *pscreen)
{
	static char buffer[128];
	util_snprintf(buffer, sizeof(buffer), "FD%03d",
			fd_screen(pscreen)->device_id);
	return buffer;
}
char *initialize_event_handler(char *serverid)
{
	char *err;
	char mutex_name[EVENT_LEN];
    HANDLE event;
	
	/* First create the global lock -acquire ownership immediately */

	util_snprintf(mutex_name, EVENT_LEN, "%s.event_handler", serverid);
	eventMutex = CreateMutex(NULL, TRUE, mutex_name); 
	if (eventMutex == NULL) {
		err = (char *)MALLOC(ERR_MSG_LEN);
		util_snprintf(err, ERR_MSG_LEN, "Failed to create mutex for event handler %s",
				system_errmsg());
		return err;
	}
	
    /* Create the resume and suspend event names */

	util_snprintf(resume, EVENT_LEN, "%s.resume", serverid);
	util_snprintf(suspend, EVENT_LEN, "%s.suspend", serverid);
	/* Create the global event to resume the event handler thread */
		
	if(!(event = CreateEvent(NULL, FALSE, FALSE, resume))) {
		err = (char *)MALLOC(ERR_MSG_LEN);
        util_snprintf(err, ERR_MSG_LEN, "could not open create event %s (%s)", 
            resume, system_errmsg());
    	RELEASE_EVENT_LOCK;
        return err;
	}
    resumeEvent = (HANDLE *)MALLOC(sizeof(HANDLE));
    resumeEvent[0] = event;

	if (!handler_thread) {
		if (err = _create_handler_thread()) {
        	RELEASE_EVENT_LOCK;
            return err;
		}	
	}
	 
	/* Release mutex */
	RELEASE_EVENT_LOCK;
    return NULL;

}
Beispiel #14
0
static const char *
nouveau_screen_get_name(struct pipe_screen *pscreen)
{
	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
	static char buffer[128];

	util_snprintf(buffer, sizeof(buffer), "NV%02X", dev->chipset);
	return buffer;
}
static const char *
brw_get_name(struct pipe_screen *screen)
{
   static char buffer[128];
   const char *chipset;

   switch (brw_screen(screen)->chipset.pci_id) {
   case PCI_CHIP_I965_G:
      chipset = "I965_G";
      break;
   case PCI_CHIP_I965_Q:
      chipset = "I965_Q";
      break;
   case PCI_CHIP_I965_G_1:
      chipset = "I965_G_1";
      break;
   case PCI_CHIP_I946_GZ:
      chipset = "I946_GZ";
      break;
   case PCI_CHIP_I965_GM:
      chipset = "I965_GM";
      break;
   case PCI_CHIP_I965_GME:
      chipset = "I965_GME";
      break;
   case PCI_CHIP_GM45_GM:
      chipset = "GM45_GM";
      break;
   case PCI_CHIP_IGD_E_G:
      chipset = "IGD_E_G";
      break;
   case PCI_CHIP_Q45_G:
      chipset = "Q45_G";
      break;
   case PCI_CHIP_G45_G:
      chipset = "G45_G";
      break;
   case PCI_CHIP_G41_G:
      chipset = "G41_G";
      break;
   case PCI_CHIP_B43_G:
      chipset = "B43_G";
      break;
   case PCI_CHIP_ILD_G:
      chipset = "ILD_G";
      break;
   case PCI_CHIP_ILM_G:
      chipset = "ILM_G";
      break;
   default:
      chipset = "unknown";
      break;
   }

   util_snprintf(buffer, sizeof(buffer), "i965 (chipset: %s)", chipset);
   return buffer;
}
Beispiel #16
0
static int qc_vtos(qc_program_t *prog) {
    char buffer[512];
    qcany_t *num;
    qcany_t str;
    CheckArgs(1);
    num = GetArg(0);
    util_snprintf(buffer, sizeof(buffer), "'%g %g %g'", num->vector[0], num->vector[1], num->vector[2]);
    str.string = prog_tempstring(prog, buffer);
    Return(str);
    return 0;
}
Beispiel #17
0
static const char *
etna_screen_get_name(struct pipe_screen *pscreen)
{
   struct etna_screen *priv = etna_screen(pscreen);
   static char buffer[128];

   util_snprintf(buffer, sizeof(buffer), "Vivante GC%x rev %04x", priv->model,
                 priv->revision);

   return buffer;
}
Beispiel #18
0
static int qc_etos(qc_program_t *prog) {
    char buffer[512];
    qcany_t *num;
    qcany_t str;
    CheckArgs(1);
    num = GetArg(0);
    util_snprintf(buffer, sizeof(buffer), "%i", num->_int);
    str.string = prog_tempstring(prog, buffer);
    Return(str);
    return 0;
}
int NTStatsServer::buildConnectionName(const char* instanceName,
                                       char* outputPath,
                                       int sizeOutputPath)
{
    if (instanceName == NULL)
    {
        instanceName = conf_get_true_globals()->Vserver_id;
    }
    return util_snprintf(outputPath, sizeOutputPath,
                         "\\\\.\\pipe\\iWSStats-%s",
                         instanceName);
}
static void svga_flush( struct pipe_context *pipe,
                        struct pipe_fence_handle **fence,
                        unsigned flags)
{
   struct svga_context *svga = svga_context(pipe);

   /* Emit buffered drawing commands, and any back copies.
    */
   svga_surfaces_flush( svga );

   if (flags & PIPE_FLUSH_FENCE_FD)
      svga->swc->hints |= SVGA_HINT_FLAG_EXPORT_FENCE_FD;

   /* Flush command queue.
    */
   svga_context_flush(svga, fence);

   SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p\n",
            __FUNCTION__, fence ? *fence : 0x0);

   /* Enable to dump BMPs of the color/depth buffers each frame */
   if (0) {
      struct pipe_framebuffer_state *fb = &svga->curr.framebuffer;
      static unsigned frame_no = 1;
      char filename[256];
      unsigned i;

      for (i = 0; i < fb->nr_cbufs; i++) {
         util_snprintf(filename, sizeof(filename), "cbuf%u_%04u.bmp", i, frame_no);
         debug_dump_surface_bmp(&svga->pipe, filename, fb->cbufs[i]);
      }

      if (0 && fb->zsbuf) {
         util_snprintf(filename, sizeof(filename), "zsbuf_%04u.bmp", frame_no);
         debug_dump_surface_bmp(&svga->pipe, filename, fb->zsbuf);
      }

      ++frame_no;
   }
}
Beispiel #21
0
void
lp_format_intrinsic(char *name,
                    size_t size,
                    const char *name_root,
                    LLVMTypeRef type)
{
   unsigned length = 0;
   unsigned width;
   char c;

   LLVMTypeKind kind = LLVMGetTypeKind(type);
   if (kind == LLVMVectorTypeKind) {
      length = LLVMGetVectorSize(type);
      type = LLVMGetElementType(type);
      kind = LLVMGetTypeKind(type);
   }

   switch (kind) {
   case LLVMIntegerTypeKind:
      c = 'i';
      width = LLVMGetIntTypeWidth(type);
      break;
   case LLVMFloatTypeKind:
      c = 'f';
      width = 32;
      break;
   case LLVMDoubleTypeKind:
      c = 'f';
      width = 64;
      break;
   default:
      unreachable("unexpected LLVMTypeKind");
   }

   if (length) {
      util_snprintf(name, size, "%s.v%u%c%u", name_root, length, c, width);
   } else {
      util_snprintf(name, size, "%s.%c%u", name_root, c, width);
   }
}
Beispiel #22
0
/**
 * Dump an image to a .raw or .ppm file (depends on OS).
 * \param format  PIPE_FORMAT_x
 * \param cpp  bytes per pixel
 * \param width  width in pixels
 * \param height height in pixels
 * \param stride  row stride in bytes
 */
void debug_dump_image(const char *prefix,
                      unsigned format, unsigned cpp,
                      unsigned width, unsigned height,
                      unsigned stride,
                      const void *data)     
{
   /* write a ppm file */
   char filename[256];
   FILE *f;

   util_snprintf(filename, sizeof(filename), "%s.ppm", prefix);

   f = fopen(filename, "w");
   if (f) {
      int i, x, y;
      int r, g, b;
      const uint8_t *ptr = (uint8_t *) data;

      /* XXX this is a hack */
      switch (format) {
      case PIPE_FORMAT_B8G8R8A8_UNORM:
         r = 2;
         g = 1;
         b = 0;
         break;
      default:
         r = 0;
         g = 1;
         b = 1;
      }

      fprintf(f, "P6\n");
      fprintf(f, "# ppm-file created by osdemo.c\n");
      fprintf(f, "%i %i\n", width, height);
      fprintf(f, "255\n");
      fclose(f);

      f = fopen(filename, "ab");  /* reopen in binary append mode */
      for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++) {
            i = y * stride + x * cpp;
            fputc(ptr[i + r], f); /* write red */
            fputc(ptr[i + g], f); /* write green */
            fputc(ptr[i + b], f); /* write blue */
         }
      }
      fclose(f);
   }
   else {
      fprintf(stderr, "Can't open %s for writing\n", filename);
   }
}
Beispiel #23
0
/*
 * Linux perf profiler integration.
 *
 * See also:
 * - http://penberg.blogspot.co.uk/2009/06/jato-has-profiler.html
 * - https://github.com/penberg/jato/commit/73ad86847329d99d51b386f5aba692580d1f8fdc
 * - http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=commitdiff;h=80d496be89ed7dede5abee5c057634e80a31c82d
 */
extern "C" void
lp_profile(LLVMValueRef func, const void *code)
{
#if defined(__linux__) && defined(PROFILE)
   static boolean first_time = TRUE;
   static FILE *perf_map_file = NULL;
   static int perf_asm_fd = -1;
   if (first_time) {
      /*
       * We rely on the disassembler for determining a function's size, but
       * the disassembly is a leaky and slow operation, so avoid running
       * this except when running inside linux perf, which can be inferred
       * by the PERF_BUILDID_DIR environment variable.
       */
      if (getenv("PERF_BUILDID_DIR")) {
         pid_t pid = getpid();
         char filename[256];
         util_snprintf(filename, sizeof filename, "/tmp/perf-%llu.map", (unsigned long long)pid);
         perf_map_file = fopen(filename, "wt");
         util_snprintf(filename, sizeof filename, "/tmp/perf-%llu.map.asm", (unsigned long long)pid);
         mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
         perf_asm_fd = open(filename, O_WRONLY | O_CREAT, mode);
      }
      first_time = FALSE;
   }
   if (perf_map_file) {
      const char *symbol = LLVMGetValueName(func);
      unsigned long addr = (uintptr_t)code;
      llvm::raw_fd_ostream Out(perf_asm_fd, false);
      Out << symbol << ":\n";
      unsigned long size = disassemble(code, Out);
      fprintf(perf_map_file, "%lx %lx %s\n", addr, size, symbol);
      fflush(perf_map_file);
   }
#else
   (void)func;
   (void)code;
#endif
}
Beispiel #24
0
static struct vg_shader * setup_convolution(struct vg_context *ctx, void *user_data)
{
   char buffer[1024];
   VGint num_consts = (VGint)(long)(user_data);
   struct vg_shader *shader;

   util_snprintf(buffer, 1023, convolution_asm, num_consts, num_consts / 2 + 1);

   shader = shader_create_from_text(ctx->pipe, buffer, 200,
                                    PIPE_SHADER_FRAGMENT);

   return shader;
}
char *_resume_handler()
{
	HANDLE resume_event;
	char *err;
	
    resume_event = OpenEvent(EVENT_ALL_ACCESS, FALSE, resume);

    if (resume_event == NULL) {
		err = (char *)MALLOC(ERR_MSG_LEN);
        util_snprintf(err, ERR_MSG_LEN, "could not open resume event  (%s)", 
            system_errmsg());
        return err;
    }
	
    if(!SetEvent(resume_event)) {
 		err = (char *)MALLOC(ERR_MSG_LEN);
       util_snprintf(err, ERR_MSG_LEN, "cannot set reset event (%s)", 
            system_errmsg());
        return err;
    }
	return NULL;
}
char *_create_rotation_thread()
{
	char *err;
	
    handler_thread = systhread_start(15, 65536, _wait_for_events, 
                                         NULL);
	if (handler_thread == NULL) {	
		err = (char *)MALLOC(ERR_MSG_LEN);
		util_snprintf(err, ERR_MSG_LEN, "Failed to start event handler thread %s",
				system_errmsg());
		return err;
	}
	return NULL;
}
Beispiel #27
0
/**
 * Generate sin(a)
 */
LLVMValueRef
lp_build_sin(struct lp_build_context *bld,
              LLVMValueRef a)
{
   const struct lp_type type = bld->type;
   LLVMTypeRef vec_type = lp_build_vec_type(type);
   char intrinsic[32];

   /* TODO: optimize the constant case */

   assert(type.floating);
   util_snprintf(intrinsic, sizeof intrinsic, "llvm.sin.v%uf%u", type.length, type.width);

   return lp_build_intrinsic_unary(bld->builder, intrinsic, vec_type, a);
}
Beispiel #28
0
const char *
debug_dump_enum(const struct debug_named_value *names, 
                unsigned long value)
{
   static char rest[64];
   
   while(names->name) {
      if(names->value == value)
	 return names->name;
      ++names;
   }

   util_snprintf(rest, sizeof(rest), "0x%08lx", value);
   return rest;
}
Beispiel #29
0
static EGLBoolean
dlopen_gl_lib_cb(const char *dir, size_t len, void *callback_data)
{
   const char *name = (const char *) callback_data;
   char path[1024];
   int ret;

   if (len) {
      assert(len <= INT_MAX && "path is insanely long!");
      ret = util_snprintf(path, sizeof(path), "%.*s/%s" UTIL_DL_EXT,
            (int)len, dir, name);
   }
   else {
      ret = util_snprintf(path, sizeof(path), "%s" UTIL_DL_EXT, name);
   }

   if (ret > 0 && ret < sizeof(path)) {
      egl_st_gl_lib = util_dl_open(path);
      if (egl_st_gl_lib)
         _eglLog(_EGL_DEBUG, "loaded %s", path);
   }

   return !egl_st_gl_lib;
}
Beispiel #30
0
static const GLubyte *
st_get_string(struct gl_context * ctx, GLenum name)
{
    struct st_context *st = st_context(ctx);
    struct pipe_screen *screen = st->pipe->screen;

    switch (name) {
    case GL_VENDOR: {
        const char *vendor = screen->get_vendor( screen );
        util_snprintf(st->vendor, sizeof(st->vendor), "%s", vendor);
        return (GLubyte *) st->vendor;
    }

    case GL_RENDERER:
        util_snprintf(st->renderer, sizeof(st->renderer), "Gallium %s on %s",
                      ST_VERSION_STRING,
                      screen->get_name( screen ));

        return (GLubyte *) st->renderer;

    default:
        return NULL;
    }
}