Esempio n. 1
0
int FileThread::stop_writing()
{
	if(is_writing)
	{
		int i, buffer, layer, frame;

		swap_buffer();
		input_lock[current_buffer]->lock("FileThread::stop_writing 1");

		last_buffer[current_buffer] = 1;

		for(i = 0; i < ring_buffers; i++)
			output_lock[i]->unlock();

		swap_buffer();

// wait for thread to finish
		Thread::join();

// delete buffers
		file_lock->lock("FileThread::stop_writing 2");
		if(do_audio)
		{
			for(buffer = 0; buffer < ring_buffers; buffer++)
			{
				for(i = 0; i < file->asset->channels; i++)
					delete [] audio_buffer[buffer][i];
				delete [] audio_buffer[buffer];
			}
			delete [] audio_buffer;
			audio_buffer = 0;
		}

// printf("FileThread::stop_writing %d %d %d %d\n", 
// do_video,
// ring_buffers,
// file->asset->layers,
// buffer_size);
		if(do_video)
		{
			for(buffer = 0; buffer < ring_buffers; buffer++)
			{
				for(layer = 0; layer < file->asset->layers; layer++)
				{
					for(frame = 0; frame < buffer_size; frame++)
					{
						delete video_buffer[buffer][layer][frame];
					}
					delete [] video_buffer[buffer][layer];
				}
				delete [] video_buffer[buffer];
			}
			delete [] video_buffer;
			video_buffer = 0;
		}

		file_lock->unlock();
	}
	return 0;
}
Esempio n. 2
0
void ms_read_process(MSRead *r)
{
	MSFifo *f;
	MSQueue *q;
	MSMessage *msg=NULL;
	int err;
	gint gran=r->gran;
	void *p;
	
	f=r->foutputs[0];
	if ((f!=NULL) && (r->state==MS_READ_STATE_STARTED))
	{
		ms_fifo_get_write_ptr(f,gran,&p);
		if (p!=NULL)
		{
			err=read(r->fd,p,gran);
			if (err<0)
			{
				/* temp: */
				g_warning("ms_read_process: failed to read: %s.\n",strerror(errno));
			}
			else if (err<gran){
				ms_trace("ms_read_process: end of file.");
				ms_filter_notify_event(MS_FILTER(r),MS_READ_EVENT_EOF,NULL);
				r->state=MS_READ_STATE_STOPPED;
				close(r->fd);
				r->fd=-1;
			}
			if (r->need_swap) swap_buffer(p,gran);
		}
	}
	/* process output queues*/
	q=r->qoutputs[0];
	if ((q!=NULL) && (r->fd>0))
	{
		msg=ms_message_new(r->gran);
		err=read(r->fd,msg->data,r->gran);
		if (err>0){
			msg->size=err;
			ms_queue_put(q,msg);
			if (r->need_swap) swap_buffer(msg->data,r->gran);
		}else{
			ms_filter_notify_event(MS_FILTER(r),MS_READ_EVENT_EOF,NULL);
			ms_trace("End of file reached.");
			r->state=MS_READ_STATE_STOPPED;
		}				
	}	
}
Esempio n. 3
0
void swap_buffers_tolast(){
	if(shellbuff.changed == 0){
		swap_buffer();
		shellbuff.changed = 1;
	}
	return;
}
Esempio n. 4
0
void swap_buffers_tofirst(){
	if(shellbuff.changed == 1){
		swap_buffer();
		shellbuff.changed = 0;
	}
	return;
}
_inline void openmp_rows(transform_direction dir, cpx **in, cpx **out, const cpx *w, const int n)
{
#pragma omp parallel for schedule(static)
    for (int row = 0; row < n * n; row += n)
        openmp_const_geom_2d_helper(dir, (*in) + row, (*out) + row, w, n);
    if (log2_32(n) % 2 == 0)
        swap_buffer(in, out);
}
void openmp_const_geom_2d(transform_direction dir, cpx **in, cpx **out, const int n)
{
    cpx *w = (cpx *)malloc(sizeof(cpx) * n);
    openmp_twiddle_factors(w, dir, n);    
    openmp_rows(dir, in, out, w, n);
    openmp_transpose(*out, *in, n);
    openmp_rows(dir, in, out, w, n);
    openmp_transpose(*out, *in, n);
    swap_buffer(in, out);
    free(w);
}
_inline void openmp_const_geom_2d_helper(transform_direction dir, cpx *in, cpx *out, const cpx *w, const int n)
{
    const int n_half = n / 2;
    int steps_left = log2_32(n);
    int steps = 0;
    openmp_inner_body(in, out, w, 0xffffffff << steps, n_half);
    while (++steps < steps_left) {
        swap_buffer(&in, &out);
        openmp_inner_body(in, out, w, 0xffffffff << steps, n_half);
    }
    openmp_bit_reverse(out, dir, 32 - steps_left, n);
}
Esempio n. 8
0
void ms_ring_player_process(MSRingPlayer *r)
{
	MSFifo *f;
	gint err;
	gint processed=0;
	gint gran=r->gran;
	char *p;
	
	g_return_if_fail(gran>0);
	/* process output fifos*/
	
	f=r->foutputs[0];
	ms_fifo_get_write_ptr(f,gran,(void**)&p);
	g_return_if_fail(p!=NULL);
	for (processed=0;processed<gran;){
		switch(r->state){
			case PLAY_RING:
				err=read(r->fd,&p[processed],gran-processed);
				if (err<0)
				{
					memset(&p[processed],0,gran-processed);
					processed=gran;
					g_warning("ms_ring_player_process: failed to read: %s.\n",strerror(errno));
					return;
				}
				else if (err<gran)
				{/* end of file */
					
					r->current_pos=r->silence_bytes;
					lseek(r->fd,WAVE_HEADER_OFFSET,SEEK_SET);
					r->state=PLAY_SILENCE;
          ms_filter_notify_event(MS_FILTER(r),MS_RING_PLAYER_END_OF_RING_EVENT,NULL);
				}
				if (r->need_swap) swap_buffer(&p[processed],err);
				processed+=err;
			break;
			case PLAY_SILENCE:
				err=gran-processed;
				if  (r->current_pos>err){
					memset(&p[processed],0,err);
					r->current_pos-=gran;
					processed=gran;
				}else{
					memset(&p[processed],0,r->current_pos);
					processed+=r->current_pos;
					r->state=PLAY_RING;
				}
			break;
		}
	}
}
void openmp_const_geom(transform_direction dir, cpx **in, cpx **out, const int n)
{
    const int n_half = n / 2;
    int steps_left = log2_32(n);
    int steps = 0;
    cpx *w = (cpx *)malloc(sizeof(cpx) * n);
    openmp_twiddle_factors(w, dir, n);
    openmp_inner_body(*in, *out, w, 0xffffffff << steps, n_half);
    while (++steps < steps_left) {
        swap_buffer(in, out);
        openmp_inner_body(*in, *out, w, 0xffffffff << steps, n_half);
    }
    openmp_bit_reverse(*out, dir, 32 - steps_left, n);
    free(w);
}
Esempio n. 10
0
static void do_send(struct rp_generator_t *self)
{
    assert(self->buf_sending->size == 0);

    swap_buffer(
        &self->buf_sending,
        self->client != NULL ? &self->client->sock->input : &self->last_content_before_send);

    if (self->buf_sending->size != 0) {
        h2o_iovec_t buf = h2o_iovec_init(self->buf_sending->bytes, self->buf_sending->size);
        h2o_send(self->src_req, &buf, 1, self->client == NULL);
    } else if (self->client == NULL) {
        h2o_send(self->src_req, NULL, 0, 1);
    }
}
void openmp_const_geom_alt(transform_direction dir, cpx **in, cpx **out, const int n)
{
    int bit = log2_32(n);
    const int leading_bits = 32 - bit;
    int steps = --bit;
    unsigned int mask = 0xffffffff << (steps - bit);
    float global_angle = dir * M_2_PI / n;
    openmp_inner_body(*in, *out, global_angle, mask, n);
    while (bit-- > 0) {
        swap_buffer(in, out);
        mask = 0xffffffff << (steps - bit);
        openmp_inner_body(*in, *out, global_angle, mask, n);
    }
    openmp_bit_reverse(*out, dir, leading_bits, n);
}
Esempio n. 12
0
File: storage.c Progetto: barak/lush
static void storage_serialize(at **pp, int code)
{
   storage_t *st;
   int type, kind;
   size_t size;

   if (code != SRZ_READ) {
      st = Mptr(*pp);
      type = (int)st->type;
      kind = (int)st->kind;
      size = st->size;
   }
   // Read/write basic info
   serialize_int(&type, code);
   serialize_int(&kind, code);
   serialize_size(&size, code);

   // Create storage if needed
   if (code == SRZ_READ) {
      st = new_storage_managed((storage_type_t)type, size, NIL);
      *pp = st->backptr;
   }

   // Read/write storage data
   st = Mptr(*pp);
   if (type == ST_AT) {
      at **data = st->data;
      for (int i=0; i<size; i++)
         serialize_atstar( &data[i], code);

   } else  {
      FILE *f = serialization_file_descriptor(code);
      if (code == SRZ_WRITE) {
         extern int in_bwrite;
         in_bwrite += sizeof(int) + size * storage_sizeof[type];
         write4(f, STORAGE_NORMAL);
         storage_save(st, f);
         
      } else if (code == SRZ_READ) {
         int magic = read4(f);
         storage_load(st, f);
         if (magic == STORAGE_SWAPPED)
            swap_buffer(st->data, size, storage_sizeof[type]);
         else if (magic != STORAGE_NORMAL)
            RAISEF("Corrupted binary file",NIL);
      }
   }
}
Esempio n. 13
0
static void
step (AppData *appdata)
{
  cairo_t *cr;

  set_up_for_buffer (appdata, &cr);

  cairo_save (cr);
  cairo_set_source_rgb (cr, 1, 1, 1);
  cairo_paint (cr);

  appdata->x += 10 * appdata->dir;
  if (appdata->x > 1239 || appdata->x < 0)
    appdata->dir *= -1;

  cairo_set_source_rgb (cr, 1, 0, 0);
  cairo_rectangle (cr, appdata->x - 50, 75, 681, 800);
  cairo_fill (cr);

  cairo_translate (cr, appdata->x, 200);
  cairo_set_source_surface (cr, appdata->craig, 0, 0);
  cairo_rectangle (cr, 0, 0, 681, 800);
  cairo_fill (cr);
  cairo_restore (cr);

  /*
  cairo_save (cr);
  cairo_scale (cr, 2, 2);
  rsvg_handle_render_cairo (appdata->tiger, cr);
  cairo_restore (cr);
  */

  swap_buffer (appdata);

  step_cursor (appdata);
  step_cursor (appdata);
  step_cursor (appdata);
  step_cursor (appdata);
  step_cursor (appdata);
  step_cursor (appdata);
  step_cursor (appdata);

  ++appdata->time;
}
Esempio n. 14
0
void *tsout_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
{
	struct ngene_channel *chan = priv;
	struct ngene *dev = chan->dev;
	u32 alen;

	alen = dvb_ringbuffer_avail(&dev->tsout_rbuf);
	alen -= alen % 188;

	if (alen < len)
		FillTSBuffer(buf + alen, len - alen, flags);
	else
		alen = len;
	dvb_ringbuffer_read(&dev->tsout_rbuf, buf, alen);
	if (flags & DF_SWAP32)
		swap_buffer((u32 *)buf, alen);
	wake_up_interruptible(&dev->tsout_rbuf.queue);
	return buf;
}
Esempio n. 15
0
void *tsin_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
{
	struct ngene_channel *chan = priv;
	struct ngene *dev = chan->dev;


	if (flags & DF_SWAP32)
		swap_buffer(buf, len);

	if (dev->ci.en && chan->number == 2) {
		while (len >= 188) {
			if (memcmp(buf, fill_ts, sizeof fill_ts) != 0) {
				if (dvb_ringbuffer_free(&dev->tsin_rbuf) >= 188) {
					dvb_ringbuffer_write(&dev->tsin_rbuf, buf, 188);
					wake_up(&dev->tsin_rbuf.queue);
#ifdef DEBUG_CI_XFER
					ok++;
#endif
				}
#ifdef DEBUG_CI_XFER
				else
					overflow++;
#endif
			}
#ifdef DEBUG_CI_XFER
			else
				stripped++;

			if (ok % 100 == 0 && overflow)
				printk(KERN_WARNING "%s: ok %u overflow %u dropped %u\n", __func__, ok, overflow, stripped);
#endif
			buf += 188;
			len -= 188;
		}
		return NULL;
	}

	if (chan->users > 0)
		dvb_dmx_swfilter(&chan->demux, buf, len);

	return NULL;
}
Esempio n. 16
0
int rdieee_file(float *array, int n, int header, FILE *input) {

    int i, j;
    unsigned int l;
    unsigned char buff[BSIZ];
    unsigned char h4[4],t4[4];
    float *p;

    n = n*4;

    if (header) {
	if (fread(h4,1,4,input) != 4) fatal_error("rdieee: header read","");
	if (ieee_little_endian) 
	    l = (h4[3] << 24) | (h4[2] << 16) | (h4[1] << 8) | h4[0];
	else
	    l = (h4[0] << 24) | (h4[1] << 16) | (h4[2] << 8) | h4[3];
	
	if (l != n) fatal_error_ii("rdieee: bad header=%u expecting %d",l,n);
    }

    p = array;
    while (n > 0) {
	j =  n < BSIZ ? n : BSIZ;
	fread(buff,1,j,input);
	if (ieee_little_endian) swap_buffer(buff, j);
	for (i = 0; i < j; i += 4) {
	    *p++ = ieee2flt(buff + i);
	}
	n = n - j;
    }

    if (header) {
	if (fread(t4,1,4,input) != 4) fatal_error("rdieee: trailer read","");
	if (h4[0] != t4[0] || h4[1] != t4[1] || h4[2] != t4[2] || h4[3] != t4[3])
	   fatal_error("rdieee: bad trailer","");
    }

    return 0;
}
Esempio n. 17
0
void Game::update(){
	//std::cout<<"Game::update() 1"<<std::endl;
	input->update();
	handle_game_signal();
	//std::cout<<"Game::update() 2"<<std::endl;
	//===========game update===============
	game_update();
	Scene* cur_scene=get_cur_scene();
	//std::cout<<"Game::update() cur_scene="<<cur_scene->scene_name()<<std::endl;
	//===============system pre_update=======================
	//std::cout<<"Game::update() controller_system->pre_update()"<<std::endl;
	controller_system->pre_update();
	//std::cout<<"Game::update() controller_system->pre_update() end"<<std::endl;
	//===============scene_update()======================
	//std::cout<<"Game::update() cur_scene="<<cur_scene->scene_name()<<std::endl;
	cur_scene->update();
	//std::cout<<"Game::update() cur_scene->update() end"<<std::endl;
	//===========system update=============
	controller_system->update();
	//std::cout<<"Game::update() controller_system->update() end"<<std::endl;
	//===========update end================
	cur_scene->scene_update_end();
	//===========draw start================
	//std::cout<<"Game::update() cur_scene->draw_scene(); start"<<std::endl;
	cur_scene->draw_scene();
	//std::cout<<"Game::update() cur_scene->draw_scene(); end"<<std::endl;
	//===========render start==============
	//std::cout<<"Game::update() renderer->render() start"<<std::endl;
	renderer->render();
	//std::cout<<"Game::update() renderer->render() end"<<std::endl;
	//===========wait for render end=======

	//render_thread->join();
	draw->clear_tmp_data();
	//std::cout<<"Game::update() draw->clear_tmp_data()"<<std::endl;
	swap_buffer();//swap screen buffer
	//std::cout<<"Game::update() end"<<std::endl;
}
Esempio n. 18
0
/*------------------------------------------------------------------------
 * main - extract_region
 *
 *        input : argc, argv - command line args
 *
 *      result: EXIT_SUCCESS or EXIT_FAILURE
 *
 *      effect: Input consists of grid file file_in whose dimensions are
 *              defined by bytes_per_cell, cols_in, and rows_in.
 *              Output consists of raster file file_out consisting of a region
 *              of file_in defined by col_start, row_start, cols_out, and
 *              rows_out and having the same number of bytes_per_cell as
 *              file_in.
 *------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
  char *option;
  int bytes_per_cell, cols_in, rows_in;
  int col_start, row_start, cols_out, rows_out;
  char *file_in;
  char *file_out;

  byte1 *buf_in  = NULL;
  byte1 *buf_out = NULL;
  byte1 *buf_temp = NULL;
  int fd_in  = -1;
  int fd_out = -1;
  bool there_were_errors;
  int row;
  int bytes_per_row_in, bytes_per_row_out;
  int last_row_in_region;
  bool byte_swap;
  double scale;
  bool float_scale;
  int cells_per_col;

  /*
   *     set defaults
   */
  verbose = very_verbose = NULL;
  byte_swap = FALSE;
  scale = 1.0;
  float_scale = FALSE;
  cells_per_col = 1;
  there_were_errors = FALSE;

  /*
   *     get command line options
   */
  while (--argc > 0 && (*++argv)[0] == '-') {
    for (option = argv[0]+1; *option != '\0'; option++) {
      switch (*option) {
      case 'v':
        if (very_verbose)
          very_very_verbose = stdout;
        if (verbose)
          very_verbose = stdout;
        verbose = stdout;
        break;
      case 'V':
        fprintf(stderr,"%s\n", extract_region_c_rcsid);
        break;
      case 'b':
        byte_swap = TRUE;
        break;
      case 's':
        ++argv; --argc;
        if (argc <= 0)
          DisplayInvalidParameter("scale");
        if (sscanf(*argv, "%lf", &scale) != 1)
          DisplayInvalidParameter("scale");
        break;
      case 'f':
        float_scale = TRUE;
        break;
      case 'c':
        ++argv; --argc;
        if (argc <= 0)
          DisplayInvalidParameter("cells_per_col");
        if (sscanf(*argv, "%d", &cells_per_col) != 1)
          DisplayInvalidParameter("cells_per_col");
        break;
      default:
        fprintf(stderr, "extract_region: invalid option %c\n", *option);
        error_exit(usage);
      }
    }
  }

  /*
   *     get command line args
   */
  if (argc != 9)
    error_exit(usage);
  if (sscanf(*argv++, "%d", &bytes_per_cell) != 1) {
    fprintf(stderr, "invalid bytes_per_cell value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &cols_in) != 1) {
    fprintf(stderr, "invalid cols_in value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &rows_in) != 1) {
    fprintf(stderr, "invalid rows_in value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &col_start) != 1) {
    fprintf(stderr, "invalid col_start value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &row_start) != 1) {
    fprintf(stderr, "invalid row_start value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &cols_out) != 1) {
    fprintf(stderr, "invalid cols_out value %s\n", *argv);
    error_exit(usage);
  }
  if (sscanf(*argv++, "%d", &rows_out) != 1) {
    fprintf(stderr, "invalid rows_out value %s\n", *argv);
    error_exit(usage);
  }
  file_in  = *argv++;
  file_out = *argv++;

  /*
   *     display command line parameters
   */
  if (verbose) {
    fprintf(stderr, "extract_region:    %s\n", extract_region_c_rcsid);
    fprintf(stderr, "  byte_swap:       %d\n", byte_swap);
    fprintf(stderr, "  scale:           %lf\n", scale);
    fprintf(stderr, "  float_scale:     %d\n", float_scale);
    fprintf(stderr, "  cells_per_col:   %d\n", cells_per_col);
    fprintf(stderr, "  bytes_per_cell:  %d\n", bytes_per_cell);
    fprintf(stderr, "  cols_in:         %d\n", cols_in);
    fprintf(stderr, "  rows_in:         %d\n", rows_in);
    fprintf(stderr, "  col_start:       %d\n", col_start);
    fprintf(stderr, "  row_start:       %d\n", row_start);
    fprintf(stderr, "  cols_out:        %d\n", cols_out);
    fprintf(stderr, "  rows_out:        %d\n", rows_out);
    fprintf(stderr, "  file_in:         %s\n", file_in);
    fprintf(stderr, "  file_out:        %s\n", file_out);
  }

  /*
   *     use loop even though it's one time through for easy error exit
   */
  for(;;) {

    /*
     *     check for a valid region
     */
    if (col_start + cols_out > cols_in) {
      fprintf(stderr,
              "extract_region: col_start + cols_out must be <= cols_in\n");
      there_were_errors = TRUE;
    }
    if (row_start + rows_out > rows_in) {
      fprintf(stderr,
              "extract_region: row_start + rows_out must be <= rows_in\n");
      there_were_errors = TRUE;
    }
    if (bytes_per_cell != 1 && bytes_per_cell != 2 &&
        bytes_per_cell != 4 && bytes_per_cell != 8) {
      fprintf(stderr,
              "extract_region: bytes_per_cell must be 1, 2, 4, or 8\n");
      there_were_errors = TRUE;
    }
    if (float_scale == TRUE && scale != 1.0 &&
        bytes_per_cell != 4 && bytes_per_cell != 8) {
      fprintf(stderr,
              "extract_region: bytes_per_cell must be 4 or 8 if -f is specified and scale != 1.0\n");
      there_were_errors = TRUE;
    }
    if (there_were_errors)
      break;

    /*
     *    initialize buffer size for i/o
     */
    bytes_per_row_in  = cols_in  * cells_per_col * bytes_per_cell;
    bytes_per_row_out = cols_out * cells_per_col * bytes_per_cell;
    last_row_in_region = row_start + rows_out - 1;

    /*
     *    allocate a buffer for each input and output grid file.
     */
    if (very_verbose)
      fprintf(stderr, "extract_region: allocating buffers\n");

    buf_in = (byte1 *)calloc(bytes_per_row_in, sizeof(byte1));
    if (!buf_in) {
      fprintf(stderr, "error allocating %d bytes for file_in buffer\n",
              bytes_per_row_in);
      perror("extract_region");
      there_were_errors = TRUE;
      break;
    }
    buf_out = buf_in + col_start * cells_per_col * bytes_per_cell;

    /*
     *     open input file
     */
    if (very_verbose)
      fprintf(stderr, "extract_region: opening input file\n");

    fd_in = open(file_in, O_RDONLY);
    if (fd_in < 0) {
      fprintf(stderr, "error opening %s\n", file_in);
      perror("extract_region");
      there_were_errors = TRUE;
      break;
    }

    /*
     *     open output file
     */
    if (very_verbose)
      fprintf(stderr, "extract_region: opening output file\n");

    fd_out = creat(file_out, 0644);
    if (fd_out < 0) {
      fprintf(stderr, "error opening %s\n", file_out);
      perror("extract_region");
      there_were_errors = TRUE;
      break;
    }

    /*
     *     seek to first row in region of input file
     */
    if (very_verbose)
      fprintf(stderr, "extract_region: seeking to first byte in region\n");

    if (lseek(fd_in,
              (off_t)row_start * bytes_per_row_in,
              SEEK_SET) == -1) {
      fprintf(stderr, "error seeking to first row in region of %s\n", file_in);
      perror("extract_region");
      there_were_errors = TRUE;
      break;
    }

    /*
     *    for each row
     */
    for (row = row_start; row <= last_row_in_region; row++) {
      if (very_very_verbose)
        fprintf(stderr, "reading row %d\n", row);
      if (read(fd_in, buf_in,
               bytes_per_row_in) != bytes_per_row_in) {
        fprintf(stderr, "error reading %s\n", file_in);
        perror("extract_region");
        there_were_errors = TRUE;
        break;
      }
      if (byte_swap)
        swap_buffer(buf_out, cols_out, cells_per_col, bytes_per_cell);
      if (scale != 1.0)
        scale_buffer(buf_out, cols_out, cells_per_col, bytes_per_cell,
                     scale, float_scale);
      if (very_very_verbose)
        fprintf(stderr, "writing row %d\n", row);
      if (write(fd_out, buf_out,
                bytes_per_row_out) != bytes_per_row_out) {
        fprintf(stderr, "error writing %s\n", file_out);
        perror("extract_region");
        there_were_errors = TRUE;
        break;
      }
    }
    break;
  }

  /*
   *      close input and output grid files
   */
  if (fd_out >= 0)
    close(fd_out);
  if (fd_in)
    close(fd_in);

  /*
   *      Deallocate buffers
   */
  if (buf_in)
    free(buf_in);
  if (buf_temp)
    free(buf_temp);

  if (very_verbose) {
    if (there_were_errors)
      fprintf(stderr, "extract_region: done, but there were errors\n");
    else
      fprintf(stderr, "extract_region: done, ok\n");
  }

  return (there_were_errors ? EXIT_FAILURE : EXIT_SUCCESS);
}
Esempio n. 19
0
/* During a receive, the cur_rx points to the current incoming buffer.
 * When we update through the ring, if the next incoming buffer has
 * not been given to the system, we just set the empty indicator,
 * effectively tossing the packet.
 */
static int
fec_enet_rx(struct net_device *ndev, int budget)
{
	struct fec_enet_private *fep = netdev_priv(ndev);
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
	struct bufdesc *bdp;
	unsigned short status;
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
	int	pkt_received = 0;

#ifdef CONFIG_M532x
	flush_cache_all();
#endif

	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {

		if (pkt_received >= budget)
			break;
		pkt_received++;

		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0)
			printk("FEC ENET: rcv is not +last\n");

		if (!fep->opened)
			goto rx_processing_done;

		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
			ndev->stats.rx_errors++;
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
				ndev->stats.rx_length_errors++;
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
				ndev->stats.rx_frame_errors++;
			if (status & BD_ENET_RX_CR)	/* CRC Error */
				ndev->stats.rx_crc_errors++;
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
				ndev->stats.rx_fifo_errors++;
		}

		/* Report late collisions as a frame error.
		 * On this error, the BD is closed, but we don't know what we
		 * have in the buffer.  So, just drop this frame on the floor.
		 */
		if (status & BD_ENET_RX_CL) {
			ndev->stats.rx_errors++;
			ndev->stats.rx_frame_errors++;
			goto rx_processing_done;
		}

		/* Process the incoming frame. */
		ndev->stats.rx_packets++;
		pkt_len = bdp->cbd_datlen;
		ndev->stats.rx_bytes += pkt_len;
		data = (__u8*)__va(bdp->cbd_bufaddr);

		dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);

		if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
			swap_buffer(data, pkt_len);

		/* This does 16 byte alignment, exactly what we need.
		 * The packet length includes FCS, but we don't want to
		 * include that when passing upstream as it messes up
		 * bridging applications.
		 */
		skb = netdev_alloc_skb(ndev, pkt_len - 4 + NET_IP_ALIGN);

		if (unlikely(!skb)) {
			printk("%s: Memory squeeze, dropping packet.\n",
					ndev->name);
			ndev->stats.rx_dropped++;
		} else {
			skb_reserve(skb, NET_IP_ALIGN);
			skb_put(skb, pkt_len - 4);	/* Make room */
			skb_copy_to_linear_data(skb, data, pkt_len - 4);
			skb->protocol = eth_type_trans(skb, ndev);

			/* Get receive timestamp from the skb */
			if (fep->hwts_rx_en && fep->bufdesc_ex) {
				struct skb_shared_hwtstamps *shhwtstamps =
							    skb_hwtstamps(skb);
				unsigned long flags;
				struct bufdesc_ex *ebdp =
					(struct bufdesc_ex *)bdp;

				memset(shhwtstamps, 0, sizeof(*shhwtstamps));

				spin_lock_irqsave(&fep->tmreg_lock, flags);
				shhwtstamps->hwtstamp = ns_to_ktime(
				    timecounter_cyc2time(&fep->tc, ebdp->ts));
				spin_unlock_irqrestore(&fep->tmreg_lock, flags);
			}

			if (!skb_defer_rx_timestamp(skb))
				napi_gro_receive(&fep->napi, skb);
		}

		bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
rx_processing_done:
		/* Clear the status flags for this buffer */
		status &= ~BD_ENET_RX_STATS;

		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;

		if (fep->bufdesc_ex) {
			struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;

			ebdp->cbd_esc = BD_ENET_RX_INT;
			ebdp->cbd_prot = 0;
			ebdp->cbd_bdu = 0;
		}

		/* Update BD pointer to next entry */
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);
		/* Doing this here will keep the FEC running while we process
		 * incoming frames.  On a heavily loaded network, we should be
		 * able to keep up at the expense of system resources.
		 */
		writel(0, fep->hwp + FEC_R_DES_ACTIVE);
	}
	fep->cur_rx = bdp;

	return pkt_received;
}
Esempio n. 20
0
static netdev_tx_t
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
{
	struct fec_enet_private *fep = netdev_priv(ndev);
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
	struct bufdesc *bdp;
	void *bufaddr;
	unsigned short	status;
	unsigned long flags;

	if (!fep->link) {
		/* Link is down or autonegotiation is in progress. */
		return NETDEV_TX_BUSY;
	}

	spin_lock_irqsave(&fep->hw_lock, flags);
	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

	status = bdp->cbd_sc;

	if (status & BD_ENET_TX_READY) {
		/* Ooops.  All transmit buffers are full.  Bail out.
		 * This should not happen, since ndev->tbusy should be set.
		 */
		printk("%s: tx queue full!.\n", ndev->name);
		spin_unlock_irqrestore(&fep->hw_lock, flags);
		return NETDEV_TX_BUSY;
	}

	/* Clear all of the status flags */
	status &= ~BD_ENET_TX_STATS;

	/* Set buffer length and buffer pointer */
	bufaddr = skb->data;
	bdp->cbd_datlen = skb->len;

	/*
	 * On some FEC implementations data must be aligned on
	 * 4-byte boundaries. Use bounce buffers to copy data
	 * and get it aligned. Ugh.
	 */
	if (((unsigned long) bufaddr) & FEC_ALIGNMENT) {
		unsigned int index;
		if (fep->bufdesc_ex)
			index = (struct bufdesc_ex *)bdp -
				(struct bufdesc_ex *)fep->tx_bd_base;
		else
			index = bdp - fep->tx_bd_base;
		memcpy(fep->tx_bounce[index], skb->data, skb->len);
		bufaddr = fep->tx_bounce[index];
	}

	/*
	 * Some design made an incorrect assumption on endian mode of
	 * the system that it's running on. As the result, driver has to
	 * swap every frame going to and coming from the controller.
	 */
	if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
		swap_buffer(bufaddr, skb->len);

	/* Save skb pointer */
	fep->tx_skbuff[fep->skb_cur] = skb;

	ndev->stats.tx_bytes += skb->len;
	fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;

	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
	bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, bufaddr,
			FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);

	/* Send it on its way.  Tell FEC it's ready, interrupt when done,
	 * it's the last BD of the frame, and to put the CRC on the end.
	 */
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
	bdp->cbd_sc = status;

	if (fep->bufdesc_ex) {

		struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
		ebdp->cbd_bdu = 0;
		if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
			fep->hwts_tx_en)) {
			ebdp->cbd_esc = (BD_ENET_TX_TS | BD_ENET_TX_INT);
			skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
		} else {

			ebdp->cbd_esc = BD_ENET_TX_INT;
		}
	}
	/* Trigger transmission start */
	writel(0, fep->hwp + FEC_X_DES_ACTIVE);

	/* If this was the last BD in the ring, start at the beginning again. */
	if (status & BD_ENET_TX_WRAP)
		bdp = fep->tx_bd_base;
	else
		bdp = fec_enet_get_nextdesc(bdp, fep->bufdesc_ex);

	if (bdp == fep->dirty_tx) {
		fep->tx_full = 1;
		netif_stop_queue(ndev);
	}

	fep->cur_tx = bdp;

	skb_tx_timestamp(skb);

	spin_unlock_irqrestore(&fep->hw_lock, flags);

	return NETDEV_TX_OK;
}
Esempio n. 21
0
void write_rawiv_float(float *result,FILE* fp)
{
	int i, j, k;
	float c_float;
	size_t fwrite_return;
	
	
	//#ifdef _LITTLE_ENDIAN
	if(!big_endian())
	  {
	    swap_buffer((char *)minext, 3, sizeof(float));
	    swap_buffer((char *)maxext, 3, sizeof(float));
	    swap_buffer((char *)&nverts, 1, sizeof(int));
	    swap_buffer((char *)&ncells, 1, sizeof(int));
	    swap_buffer((char *)dim, 3, sizeof(unsigned int));
	    swap_buffer((char *)orig, 3, sizeof(float));
	    swap_buffer((char *)span, 3, sizeof(float));
	  }
	//#endif 
	
	fwrite_return = fwrite(minext, sizeof(float), 3, fp);
	fwrite_return = fwrite(maxext, sizeof(float), 3, fp);
	fwrite_return = fwrite(&nverts, sizeof(int), 1, fp);
	fwrite_return = fwrite(&ncells, sizeof(int), 1, fp);
	fwrite_return = fwrite(dim, sizeof(unsigned int), 3, fp);
	fwrite_return = fwrite(orig, sizeof(float), 3, fp);
	fwrite_return = fwrite(span, sizeof(float), 3, fp);
	//#ifdef _LITTLE_ENDIAN
	if(!big_endian())
	  {
	    swap_buffer((char *)minext, 3, sizeof(float));
	    swap_buffer((char *)maxext, 3, sizeof(float));
	    swap_buffer((char *)&nverts, 1, sizeof(int));
	    swap_buffer((char *)&ncells, 1, sizeof(int));
	    swap_buffer((char *)dim, 3, sizeof(unsigned int));
	    swap_buffer((char *)orig, 3, sizeof(float));
	    swap_buffer((char *)span, 3, sizeof(float));
	  }
	//#endif 
	
	for (k=0; k<ZDIM; k++) 
		for (j=0; j<YDIM; j++)
			for (i=0; i<XDIM; i++) {
				
				c_float = result[IndexVect(i,j,k)];
				
				//#ifdef _LITTLE_ENDIAN
				if(!big_endian())
				  swap_buffer((char *)&c_float, 1, sizeof(float));
				//#endif 
				fwrite_return = fwrite(&c_float, sizeof(float), 1, fp);
				//#ifdef _LITTLE_ENDIAN
				if(!big_endian())
				  swap_buffer((char *)&c_float, 1, sizeof(float));
				//#endif 
			}
				
				fclose(fp);
}
Esempio n. 22
0
void read_data(int *xd, int *yd, int *zd, float **data, 
			   /*float *span_t, float *orig_t,*/ const char *input_name)
{
	float c_float;
	unsigned char c_unchar;
	unsigned short c_unshort;
	int i,j,k;
	float *dataset;
	
	struct stat filestat;
	size_t size[3];
	int datatype = 0;
	int found;
	FILE *fp;
	
	size_t fread_return=0;
	
	
	
	if ((fp=fopen(input_name, "rb"))==NULL){
		printf("read error...\n");
		exit(0);
	}
	stat(input_name, &filestat);
	
	/* reading RAWIV header */
	fread_return = fread(minext, sizeof(float), 3, fp);
	fread_return = fread(maxext, sizeof(float), 3, fp);
	fread_return = fread(&nverts, sizeof(int), 1, fp);
	fread_return = fread(&ncells, sizeof(int), 1, fp);
	//#ifdef _LITTLE_ENDIAN
	if(!big_endian())
	  {
	    swap_buffer((char *)minext, 3, sizeof(float));
	    swap_buffer((char *)maxext, 3, sizeof(float));
	    swap_buffer((char *)&nverts, 1, sizeof(int));
	    swap_buffer((char *)&ncells, 1, sizeof(int));
	  }
	//#endif  
	
	size[0] = 12 * sizeof(float) + 2 * sizeof(int) + 3 * sizeof(unsigned int) +
		nverts * sizeof(unsigned char);
	size[1] = 12 * sizeof(float) + 2 * sizeof(int) + 3 * sizeof(unsigned int) +
		nverts * sizeof(unsigned short);
	size[2] = 12 * sizeof(float) + 2 * sizeof(int) + 3 * sizeof(unsigned int) +
		nverts * sizeof(float);
	
	found = 0;
	for (i = 0; i < 3; i++)
		if (size[i] == (unsigned int)filestat.st_size)
		{
			if (found == 0)
			{
				datatype = i;
				found = 1;
			}
		}
			if (found == 0)
			{
				printf("Corrupted file or unsupported dataset type\n");
				exit(5);
			}
			
			
			fread_return = fread(dim, sizeof(unsigned int), 3, fp);
	fread_return = fread(orig, sizeof(float), 3, fp);
	fread_return = fread(span, sizeof(float), 3, fp);
	//#ifdef _LITTLE_ENDIAN
	if(!big_endian())
	  {
	    swap_buffer((char *)dim, 3, sizeof(unsigned int));
	    swap_buffer((char *)orig, 3, sizeof(float));
	    swap_buffer((char *)span, 3, sizeof(float));
	  }
	//#endif 
	/*
	 span_t[0] = span[0];
	 span_t[1] = span[1];
	 span_t[2] = span[2];
	 orig_t[0] = orig[0];
	 orig_t[1] = orig[1];
	 orig_t[2] = orig[2];
	 */
	XDIM = dim[0];
	YDIM = dim[1];
	ZDIM = dim[2];
	dataset = (float *)malloc(sizeof(float)*XDIM*YDIM*ZDIM);
	
	maxraw = -99999999.f;
	minraw = 99999999.f;
	
	if (datatype == 0) {
		printf("data type: unsigned char \n");
		for (i=0; i<ZDIM; i++)
			for (j=0; j<YDIM; j++)
				for (k=0; k<XDIM; k++) {
					fread_return = fread(&c_unchar, sizeof(unsigned char), 1, fp);
					dataset[IndexVect(k,j,i)]=(float)c_unchar;
					
					if (c_unchar > maxraw)
						maxraw = c_unchar;
					if (c_unchar < minraw)
						minraw = c_unchar;
				}
	}
		else if (datatype == 1) {
			printf("data type: unsigned short \n");
			for (i=0; i<ZDIM; i++)
				for (j=0; j<YDIM; j++)
					for (k=0; k<XDIM; k++) {
						fread_return = fread(&c_unshort, sizeof(unsigned short), 1, fp);
						//#ifdef _LITTLE_ENDIAN
						if(!big_endian())
						  swap_buffer((char *)&c_unshort, 1, sizeof(unsigned short));
						//#endif 
						dataset[IndexVect(k,j,i)]=(float)c_unshort;
						
						if (c_unshort > maxraw)
							maxraw = c_unshort;
						if (c_unshort < minraw)
							minraw = c_unshort;
					}
		}
			else if (datatype == 2) {
				printf("data type: float \n");
				for (i=0; i<ZDIM; i++) 
					for (j=0; j<YDIM; j++)
						for (k=0; k<XDIM; k++) {
							fread_return = fread(&c_float, sizeof(float), 1, fp);
							//#ifdef _LITTLE_ENDIAN
							if(!big_endian())
							  swap_buffer((char *)&c_float, 1, sizeof(float));
							//#endif 
							dataset[IndexVect(k,j,i)]=c_float;
							
							if (c_float > maxraw)
								maxraw = c_float;
							if (c_float < minraw)
								minraw = c_float;
						}
			}
				
				else {
					printf("error\n");
					fclose(fp);
					exit(1);
				}
				
				fclose(fp);
				
				for (i=0; i<ZDIM; i++) 
					for (j=0; j<YDIM; j++)
						for (k=0; k<XDIM; k++)
							dataset[IndexVect(k,j,i)] = 255*(dataset[IndexVect(k,j,i)] - 
															 minraw)/(maxraw-minraw); 
				
				printf("minimum = %f,   maximum = %f \n",minraw,maxraw);
				
				
				*xd = XDIM;
				*yd = YDIM;
				*zd = ZDIM;
				*data = dataset;
				
				loadedVolumeInfo.read(input_name);
}
Esempio n. 23
0
/* During a receive, the cur_rx points to the current incoming buffer.
 * When we update through the ring, if the next incoming buffer has
 * not been given to the system, we just set the empty indicator,
 * effectively tossing the packet.
 */
static void
fec_enet_rx(struct rtnet_device *ndev, int *packets, nanosecs_abs_t *time_stamp)
{
	struct fec_enet_private *fep = rtnetdev_priv(ndev);
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
	struct bufdesc *bdp;
	unsigned short status;
	struct	rtskb	*skb;
	ushort	pkt_len;
	__u8 *data;

#ifdef CONFIG_M532x
	flush_cache_all();
#endif
	rtdm_lock_get(&fep->hw_lock);

	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {

		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0)
			printk("FEC ENET: rcv is not +last\n");

		if (!fep->opened)
			goto rx_processing_done;

		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
			fep->stats.rx_errors++;
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
				fep->stats.rx_length_errors++;
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
				fep->stats.rx_frame_errors++;
			if (status & BD_ENET_RX_CR)	/* CRC Error */
				fep->stats.rx_crc_errors++;
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
				fep->stats.rx_fifo_errors++;
		}

		/* Report late collisions as a frame error.
		 * On this error, the BD is closed, but we don't know what we
		 * have in the buffer.  So, just drop this frame on the floor.
		 */
		if (status & BD_ENET_RX_CL) {
			fep->stats.rx_errors++;
			fep->stats.rx_frame_errors++;
			goto rx_processing_done;
		}

		/* Process the incoming frame. */
		fep->stats.rx_packets++;
		pkt_len = bdp->cbd_datlen;
		fep->stats.rx_bytes += pkt_len;
		data = (__u8*)__va(bdp->cbd_bufaddr);

		dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);

		if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
			swap_buffer(data, pkt_len);

		/* This does 16 byte alignment, exactly what we need.
		 * The packet length includes FCS, but we don't want to
		 * include that when passing upstream as it messes up
		 * bridging applications.
		 */
		skb = dev_alloc_rtskb(pkt_len - 4 + NET_IP_ALIGN,
				      &fep->skb_pool); /* RTnet */

		if (unlikely(!skb)) {
			printk("%s: Memory squeeze, dropping packet.\n",
					ndev->name);
			fep->stats.rx_dropped++;
		} else {
			rtskb_reserve(skb, NET_IP_ALIGN);
			rtskb_put(skb, pkt_len - 4);	/* Make room */
			memcpy(skb->data, data, pkt_len - 4);
			skb->protocol = rt_eth_type_trans(skb, ndev);
			skb->rtdev = ndev;
			skb->time_stamp = *time_stamp;
			rtnetif_rx(skb);
			(*packets)++; /* RTnet */
		}

		bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
				FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
rx_processing_done:
		/* Clear the status flags for this buffer */
		status &= ~BD_ENET_RX_STATS;

		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;

		/* Update BD pointer to next entry */
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp++;
		/* Doing this here will keep the FEC running while we process
		 * incoming frames.  On a heavily loaded network, we should be
		 * able to keep up at the expense of system resources.
		 */
		writel(0, fep->hwp + FEC_R_DES_ACTIVE);
	}
	fep->cur_rx = bdp;

	rtdm_lock_put(&fep->hw_lock);
}
Esempio n. 24
0
*/ void rebcmp_compose(REBCMP_CTX* ctx, REBGOB* winGob, REBGOB* gob, REBOOL only)
/*
**	Compose content of the specified gob. Main compositing function.
**
**  If the ONLY arg is TRUE then the specified gob area will be
**  rendered to the buffer at 0x0 offset.(used by TO-IMAGE)
**
***********************************************************************/
{
	REBINT max_depth = 1000; // avoid infinite loops
	REBD32 abs_x = 0;
	REBD32 abs_y = 0;
	REBD32 abs_ox;
	REBD32 abs_oy;
	REBGOB* parent_gob = gob;
	REBINT x = GOB_LOG_X_INT(gob);
	REBINT y = GOB_LOG_Y_INT(gob);
	REBINT w = GOB_LOG_W_INT(gob);
	REBINT h = GOB_LOG_H_INT(gob);
	/*
	RL_Print("Composing gob: %x (%dx%d, %dx%d) in wingob %x\n", 
			 gob,
			 (int)GOB_LOG_X(gob),
			 (int)GOB_LOG_Y(gob),
			 GOB_W_INT(gob),
			 GOB_H_INT(gob),
			 winGob);
			 */

	//reset clip region to window area
	if (ctx->Win_Region != NULL){
		XDestroyRegion(ctx->Win_Region);
	}
	ctx->Win_Region = XCreateRegion();

	//calculate absolute offset of the gob
	while (GOB_PARENT(parent_gob) && (max_depth-- > 0) && !GET_GOB_FLAG(parent_gob, GOBF_WINDOW))
	{
		abs_x += GOB_LOG_X(parent_gob);
		abs_y += GOB_LOG_Y(parent_gob);
		parent_gob = GOB_PARENT(parent_gob);
	}

	assert(max_depth > 0);

	//the offset is shifted to render given gob at offset 0x0 (used by TO-IMAGE)
	if (only){
		ctx->absOffset.x = -abs_x;
		ctx->absOffset.y = -abs_y;
		abs_x = 0;
		abs_y = 0;
	} else {
		ctx->absOffset.x = 0;
		ctx->absOffset.y = 0;
	}

	ctx->New_Clip.x = abs_x;
	ctx->New_Clip.y = abs_y;
	ctx->New_Clip.width = GOB_LOG_W_INT(gob);
	ctx->New_Clip.height = GOB_LOG_H_INT(gob);

	//handle newly added gob case
	if (!GET_GOB_STATE(gob, GOBS_NEW)){
		//calculate absolute old offset of the gob
		abs_ox = abs_x + (GOB_XO(gob) - GOB_LOG_X(gob));
		abs_oy = abs_y + (GOB_YO(gob) - GOB_LOG_Y(gob));

		//set region with old gob location and dimensions
		ctx->Old_Clip.x = abs_ox;
		ctx->Old_Clip.y = abs_oy;
		ctx->Old_Clip.width = GOB_WO_INT(gob);
		ctx->Old_Clip.height = GOB_HO_INT(gob);
		XUnionRectWithRegion(&ctx->Old_Clip, ctx->Win_Region, ctx->Win_Region);
		//RL_Print("OLD: %dx%d %dx%d\n",(REBINT)abs_ox, (REBINT)abs_oy, (REBINT)abs_ox + GOB_WO_INT(gob), (REBINT)abs_oy + GOB_HO_INT(gob));
	}
	//RL_Print("NEW: %dx%d %dx%d\n",(REBINT)abs_x, (REBINT)abs_y, (REBINT)abs_x + GOB_LOG_W_INT(gob), (REBINT)abs_y + GOB_LOG_H_INT(gob));

	//Create union of "new" and "old" gob location
	XUnionRectWithRegion(&ctx->New_Clip, ctx->Win_Region, ctx->Win_Region);
	/*
	XClipBox(ctx->Win_Region, &win_rect);
	RL_Print("Old+New, %dx%d,%dx%d\n",
			 win_rect.x,
			 win_rect.y,
			 win_rect.x + win_rect.width,
			 win_rect.y + win_rect.height);
			 */

	if (!XEmptyRegion(ctx->Win_Region))
	{
		swap_buffer(ctx);
		ctx->Window_Buffer = rebcmp_get_buffer(ctx);
		if (gob == winGob) {
			memset(ctx->Window_Buffer, 0, ctx->pixbuf_len);
		}

		//redraw gobs
		process_gobs(ctx, winGob);

		rebcmp_release_buffer(ctx);

		ctx->Window_Buffer = NULL;
	}

	//update old GOB area
	GOB_XO(gob) = GOB_LOG_X(gob);
	GOB_YO(gob) = GOB_LOG_Y(gob);
	GOB_WO(gob) = GOB_LOG_W(gob);
	GOB_HO(gob) = GOB_LOG_H(gob);
}
Esempio n. 25
0
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_init(void)
{
   size_t i;
   unsigned int disable_extra_mem;
   static int channels[] = { 0, 1, 2, 3 };
   /* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
   r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");

   /* set some other core parameters based on the config file values */
   no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
   disable_extra_mem = ConfigGetParamInt(g_CoreConfig, "DisableExtraMem");
#if 0
   count_per_op = ConfigGetParamInt(g_CoreConfig, "CountPerOp");
#endif

   if (count_per_op <= 0)
      count_per_op = 2;

   /* do byte-swapping if it's not been done yet */
   if (g_MemHasBeenBSwapped == 0)
   {
      swap_buffer(g_rom, 4, g_rom_size / 4);
      g_MemHasBeenBSwapped = 1;
   }

   if (g_DDMemHasBeenBSwapped == 0)
   {
      swap_buffer(g_ddrom, 4, g_ddrom_size / 4);
      g_DDMemHasBeenBSwapped = 1;
   }

   connect_all(&g_r4300, &g_dp, &g_sp,
         &g_ai, &g_pi, &g_ri, &g_si, &g_vi, &g_dd,
         g_rdram, (disable_extra_mem == 0) ? 0x800000 : 0x400000,
         g_rom, g_rom_size, g_ddrom, g_ddrom_size, g_dd_disk, g_dd_disk_size);

   init_memory();

   // Attach rom to plugins
   printf("Gfx RomOpen.\n");
   if (!gfx.romOpen())
   {
      printf("Gfx RomOpen failed.\n");
      return M64ERR_PLUGIN_FAIL;
   }
   printf("Input RomOpen.\n");
   if (!input.romOpen())
   {
      printf("Input RomOpen failed.\n");
      gfx.romClosed();
      return M64ERR_PLUGIN_FAIL;
   }

   /* connect external time source to AF_RTC component */
   g_si.pif.af_rtc.user_data = NULL;
   g_si.pif.af_rtc.get_time = get_time_using_C_localtime;

   /* connect external game controllers */
   for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
   {
      g_si.pif.controllers[i].user_data = &channels[i];
      g_si.pif.controllers[i].is_connected = egcvip_is_connected;
      g_si.pif.controllers[i].get_input = egcvip_get_input;
   }

   /* connect external rumblepaks */
   for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
   {
      g_si.pif.controllers[i].rumblepak.user_data = &channels[i];
      g_si.pif.controllers[i].rumblepak.rumble = rvip_rumble;
   }

   /* connect saved_memory.mempacks to mempaks */
   for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
   {
      g_si.pif.controllers[i].mempak.user_data = NULL;
      g_si.pif.controllers[i].mempak.save = dummy_save;
      g_si.pif.controllers[i].mempak.data = &saved_memory.mempack[i][0];
   }

   /* connect saved_memory.eeprom to eeprom */
   g_si.pif.eeprom.user_data = NULL;
   g_si.pif.eeprom.save = dummy_save;
   g_si.pif.eeprom.data = saved_memory.eeprom;
   if (ROM_SETTINGS.savetype != EEPROM_16KB)
   {
      /* 4kbits EEPROM */
      g_si.pif.eeprom.size = 0x200;
      g_si.pif.eeprom.id = 0x8000;
   }
   else
   {
      /* 16kbits EEPROM */
      g_si.pif.eeprom.size = 0x800;
      g_si.pif.eeprom.id = 0xc000;
   }

   /* connect saved_memory.flashram to flashram */
   g_pi.flashram.user_data = NULL;
   g_pi.flashram.save = dummy_save;
   g_pi.flashram.data = saved_memory.flashram;

   /* connect saved_memory.sram to SRAM */
   g_pi.sram.user_data = NULL;
   g_pi.sram.save = dummy_save;
   g_pi.sram.data = saved_memory.sram;

#ifdef DBG
   if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
      init_debugger();
#endif

   g_EmulatorRunning = 1;
   StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);

   /* call r4300 CPU core and run the game */
   r4300_reset_hard();
   r4300_reset_soft();
   r4300_init();


   return M64ERR_SUCCESS;
}
Esempio n. 26
0
/*NAPI polling Receive packets */
static int fec_rx_poll(struct napi_struct *napi, int budget)
{
	struct  fec_enet_private *fep =
		container_of(napi, struct fec_enet_private, napi);
	struct net_device *ndev = napi->dev;
	struct  fec_ptp_private *fpp = fep->ptp_priv;
	const struct platform_device_id *id_entry =
				platform_get_device_id(fep->pdev);
	int pkt_received = 0;
	struct bufdesc *bdp;
	unsigned short status;
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;

	if (fep->use_napi)
		WARN_ON(!budget);

#ifdef CONFIG_M532x
	flush_cache_all();
#endif

	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
		if (pkt_received >= budget)
			break;
		pkt_received++;

		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0)
			dev_err(&ndev->dev, "FEC ENET: rcv is not +last\n");

		if (!fep->opened)
			goto rx_processing_done;

		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
			ndev->stats.rx_errors++;
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
				ndev->stats.rx_length_errors++;
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
				ndev->stats.rx_frame_errors++;
			if (status & BD_ENET_RX_CR)	/* CRC Error */
				ndev->stats.rx_crc_errors++;
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
				ndev->stats.rx_fifo_errors++;
		}

		/* Report late collisions as a frame error.
		 * On this error, the BD is closed, but we don't know what we
		 * have in the buffer.  So, just drop this frame on the floor.
		 */
		if (status & BD_ENET_RX_CL) {
			ndev->stats.rx_errors++;
			ndev->stats.rx_frame_errors++;
			goto rx_processing_done;
		}

		/* Process the incoming frame. */
		ndev->stats.rx_packets++;
		pkt_len = bdp->cbd_datlen;
		ndev->stats.rx_bytes += pkt_len;
		data = (__u8 *)__va(bdp->cbd_bufaddr);

		if (bdp->cbd_bufaddr)
			dma_unmap_single(&ndev->dev, bdp->cbd_bufaddr,
				FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);

		if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
			swap_buffer(data, pkt_len);

		/* This does 16 byte alignment, exactly what we need.
		 * The packet length includes FCS, but we don't want to
		 * include that when passing upstream as it messes up
		 * bridging applications.
		 */
		skb = dev_alloc_skb(pkt_len - 4 + NET_IP_ALIGN);

		if (unlikely(!skb)) {
			dev_err(&ndev->dev,
			"%s: Memory squeeze, dropping packet.\n", ndev->name);
			ndev->stats.rx_dropped++;
		} else {
			skb_reserve(skb, NET_IP_ALIGN);
			skb_put(skb, pkt_len - 4);	/* Make room */
			skb_copy_to_linear_data(skb, data, pkt_len - 4);
			/* 1588 messeage TS handle */
			if (fep->ptimer_present)
				fec_ptp_store_rxstamp(fpp, skb, bdp);
			skb->protocol = eth_type_trans(skb, ndev);
			netif_receive_skb(skb);
		}

		bdp->cbd_bufaddr = dma_map_single(&ndev->dev, data,
				FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
rx_processing_done:
		/* Clear the status flags for this buffer */
		status &= ~BD_ENET_RX_STATS;

		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;
#ifdef CONFIG_ENHANCED_BD
		bdp->cbd_esc = BD_ENET_RX_INT;
		bdp->cbd_prot = 0;
		bdp->cbd_bdu = 0;
#endif

		/* Update BD pointer to next entry */
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp++;
		/* Doing this here will keep the FEC running while we process
		 * incoming frames.  On a heavily loaded network, we should be
		 * able to keep up at the expense of system resources.
		 */
		writel(0, fep->hwp + FEC_R_DES_ACTIVE);
	}
	fep->cur_rx = bdp;

	if (pkt_received < budget) {
		napi_complete(napi);
		fec_rx_int_is_enabled(ndev, true);
	}

	return pkt_received;
}
Esempio n. 27
0
void to_big_endian_buffer(void *buffer, size_t length, size_t count)
{
#ifndef M64P_BIG_ENDIAN
    swap_buffer(buffer, length, count);
#endif
}
Esempio n. 28
0
File: bpnn.cpp Progetto: kymo/DECNN
void BPNN::_load_train_data() {
	
	const char fileName[] = "train-images.idx3-ubyte";  
	const char labelFileName[] = "train-labels.idx1-ubyte";  
    ifstream lab_ifs(labelFileName, ios_base::binary);  
	ifstream ifs(fileName, ios_base::binary);  
	
	if( lab_ifs.fail() ) 	{
		cerr << "[ERROR] error when open the label train file!" << endl;
		exit (0);
	}
	
	if (ifs.fail()) {
		cerr << "[ERROR] error when open the train file!" << endl;
		exit (0);
	}
	
    //Read train data number and image rows / cols   
    char magicNum[4], ccount[4], crows[4], ccols[4];  
	
    ifs.read(magicNum, sizeof(magicNum));  
    ifs.read(ccount, sizeof(ccount));  
    ifs.read(crows, sizeof(crows));  
    ifs.read(ccols, sizeof(ccols));
	
	swap_buffer(magicNum);
	swap_buffer(ccount);
	swap_buffer(crows);
	swap_buffer(ccols);

	int count, rows, cols;  
    memcpy(&count, ccount, sizeof(count));  
    memcpy(&rows, crows, sizeof(rows));  
    memcpy(&cols, ccols, sizeof(cols));  

	lab_ifs.read(magicNum, sizeof(magicNum));
	lab_ifs.read(ccount, sizeof(magicNum));

	int idx = 0;
	
	while(! ifs.eof() && idx < _train_sample_cnt)
	{
		int pt = 0;
		double val[28][28];
		for(int i = 0; i < 28; i ++)
		{
			for(int j = 0; j < 28; j ++)
			{
				char st[4] ={'0'};
				ifs.read(st, 1);
				int t = 0;
				memcpy(&t, st, sizeof(t));
				// load _x feature
				// _x[idx][pt ++] = t;
				val[i][j] = t;
			}
		}
		int tot = 0;
		for ( int i = 0; i < 7; i ++) {
			for ( int j = 0; j < 7; j ++) {
				int cnt = 0;
				for ( int k = i * 4; k < i * 4 + 4; k ++) {
					for ( int l = j * 4; l < j * 4 + 4; l ++) {
						if ( val[k][l] > 0 ) {
							cnt += 1;
						}

					}
				}
				_x[idx][pt ++] = cnt;
				tot += cnt;
			}
		}
		for ( int i = 0; i < pt; i ++) {
			_x[idx][i] /= tot*1.0;
		}
		

		char num[4] = {'0'};
		lab_ifs.read(num, 1);
		int out;
		
		memcpy(&out, num, sizeof(out));
		memset(_y[idx], 0, sizeof(_y[idx]));
		_y[idx][out] = 1;
		idx += 1;
	}
	
	cerr << "[LOG] Train data is loaded completed! "<<endl;
}
Esempio n. 29
0
void ZDisplay::update(uint32_t dtime)
{
    swap_buffer();
}