Exemple #1
0
static void
test_foreach_message_queue() {
  message_queue *queue = create_message_queue();
  assert_true( queue != NULL );

  buffer *first_buf = alloc_buffer();
  append_string( first_buf, "first_buffer" );
  assert_true( enqueue_message( queue, first_buf ) );
  assert_int_equal( queue->length, 1 );
  buffer *second_buf = alloc_buffer();
  append_string( second_buf, "second_buffer" );
  assert_true( enqueue_message( queue, second_buf ) );
  assert_int_equal( queue->length, 2 );
  buffer *third_buf = alloc_buffer();
  append_string( third_buf, "third_buffer" );
  assert_true( enqueue_message( queue, third_buf ) );
  assert_int_equal( queue->length, 3 );

  buffer *deq_buf = dequeue_message( queue );
  assert_true( deq_buf == first_buf );

  char *user_data = xstrdup( "user_data" );
  count = 0;

  foreach_message_queue( queue, test_foreach_message_queue_helper, user_data );

  assert_int_equal( count, 2 );

  xfree( user_data );
  assert_true( delete_message_queue( queue ) );
}
Exemple #2
0
static void
test_multiple_queueing() {
  message_queue *queue = create_message_queue();
  assert_true( queue != NULL );

  buffer *first_buf = alloc_buffer();
  assert_true( enqueue_message( queue, first_buf ) );
  assert_int_equal( queue->length, 1 );

  buffer *deq_buf = dequeue_message( queue );
  assert_true( deq_buf == first_buf );
  free_buffer( deq_buf );
  assert_int_equal( queue->length, 0 );


  first_buf = alloc_buffer();
  assert_true( enqueue_message( queue, first_buf ) );
  assert_int_equal( queue->length, 1 );
  buffer *second_buf = alloc_buffer();
  assert_true( enqueue_message( queue, second_buf ) );
  assert_int_equal( queue->length, 2 );

  deq_buf = dequeue_message( queue );
  assert_true( deq_buf == first_buf );
  free_buffer( deq_buf );
  assert_int_equal( queue->length, 1 );

  buffer *third_buf = alloc_buffer();
  assert_true( enqueue_message( queue, third_buf ) );
  assert_int_equal( queue->length, 2 );
  buffer *fourth_buf = alloc_buffer();
  assert_true( enqueue_message( queue, fourth_buf ) );
  assert_int_equal( queue->length, 3 );

  deq_buf = dequeue_message( queue );
  assert_true( deq_buf == second_buf );
  free_buffer( deq_buf );
  assert_int_equal( queue->length, 2 );
  deq_buf = dequeue_message( queue );
  assert_true( deq_buf == third_buf );
  free_buffer( deq_buf );
  assert_int_equal( queue->length, 1 );
  deq_buf = dequeue_message( queue );
  assert_true( deq_buf == fourth_buf );
  free_buffer( deq_buf );
  assert_int_equal( queue->length, 0 );


  assert_true( delete_message_queue( queue ) );
}
Exemple #3
0
static INLINE void *
remote_context_create_rasterizer_state(struct pipe_context *_pipe,
                                      const struct pipe_rasterizer_state *state)
{

    ALLOC_OUT_MESSAGE(create_rast_state, message);
    
    message->base.opcode = REMREQ_CREATE_RAST_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->state = *state;
    // Struct copy

    uint32_t handle = get_fresh_rast_handle(_pipe->screen);
    message->handle = handle;
    
    DBG("Create new rasterizer state: handle %u\n", handle);
    
    enqueue_message(message);
    
    struct remote_opaque_rast_state* remote_rast = CALLOC_STRUCT(remote_opaque_rast_state);
    
    PANIC_IF_NULL(remote_rast);
    remote_rast->handle = handle;
    return remote_rast;
}
Exemple #4
0
/**
 * @brief notify the command receiver that a chid printed a line on it's stderr.
 * @param c the child hat generated @p line
 * @param line the line received from the child stderr
 * @returns 0 on success, -1 on error.
 */
int on_cmd_stderr(child_node *c, char *line) {
  message *m;
  struct cmd_stderr_info *stderr_info;
  size_t len;
  uint16_t seq;
  
  seq = get_sequence(&(c->conn->ctrl_seq), &(c->conn->control.mutex));
  
  len = strlen(line) + 1;
  
  m = create_message(seq, sizeof(struct cmd_stderr_info) + len, CTRL_ID);
  
  if(!m) {
    print(ERROR, "cannot create messages");
    return -1;
  }
  
  stderr_info = (struct cmd_stderr_info *) m->data;
  stderr_info->cmd_action = CMD_STDERR;
  stderr_info->id = c->id;
  memcpy(stderr_info->line, line, len);
  
  if(enqueue_message(&(c->conn->outcoming), m)) {
    print(ERROR, "cannot enqueue messages");
    dump_message(m);
    free_message(m);
    return -1;
  }
  
  return 0;
}
Exemple #5
0
static INLINE void
remote_context_bind_sampler_states(struct pipe_context *_pipe, 
                                  unsigned num_states, void **states)
{

    DBG("Bind sampler states: %u states\n", num_states);

    struct remreq_bind_sampler_state* header =
      allocate_message_memory(
          sizeof(struct remreq_bind_sampler_state)
	+ (num_states * sizeof(uint32_t)));
    
    header->base.opcode = REMREQ_BIND_SAMPLER_STATE;
    header->pipe = PIPE_HANDLE(_pipe);
    header->nstates = num_states;

    uint32_t* state_handles =
      (uint32_t*)((char*)header + sizeof(struct remreq_bind_sampler_state));    
    unsigned i;
    for(i = 0; i < num_states; i++) {
	state_handles[i] = SAMPLER_HANDLE(states[i]);	
    }

    enqueue_message(header);
}
Exemple #6
0
static void
test_enqueue_message_if_queue_is_not_created() {
  message_queue *queue = NULL;
  buffer *enq_buf = alloc_buffer();
  expect_assert_failure( enqueue_message( queue, enq_buf ) );
  free_buffer( enq_buf );
}
Exemple #7
0
static INLINE void
remote_context_set_constant_buffer(struct pipe_context *_pipe,
                                  uint shader, uint index,
                                  const struct pipe_constant_buffer *buffer)
{

    DBG("Set constant buffer for shader %u, index %u\n", shader, index);

    ALLOC_OUT_MESSAGE(set_constant_buffer, message);
    
    message->base.opcode = REMREQ_SET_CONSTANT_BUFFER;
    message->pipe = PIPE_HANDLE(_pipe);
    message->shader = shader;
    message->index = index;
    message->buffer_size = buffer->size;
    message->buffer = BUFFER_HANDLE(buffer->buffer);
    /*
    char* mapped = (char*)pipe_buffer_map(_pipe->screen, buffer->buffer, PIPE_BUFFER_USAGE_CPU_READ);

    printf("On setting, constant buffer goes like this:\n");
    
    int i;
    for(i = 0; i < buffer->size; i++) {
      printf("%4d ", (int)mapped[i]);
      if(i % 8 == 7)
	printf("\n");
    }
    printf("\n");

    pipe_buffer_unmap(_pipe->screen, buffer->buffer);
    */
    enqueue_message(message);

}
Exemple #8
0
static INLINE void
remote_context_set_edgeflags(struct pipe_context *_pipe,
                            const unsigned *bitfield)
{

  if(bitfield) {
    DBG("Set edge flags: %u\n", *bitfield);
  }
  else {
    DBG("Set edge flags: null\n");
  }

    ALLOC_OUT_MESSAGE(set_edgeflags, message);
    
    message->base.opcode = REMREQ_SET_EDGEFLAGS;
    message->pipe = PIPE_HANDLE(_pipe);
    if(bitfield) {
      message->isnull = 0;
      message->flag = *bitfield;
    }
    else {
      message->isnull = 1;
    }
    
    enqueue_message(message);

}
Exemple #9
0
static INLINE void
remote_context_set_framebuffer_state(struct pipe_context *_pipe,
                                    const struct pipe_framebuffer_state *state)
{
    unsigned i;
    ALLOC_OUT_MESSAGE(set_framebuffer_state, message);

    message->base.opcode = REMREQ_SET_FRAMEBUFFER_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->fbwidth = state->width;
    message->fbheight = state->height;
    message->fbnum_cbufs = state->num_cbufs;
    message->fbzsbuf = state->zsbuf ? SURFACE_HANDLE(state->zsbuf) : 0;
    for(i = 0; i < PIPE_MAX_COLOR_BUFS; i++)
	message->fbcbufs[i] = state->cbufs[i] ? SURFACE_HANDLE(state->cbufs[i]) : 0;
	
    DBG("Set framebuffer state: %dx%d\n", state->width, state->height);
    if(message->fbzsbuf) {
	DBG("Z/stencil buffer: %u\n", message->fbzsbuf);
    }
    else {
	DBG("No Z/stencil buffer\n");
    }
    
    for(i = 0; i < PIPE_MAX_COLOR_BUFS; i++)
	if(message->fbcbufs[i])
	    DBG("Colour buffer %d: texture %u\n", i, message->fbcbufs[i]);

    enqueue_message(message);

    struct remote_context* rctx = (struct remote_context*)_pipe;

    rctx->current_framebuffer_state = *state; // Struct copy
    
}
Exemple #10
0
static INLINE struct pipe_query *
remote_context_create_query(struct pipe_context *_pipe,
                           unsigned query_type)
{

// Despite appearances, pipe_query is actually an opaque struct.

    ALLOC_OUT_MESSAGE(create_query, message);
    
    message->base.opcode = REMREQ_CREATE_QUERY;
    message->pipe = PIPE_HANDLE(_pipe);
    message->query_type = query_type;
    
    uint32_t handle = get_fresh_query_handle(_pipe->screen);
    
    DBG("New query %u, type %x\n", handle, query_type);
    
    message->handle = handle;

    enqueue_message(message);
    
    struct remote_pipe_query* opaque = CALLOC_STRUCT(remote_pipe_query);
    
    PANIC_IF_NULL(opaque);
    
    opaque->handle = handle;
    
    return (struct pipe_query*)opaque;

}
Exemple #11
0
static INLINE void *
remote_context_create_vs_state(struct pipe_context *_pipe,
                              const struct pipe_shader_state *state)
{

    int tokens = tgsi_num_tokens(state->tokens);

    struct remreq_create_vs_state* header = 
	allocate_message_memory(
	    sizeof(struct remreq_create_vs_state) 
	  + (tokens * sizeof(struct tgsi_token)));
	  
    uint32_t handle = get_fresh_vs_handle(_pipe->screen);
    
    DBG("Create new VS state: handle %u\n", handle);
    
    header->base.opcode = REMREQ_CREATE_VS_STATE;
    header->pipe = PIPE_HANDLE(_pipe);
    header->vs_handle = handle;

    char* copy_dest = ((char*)header) + sizeof(struct remreq_create_vs_state);
    memcpy(copy_dest, (char*)(state->tokens), sizeof(struct tgsi_token) * tokens);
    
    enqueue_message(header);
    
    struct opaque_remote_vs* retval = CALLOC_STRUCT(opaque_remote_vs);
    
    PANIC_IF_NULL(retval);
    
    retval->handle = handle;
    
    return retval;

}
Exemple #12
0
/**
 * @brief handle a command request.
 * @param c the connection that send @p msg
 * @param msg the request ::message
 * @returns 0 on success, -1 on error.
 */
int on_command_request(conn_node *c, message *msg) {
  message *reply;
  
  switch(msg->data[0]) {
    case CMD_START:
      reply = on_cmd_start(c, msg);
      break;
    case CMD_SIGNAL:
      reply = on_cmd_signal(c, msg);
      break;
    default:
      print( ERROR, "unknown command '%02hhX'", msg->data[0] );
      reply = NULL;
      break;
  }
  
  if(!reply)
    return 0;
  
  if(enqueue_message(&(c->outcoming), reply)) {
    print( ERROR, "cannot enqueue message" );
    dump_message(reply);
    free_message(reply);
    return -1;
  }
  return 0;
}
Exemple #13
0
static INLINE void
remote_context_set_sampler_textures(struct pipe_context *_pipe,
                                   unsigned num_textures,
                                   struct pipe_texture **textures)
{
    // Similar to below
    
    DBG("Set sampler textures\n");
    
    struct remreq_set_sampler_textures* header = 
	(struct remreq_set_sampler_textures*)
	  allocate_message_memory(
	    sizeof(struct remreq_set_sampler_textures) + 
	    num_textures * sizeof(uint32_t));
	    
    header->base.opcode = REMREQ_SET_SAMPLER_TEXTURES;
    header->pipe = PIPE_HANDLE(_pipe);
    header->num_textures = num_textures;
    
    uint32_t* texhandles = (uint32_t*)
      ((char*)header + sizeof(struct remreq_set_sampler_textures));
    
    unsigned i;
    
    for(i = 0; i < num_textures; i++) {
	texhandles[i] = textures[i] ? TEXTURE_HANDLE(textures[i]) : 0;
	DBG("Sampler slot %d: texture %u\n", i, texhandles[i]);
    }

    enqueue_message(header);

}
Exemple #14
0
static INLINE boolean
remote_context_draw_arrays(struct pipe_context *_pipe,
                          unsigned mode, unsigned start, unsigned count)
{

    DBG("Draw arrays: mode %u, start %u, count %u\n", mode, start, count);

    mark_framebuffer_dirty(_pipe);

    ALLOC_OUT_MESSAGE(draw_arrays, message);
    
    message->base.opcode = REMREQ_DRAW_ARRAYS;
    message->pipe = PIPE_HANDLE(_pipe);
    message->mode = mode;
    message->start = start;
    message->count = count;

    enqueue_message(message);

    return true;
    /*
    QUEUE_AND_WAIT(message, draw_arrays, reply);
    PANIC_IF_NULL(reply);
    
    boolean success = reply->success;
    
    free_message(reply);

    return success;
    */

}
Exemple #15
0
static INLINE void
remote_context_set_vertex_elements(struct pipe_context *_pipe,
                                  unsigned num_elements,
                                  const struct pipe_vertex_element *elements)
{
    // Send array
    
    DBG("Set vertex elements: %u elements\n", num_elements);
    
    struct remreq_set_vertex_elements* header = 
	(struct remreq_set_vertex_elements*)
	  allocate_message_memory(
	    sizeof(struct remreq_set_vertex_elements) + 
	    num_elements * sizeof(struct pipe_vertex_element));

    header->base.opcode = REMREQ_SET_VERTEX_ELEMENTS;
    header->pipe = PIPE_HANDLE(_pipe);
    header->num_elements = num_elements;
    
    char* dest = ((char*)header) + sizeof(struct remreq_set_vertex_elements);
    memcpy(dest, (void*)elements, num_elements * sizeof(struct pipe_vertex_element));	    
    
    enqueue_message(header);

}
Exemple #16
0
static INLINE void
remote_context_surface_copy(struct pipe_context *_pipe,
                           boolean do_flip,
                           struct pipe_surface *dest,
                           unsigned destx, unsigned desty,
                           struct pipe_surface *src,
                           unsigned srcx, unsigned srcy,
                           unsigned width, unsigned height)
{

    DBG("Surface copy: %u-%ux%u-%ux%u --> %u-%ux%u\n", SURFACE_HANDLE(src), srcx, srcy, srcx + width, srcy + height, SURFACE_HANDLE(dest), destx, desty);

    ALLOC_OUT_MESSAGE(surface_copy, message);
    
    message->base.opcode = REMREQ_SURFACE_COPY;
    message->pipe = PIPE_HANDLE(_pipe);
    message->src = SURFACE_HANDLE(src);
    message->dest = SURFACE_HANDLE(dest);
    message->sx = srcx;
    message->sy = srcy;
    message->dx = destx;
    message->dy = desty;
    message->w = width;
    message->h = height;
    message->do_flip = do_flip;
    
    enqueue_message(message);

}
Exemple #17
0
static void
test_enqueue_message_if_message_is_NULL() {
  message_queue *queue = create_message_queue();
  assert_true( queue != NULL );
  assert_int_equal( queue->length, 0 );

  expect_assert_failure( enqueue_message( queue, NULL ) );

  assert_true( delete_message_queue( queue ) );
}
Exemple #18
0
void respond_cd(t_socket *connection, t_message packet) {
    char *params = (char *) malloc(sizeof(char) * packet.size - 2);
    strncpy(params, packet.data, packet.size - 3);
    params[packet.size - 3] = '\0';

    char buffer[2048];

    if (!cd(params)) {
        sprintf(buffer, "remote chdir at '%s'\n", params);
        text_message(connection, TYPE_SCREEN, buffer);
    }
    else if (errno == EACCES)
        enqueue_message(connection, error_message(2, packet.sequence));
    else
        enqueue_message(connection, error_message(1, packet.sequence));

    if (params != NULL)
        free(params);
}
Exemple #19
0
static void
recv_from_secure_channel( int fd, void *user_data ) {
  UNUSED( fd );
  UNUSED( user_data );

  // all queued messages should be processed before receiving new messages from remote
  if ( recv_queue->length > 0 ) {
    return;
  }

  if ( fragment_buf == NULL ) {
    fragment_buf = alloc_buffer_with_length( RECEIVE_BUFFFER_SIZE );
  }

  size_t remaining_length = RECEIVE_BUFFFER_SIZE - fragment_buf->length;
  char *recv_buf = ( char * ) fragment_buf->data + fragment_buf->length;
  ssize_t recv_length = read( connection.fd, recv_buf, remaining_length );
  if ( recv_length < 0 ) {
    if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
      return;
    }
    error( "Receive error ( errno = %s [%d] ).", strerror( errno ), errno );
    return;
  }
  if ( recv_length == 0 ) {
    debug( "Connection closed by peer." );
    disconnected();
    reconnect( NULL );
    return;
  }
  fragment_buf->length += ( size_t ) recv_length;

  size_t read_total = 0;
  while ( fragment_buf->length >= sizeof( struct ofp_header ) ) {
    struct ofp_header *header = fragment_buf->data;
    uint16_t message_length = ntohs( header->length );
    if ( message_length > fragment_buf->length ) {
      break;
    }
    buffer *message = alloc_buffer_with_length( message_length );
    char *p = append_back_buffer( message, message_length );
    memcpy( p, fragment_buf->data, message_length );
    remove_front_buffer( fragment_buf, message_length );
    enqueue_message( recv_queue, message );
    read_total += message_length;
  }

  // remove headroom manually for next call
  if ( read_total > 0 ) {
    memmove( ( char * ) fragment_buf->data - read_total, fragment_buf->data, fragment_buf->length );
    fragment_buf->data = ( char * ) fragment_buf->data - read_total;
  }

  while ( recv_message_from_secure_channel() == true );
}
Exemple #20
0
/**
 * @brief read from a connection
 */
void *connection_reader(void *arg) {
  
  struct message *msg;
  conn_node *c;
  
  c=(conn_node *) arg;
  
#ifndef NDEBUG
  print( DEBUG, "started (fd=%d, tid=%lu)", c->fd, pthread_self() );
#endif
  
  while((msg = read_message(c->fd))) {
    pthread_mutex_lock(&(c->control.mutex));
    
    while(c->freeze) {
      pthread_cond_wait(&(c->control.cond), &(c->control.mutex));
    }
    
    pthread_mutex_unlock(&(c->control.mutex));
    
    if(enqueue_message(&(c->incoming), msg)) {
      print( ERROR, "cannot enqueue received message" );
      dump_message(msg);
      free_message(msg);
    }
  }
  
  stop_connection(c);
  
  pthread_mutex_lock(&(c->control.mutex));
  while(!c->writer_done || !c->worker_done) {
    pthread_cond_wait(&(c->control.cond), &(c->control.mutex));
  }
  pthread_mutex_unlock(&(c->control.mutex));
  
  pthread_mutex_lock(&(connections.control.mutex));
  list_del(&(connections.list), (node *)c);
  pthread_mutex_unlock(&(connections.control.mutex));
  
  pthread_cond_broadcast(&(connections.control.cond));
  
  close(c->fd);

#ifndef NDEBUG
  print( DEBUG, "connection closed (fd=%d)", c->fd );
#endif
  
  // add me to the death list
  send_me_to_graveyard();
  
  free_connection(c);
  
  return 0;
}
Exemple #21
0
static void
test_enqueue_and_delete_message_queue() {
  message_queue *queue = create_message_queue();
  assert_true( queue != NULL );
  assert_int_equal( queue->length, 0 );

  buffer *buf = alloc_buffer();
  assert_true( enqueue_message( queue, buf ) );
  assert_int_equal( queue->length, 1 );

  assert_true( delete_message_queue( queue ) );
}
Exemple #22
0
/**
 * @brief send handlers definitions
 * @param conn the ::connection to send these definitions
 * @returns 0 on success, -1 on error.
 */
int send_handlers_list(conn_node *conn) {
    handler *h;
    message *m;
    struct hndl_list_info *handlers_info;
    struct hndl_info *handler_info;
    int ret;
    size_t array_size;

    ret=-1;
    array_size=0;

    for(h=(handler *) handlers.head; h; h=(handler *) h->next) {
        array_size += sizeof(struct hndl_info);
        array_size += strlen(h->name) +1;
    }

    m = create_message(get_sequence(&(conn->ctrl_seq), &(conn->control.mutex)),
                       sizeof(struct hndl_list_info) + array_size,
                       CTRL_ID);

    if(!m) {
        print( ERROR, "cannot create messages" );
        goto exit;
    }

    handlers_info = (struct hndl_list_info *) m->data;
    handlers_info->hndl_code = HNDL_LIST;

    handler_info = handlers_info->list;

    for(h=(handler *) handlers.head; h; h=(handler *) h->next) {
        handler_info->id = h->id;
        handler_info->have_stdin = h->have_stdin;
        handler_info->have_stdout = h->have_stdout;

        strcpy(handler_info->name, h->name);

        handler_info = (struct hndl_info *) (
                           ((char *) handler_info) + sizeof(struct hndl_info) + strlen(h->name) + 1);
    }

    if(enqueue_message(&(conn->outcoming), m)) {
        print( ERROR, "cannot enqueue message" );
        dump_message(m);
        free_message(m);
    } else {
        ret = 0;
    }

exit:

    return ret;
}
Exemple #23
0
int
send_to_secure_channel( struct switch_info *sw_info, buffer *buf ) {
  assert( sw_info != NULL );
  assert( buf != NULL );
  assert( buf->length > 0 );

  if ( sw_info->send_queue == NULL ) {
    return -1;
  }

  return ( enqueue_message( sw_info->send_queue, buf ) == true ) ? 0 : -1;
}
Exemple #24
0
static INLINE void
remote_context_bind_rasterizer_state(struct pipe_context *_pipe, 
                                    void *state)
{

    ALLOC_OUT_MESSAGE(bind_rast_state, message);
    
    message->base.opcode = REMREQ_BIND_RAST_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->rast_handle = RAST_HANDLE(state);
    
    enqueue_message(message);    
}
Exemple #25
0
static INLINE void
remote_context_destroy(struct pipe_context *_pipe)
{
   ALLOC_OUT_MESSAGE(destroy_context, message);
   
   DBG("Destroying context %u\n", PIPE_HANDLE(_pipe));
   
   message->base.opcode = REMREQ_DESTROY_CONTEXT;
   message->pipe = PIPE_HANDLE(_pipe);
   
   enqueue_message(message);
   
   FREE((struct remote_context*)_pipe);
}
Exemple #26
0
static INLINE void
remote_context_delete_blend_state(struct pipe_context *_pipe, 
                                 void *state)
{
    DBG("Delete blend state %u\n", BLEND_HANDLE(state));

    ALLOC_OUT_MESSAGE(delete_blend_state, message);
    
    message->base.opcode = REMREQ_DELETE_BLEND_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->blend_handle = BLEND_HANDLE(state);
    
    enqueue_message(message);    
}
Exemple #27
0
static INLINE void
remote_context_delete_rasterizer_state(struct pipe_context *_pipe, 
                                      void *state)
{
    DBG("Delete rasterizer state %u\n", RAST_HANDLE(state));

    ALLOC_OUT_MESSAGE(delete_rast_state, message);
    
    message->base.opcode = REMREQ_DELETE_RAST_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->rast_handle = RAST_HANDLE(state);
    
    enqueue_message(message);    
}
Exemple #28
0
static INLINE void
remote_context_delete_sampler_state(struct pipe_context *_pipe, 
                                   void *state)
{

    DBG("Delete sampler state %u\n", SAMPLER_HANDLE(state));

    ALLOC_OUT_MESSAGE(delete_sampler_state, message);
    
    message->base.opcode = REMREQ_DELETE_SAMPLER_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->sampler_handle = SAMPLER_HANDLE(state);
    
    enqueue_message(message);    
}
Exemple #29
0
static INLINE void
remote_context_delete_fs_state(struct pipe_context *_pipe, 
                              void *state)
{

    DBG("Delete fragment shader %u\n", FS_HANDLE(state));

    ALLOC_OUT_MESSAGE(delete_fs_state, message);
    
    message->base.opcode = REMREQ_DELETE_FS_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->fs_handle = FS_HANDLE(state);
    
    enqueue_message(message);
}
Exemple #30
0
static INLINE void
remote_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, 
                                               void *state)
{

    DBG("Delete depth/stencil/alpha state %u\n", DSA_HANDLE(state));

    ALLOC_OUT_MESSAGE(delete_dsa_state, message);
    
    message->base.opcode = REMREQ_DELETE_DSA_STATE;
    message->pipe = PIPE_HANDLE(_pipe);
    message->dsa_handle = DSA_HANDLE(state);
    
    enqueue_message(message);    
}