Exemple #1
0
static int file_to_fb(const char * srcpath)
{
	int ret = -1;
	BMP_READ * bmp = NULL;
	struct FB * fb = NULL;
	int sw, sh;
	int srcbpp, dstbpp;
	void * pdata = NULL, * bmpdata = NULL;
	RGB_CONVERT_FUN convert_func = NULL;
	
	do 
	{
		bmp = bmp_open(srcpath);
		if (!bmp) {
			break;
		}
		fb = fb_create(0);
		if (!fb) {
			break;
		}
		
		sw = bmp_width(bmp);
		sh = bmp_height(bmp);
		bmpdata = bmp_data(bmp);
		srcbpp = bmp_bpp(bmp);
		dstbpp = fb_bpp(fb);
		
		convert_func = get_convert_func(srcbpp, dstbpp);
		if (convert_func) {
			pdata = convert_func(bmpdata, sw, sh);
			bmpdata = pdata;
		}
		
		if (!bmp_forward(bmp)) {
			line_reversal(bmpdata, sw, sh, dstbpp);
		}
		
		rgb_copy(bmpdata, fb_bits(fb), sw, sh, fb_width(fb), fb_height(fb), dstbpp);
		ret = 0;
	} while (0);
	
	fb_destory(fb);
	bmp_close(bmp);
	if (pdata) {
		free(pdata);
	}
	return ret;	
}
Exemple #2
0
static int file_to_file(const char * srcpath, const char * dstpath, int output_rgb)
{
	int ret = -1;
	BMP_READ * bmp = NULL;
	int w, h;
	int srcbpp, dstbpp;
	void * pdata = NULL, * bmpdata = NULL;
	RGB_CONVERT_FUN convert_func = NULL;

	do 
	{
		bmp = bmp_open(srcpath);
		if (!bmp) {
			break;
		}
		
		w = bmp_width(bmp);
		h = bmp_height(bmp);
		bmpdata = bmp_data(bmp);
		srcbpp = bmp_bpp(bmp);
		dstbpp = g_rgbbpp[output_rgb];

		convert_func = get_convert_func(srcbpp, dstbpp);
		if (convert_func) {
			pdata = convert_func(bmpdata, w, h);
			bmpdata = pdata;
		}

		if (!bmp_forward(bmp)) {
			line_reversal(bmpdata, w, h, dstbpp);
		}
		
		ret = save_bmp(dstpath, w, h, bmpdata, dstbpp);
	} while (0);

	bmp_close(bmp);
	if (pdata) {
		free(pdata);
	}
	return ret;	
}
Exemple #3
0
/*
 * Copy a tile from our tile image, loaded previously, into tile RAM.  In the
 * case of tiles with a width or height larger than 8 pixels, this will result
 * in multiple tile positions being occupied in video RAM.
 */
void nds_load_graphics_tile(int tile_idx, coord_t coords) 
{
  int glyph = map->glyphs[coords.y][coords.x];
  int i, j, x;
  int width, height, bpp, row_bytes;
  int bmp_tile_x, bmp_tile_y;
  u8 *bmp_row_start;
  u16 *tile_row_start;

  /* Next, get a few fields from the BMP headers that we'll need. */

  width = bmp_width(&tiles);
  height = bmp_height(&tiles);
  bpp = bmp_bpp(&tiles);

  /*
   * Compute the number of bytes in each row of 8-pixel tiles.
   *
   * This works explicitely because each tile component is 8 pixels wide.
   * Thus, the number of bytes in a row is (8 * (bpp / 8)), which just
   * ends up being bpp.
   */

  row_bytes = tile_width_in_tiles * bpp;

  /* Now calculate the pointer which points to the start of the BMP row */

  bmp_tile_y = glyph2tile[glyph] / width_in_tiles;
  bmp_tile_x = width_in_tiles - glyph2tile[glyph] % width_in_tiles;

  bmp_row_start = tiles.bitmap + tiles.bitmap_length - 
                  bmp_tile_y * TILE_HEIGHT * width_in_tiles * row_bytes - 
                  bmp_tile_x * row_bytes ;

  for (j = 0; j < tile_height_in_tiles; j++) {
    int y;

    for (y = 0; y < 8; y++) {
      for (i = 0; i < tile_width_in_tiles; i++) {
        tile_row_start = tile_ram + (tile_idx + j * tile_width_in_tiles + i) * bpp * 8 / 2 + y * bpp / 2; 

        /* Again, this works because 8 * (bpp / 8) == bpp */

        for (x = 0; x < bpp; x += 2, bmp_row_start += 2) {
          if (bpp == 4) {
            u16 a, b, c, d;

            a = (bmp_row_start[0] & 0xF0) >> 4;
            b = (bmp_row_start[0] & 0x0F);
            c = (bmp_row_start[1] & 0xF0) >> 4;
            d = (bmp_row_start[1] & 0x0F);

            tile_row_start[x / 2] = (d << 12) | (c << 8) | (b << 4) | (a << 0);
          } else {
            tile_row_start[x / 2] = (bmp_row_start[1] << 8) |
                                     bmp_row_start[0];
          }
        }
      }

      bmp_row_start -= row_bytes * width_in_tiles + row_bytes;
    }