int s2636_device::check_collision( int spriteno1, int spriteno2, const rectangle &cliprect )
{
int checksum = 0;
UINT8* attr1 = &m_work_ram[sprite_offsets[spriteno1]];
UINT8* attr2 = &m_work_ram[sprite_offsets[spriteno2]];
/* TODO: does not check shadow sprites yet */
m_collision_bitmap->fill(0, cliprect);
if ((attr1[0x0a] != 0xff) && (attr2[0x0a] != 0xff))
{
int x, y;
int x1 = attr1[0x0a] + m_x_offset;
int y1 = attr1[0x0c] + m_y_offset;
int x2 = attr2[0x0a] + m_x_offset;
int y2 = attr2[0x0c] + m_y_offset;
int expand1 = (m_work_ram[0xc0] >> (spriteno1 << 1)) & 0x03;
int expand2 = (m_work_ram[0xc0] >> (spriteno2 << 1)) & 0x03;
/* draw first sprite */
draw_sprite(attr1, 1, y1, x1, expand1, FALSE, *m_collision_bitmap, cliprect);
/* get fingerprint */
for (x = x1; x < x1 + SPRITE_WIDTH; x++)
for (y = y1; y < y1 + SPRITE_HEIGHT; y++)
{
if (!cliprect.contains(x, y))
continue;
checksum = checksum + m_collision_bitmap->pix16(y, x);
}
/* black out second sprite */
draw_sprite(attr2, 0, y2, x2, expand2, FALSE, *m_collision_bitmap, cliprect);
/* remove fingerprint */
for (x = x1; x < x1 + SPRITE_WIDTH; x++)
for (y = y1; y < y1 + SPRITE_HEIGHT; y++)
{
if (!cliprect.contains(x, y))
continue;
checksum = checksum - m_collision_bitmap->pix16(y, x);
}
}
UINT32 magicard_state::screen_update_magicard(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
magicard_state *state = machine().driver_data<magicard_state>();
int x,y;
UINT32 count;
bitmap.fill(get_black_pen(machine()), cliprect); //TODO
if(!(SCC_DE_VREG)) //display enable
return 0;
count = ((SCC_VSR_VREG)/2);
if(SCC_FG_VREG) //4bpp gfx
{
for(y=0;y<300;y++)
{
for(x=0;x<84;x++)
{
UINT32 color;
color = ((m_magicram[count]) & 0x000f)>>0;
if(cliprect.contains((x*4)+3, y))
bitmap.pix32(y, (x*4)+3) = machine().pens[color];
color = ((m_magicram[count]) & 0x00f0)>>4;
if(cliprect.contains((x*4)+2, y))
bitmap.pix32(y, (x*4)+2) = machine().pens[color];
color = ((m_magicram[count]) & 0x0f00)>>8;
if(cliprect.contains((x*4)+1, y))
bitmap.pix32(y, (x*4)+1) = machine().pens[color];
color = ((m_magicram[count]) & 0xf000)>>12;
if(cliprect.contains((x*4)+0, y))
bitmap.pix32(y, (x*4)+0) = machine().pens[color];
count++;
}
}
}
else //8bpp gfx
{
for(y=0;y<300;y++)
uint32_t invqix_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y;
// this means freeze or blank or something
if (m_vctl == 0x100)
{
return 0;
}
if (m_vctl == 0x0000)
{
for(y=0;y<256;y++)
{
for(x=0;x<256;x++)
{
uint8_t r,g,b;
int pen_data;
pen_data = (m_vram[(x+y*256)]);
b = (pen_data & 0x001f);
g = (pen_data & 0x03e0) >> 5;
r = (pen_data & 0x7c00) >> 10;
r = (r << 3) | (r & 0x7);
g = (g << 3) | (g & 0x7);
b = (b << 3) | (b & 0x7);
if(cliprect.contains(x, y))
bitmap.pix32(y, x) = r << 16 | g << 8 | b;
}
}
}
else if (m_vctl == 0x0001) // flip
UINT32 jantotsu_state::screen_update_jantotsu(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x, y, i;
int count = 0;
UINT8 pen_i;
if(!m_display_on)
return 0;
for (y = 0; y < 256; y++)
{
for (x = 0; x < 256; x += 8)
{
UINT8 color;
for (i = 0; i < 8; i++)
{
color = m_col_bank;
for(pen_i = 0;pen_i<4;pen_i++)
color |= (((m_bitmap[count + pen_i*0x2000]) >> (7 - i)) & 1) << pen_i;
if (cliprect.contains(x + i, y))
bitmap.pix32(y, x + i) = machine().pens[color];
}
count++;
}
}
return 0;
}
UINT32 gunpey_state::screen_update_gunpey(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT16 *blit_buffer = m_blit_buffer;
int x,y;
int count;
count = 0;
for(y=0;y<512;y++)
{
for(x=0;x<512;x++)
{
UINT32 color;
int r,g,b;
color = (blit_buffer[count] & 0xffff);
b = (color & 0x001f) << 3;
g = (color & 0x03e0) >> 2;
r = (color & 0x7c00) >> 7;
if(cliprect.contains(x, y))
bitmap.pix32(y, x) = b | (g<<8) | (r<<16);
count++;
}
}
return 0;
}
uint32_t hd44102_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
for (int y = 0; y < 50; y++)
{
int z = m_page << 3;
for (int x = 0; x < 32; x++)
{
uint8_t data = m_ram[z / 8][y];
int sy = m_sy + z;
int sx = m_sx + y;
if (cliprect.contains(sx, sy))
{
int color = (m_status & STATUS_DISPLAY_OFF) ? 0 : BIT(data, z % 8);
bitmap.pix16(sy, sx) = color;
}
z++;
z %= 32;
}
}
return 0;
}
UINT32 lbeach_state::screen_update_lbeach(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
// draw bg layer (road)
m_bg_tilemap->set_scrolly(0, *m_scroll_y);
m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
// check collision
int sprite_code = *m_sprite_code & 0xf;
int sprite_x = *m_sprite_x * 2 - 4;
int sprite_y = 160;
m_colmap_car.fill(0, cliprect);
m_gfxdecode->gfx(2)->transpen(m_palette,m_colmap_car,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
bitmap_ind16 &fg_bitmap = m_fg_tilemap->pixmap();
m_collision_bg_car = 0;
m_collision_fg_car = 0;
for (int y = sprite_y; y < (sprite_y + 16); y++)
{
for (int x = sprite_x; x < (sprite_x + 16) && cliprect.contains(x, y); x++)
{
m_collision_bg_car |= (bitmap.pix16(y, x) & m_colmap_car.pix16(y, x) & 1);
m_collision_fg_car |= (fg_bitmap.pix16(y, x) & m_colmap_car.pix16(y, x) & 1);
}
}
// draw fg layer (tiles)
m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
// draw player car
m_gfxdecode->gfx(2)->transpen(m_palette,bitmap,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
return 0;
}
UINT32 prestige_state::screen_update(int bpp, screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int width = m_lcdc.fb_width + m_lcdc.lcd_w + 1;
for (int y = 0; y <= m_lcdc.lcd_h; y++)
{
int line_start;
if (y <= m_lcdc.split_pos)
line_start = m_lcdc.addr1 + y * width;
else
line_start = m_lcdc.addr2 + (y - m_lcdc.split_pos - 1) * width;
for (int sx = 0; sx <= m_lcdc.lcd_w; sx++)
{
UINT8 data = m_vram[(line_start + sx) & 0x1fff];
for (int x = 0; x < 8 / bpp; x++)
{
int pix = 0;
for (int b=0; b<bpp; b++)
pix |= BIT(data, 7 - b) << b;
if (cliprect.contains(sx * 8 / bpp + x, y))
bitmap.pix16(y, sx * 8 / bpp + x) = pix;
data <<= bpp;
}
}
}
return 0;
}
UINT32 taitowlf_state::screen_update_taitowlf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
bitmap.fill(m_palette->black_pen(), cliprect);
count = (0);
for(y=0;y<256;y++)
{
for(x=0;x<512;x++)
{
UINT32 color;
color = (m_bootscreen_rom[count] & 0xff);
if(cliprect.contains(x+0, y))
bitmap.pix32(y, x+0) = m_palette->pen(color);
count++;
}
}
return 0;
}
static void draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip)
{
bosco_state *state = machine.driver_data<bosco_state>();
if (1)
{
int star_cntr;
int set_a, set_b;
/* two sets of stars controlled by these bits */
set_a = (state->m_bosco_starblink[0] & 1);
set_b = (state->m_bosco_starblink[1] & 1) | 2;
for (star_cntr = 0;star_cntr < MAX_STARS;star_cntr++)
{
int x,y;
if ( (set_a == star_seed_tab[star_cntr].set) || ( set_b == star_seed_tab[star_cntr].set) )
{
x = (star_seed_tab[star_cntr].x + state->m_stars_scrollx) % 256;
y = (star_seed_tab[star_cntr].y + state->m_stars_scrolly) % 256;
/* dont draw the stars that are off the screen */
if ( x < 224 )
{
if (flip) x += 20*8;
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = STARS_COLOR_BASE + star_seed_tab[star_cntr].col;
}
}
}
}
}
void nitedrvr_state::draw_box(bitmap_ind16 &bitmap, const rectangle &cliprect, int bx, int by, int ex, int ey)
{
for (int y = by; y < ey; y++)
{
for (int x = bx; x < ex; x++)
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = 1;
}
}
void gpworld_state::draw_pixel(bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix32(y, x) = m_palette->pen(color);
}
INLINE void draw_pixel(bitmap_ind16 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = color;
}
INLINE void draw_pixel(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix32(y, x) = machine.pens[color];
}
int query(node *nd, rectangle r, rectangle qr)
{
if (r.isBad()) return -INF;
if (r.intersects(qr)) return -INF;
if (qr.contains(r)) return nd->high;
int q1 = query(nd->children[0], r.getLU(), qr);
int q2 = query(nd->children[1], r.getRU(), qr);
int q3 = query(nd->children[2], r.getLB(), qr);
int q4 = query(nd->children[3], r.getRB(), qr);
return max(max(q1, q2), max(q3, q4));
}
UINT32 bingor_state::screen_update_bingor(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
bitmap.fill(get_black_pen(machine()), cliprect);
count = (0x2000/2);
for(y=0;y<256;y++)
{
for(x=0;x<286;x+=4)
{
UINT32 color;
color = (m_blit_ram[count] & 0xf000)>>12;
if(cliprect.contains(x+3, y))
bitmap.pix32(y, x+3) = machine().pens[color];
color = (m_blit_ram[count] & 0x0f00)>>8;
if(cliprect.contains(x+2, y))
bitmap.pix32(y, x+2) = machine().pens[color];
color = (m_blit_ram[count] & 0x00f0)>>4;
if(cliprect.contains(x+1, y))
bitmap.pix32(y, x+1) = machine().pens[color];
color = (m_blit_ram[count] & 0x000f)>>0;
if(cliprect.contains(x+0, y))
bitmap.pix32(y, x+0) = machine().pens[color];
count++;
}
}
return 0;
}
static void theend_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y)
{
int i;
/* same as Galaxian, but all bullets are yellow */
for (i = 0; i < 4; i++)
{
x--;
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = BULLETS_COLOR_BASE;
}
}
uint32_t progolf_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int count,color,x,y,xi,yi;
{
int scroll = (m_scrollx_lo | ((m_scrollx_hi & 0x03) << 8));
count = 0;
for(x=0;x<128;x++)
{
for(y=0;y<32;y++)
{
int tile = m_videoram[count];
m_gfxdecode->gfx(0)->opaque(bitmap,cliprect,tile,1,0,0,(256-x*8)+scroll,y*8);
/* wrap-around */
m_gfxdecode->gfx(0)->opaque(bitmap,cliprect,tile,1,0,0,(256-x*8)+scroll-1024,y*8);
count++;
}
}
}
/* framebuffer is 8x8 chars arranged like a bitmap + a register that controls the pen handling. */
{
count = 0;
for(y=0;y<256;y+=8)
{
for(x=0;x<256;x+=8)
{
for (yi=0;yi<8;yi++)
{
for (xi=0;xi<8;xi++)
{
color = m_fg_fb[(xi+yi*8)+count*0x40];
if(color != 0 && cliprect.contains(x+yi, 256-y+xi))
bitmap.pix16(x+yi, 256-y+xi) = m_palette->pen((color & 0x7));
}
}
count++;
}
}
}
return 0;
}
uint32_t kontest_state::screen_update( screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect )
{
int x,y;
int xi,yi;
uint16_t tile;
uint8_t attr;
for(y=0;y<32;y++)
{
for(x=0;x<64;x++)
{
tile = m_ram[(x+y*64)|0x800];
attr = m_ram[(x+((y >> 1)*64))|0x000] & 7;
tile *= 0x10;
tile += 0x1000;
for(yi=0;yi<8;yi++)
{
for(xi=0;xi<8;xi++)
{
uint8_t color,pen[2];
uint8_t x_step;
int res_x,res_y;
x_step = xi >> 2;
pen[0] = m_ram[(x_step+yi*2)|(tile)];
pen[0] >>= 3-((xi & 3));
pen[0] &= 1;
pen[1] = m_ram[(x_step+yi*2)|(tile)];
pen[1] >>= 7-((xi & 3));
pen[1] &= 1;
color = pen[0];
color|= pen[1]<<1;
res_x = x*8+xi-256;
res_y = y*8+yi;
if (cliprect.contains(res_x, res_y))
bitmap.pix32(res_y, res_x) = m_palette->pen(color|attr*4);
}
}
}
}
return 0;
}
void update(node *nd, rectangle r, int ur, int uc, int v)
{
if (r.isBad()) return;
if (r.isCell() && r.contains(ur, uc)) nd->high = v;
else {
if (r.getLU().contains(ur, uc))
update(nd->children[0], r.getLU(), ur, uc, v);
else if (r.getRU().contains(ur, uc))
update(nd->children[1], r.getRU(), ur, uc, v);
else if (r.getLB().contains(ur, uc))
update(nd->children[2], r.getLB(), ur, uc, v);
else if (r.getRB().contains(ur, uc))
update(nd->children[3], r.getRB(), ur, uc, v);
pushUp(nd);
}
}
static void draw_sprite( UINT8 *gfx, int color, int y, int x, int expand, int or_mode, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int sy;
/* for each row */
for (sy = 0; sy < SPRITE_HEIGHT; sy++)
{
int sx;
/* for each pixel on the row */
for (sx = 0; sx < SPRITE_WIDTH; sx++)
{
int ey;
/* each pixel can be expanded */
for (ey = 0; ey <= expand; ey++)
{
int ex;
for (ex = 0; ex <= expand; ex++)
{
/* compute effective destination pixel */
int ty = y + sy * (expand + 1) + ey;
int tx = x + sx * (expand + 1) + ex;
/* get out if outside the drawing region */
if (!cliprect.contains(tx, ty))
continue;
/* get out if current image bit is transparent */
if (((gfx[sy] << sx) & 0x80) == 0x00)
continue;
if (or_mode)
bitmap.pix16(ty, tx) = 0x08 | bitmap.pix16(ty, tx) | color;
else
bitmap.pix16(ty, tx) = 0x08 | color;
}
}
}
}
}
int gl3000s_sed1520_screen_update(device_t &device, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *vram, int start_line, int adc, int start_x)
{
for (int y=0; y<2; y++)
{
int row_pos = 0;
for (int x=0; x<61; x++)
{
int addr = (y + (start_line >> 3)) * 80 + row_pos;
for (int yi=0; yi<8; yi++)
{
int px = start_x - (adc ? (80 - x) : x);
int py = 8 + y*8 + yi;
if (cliprect.contains(px, py))
bitmap.pix16(py, px) = (vram[addr % 0x140] >> yi) & 1;
}
row_pos++;
}
}
return 0;
}
UINT32 flipjack_state::screen_update_flipjack(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
bitmap.fill(get_black_pen(machine()), cliprect);
// draw playfield
if (m_layer & 2)
{
const UINT8 *blit_data = memregion("gfx2")->base();
count = 0;
for(y=0;y<192;y++)
{
for(x=0;x<256;x+=8)
{
UINT32 pen_r,pen_g,pen_b,color;
int xi;
pen_r = (blit_data[count] & 0xff)>>0;
pen_g = (blit_data[count+0x2000] & 0xff)>>0;
pen_b = (blit_data[count+0x4000] & 0xff)>>0;
for(xi=0;xi<8;xi++)
{
if(cliprect.contains(x+xi, y))
{
color = ((pen_r >> (7-xi)) & 1)<<0;
color|= ((pen_g >> (7-xi)) & 1)<<1;
color|= ((pen_b >> (7-xi)) & 1)<<2;
bitmap.pix32(y, x+xi) = machine().pens[color+0x80];
}
}
count++;
}
}
}
UINT32 flyball_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int pitcherx = m_pitcher_horz;
int pitchery = m_pitcher_vert - 31;
int ballx = m_ball_horz - 1;
int bally = m_ball_vert - 17;
m_tmap->mark_all_dirty();
/* draw playfield */
m_tmap->draw(screen, bitmap, cliprect, 0, 0);
/* draw pitcher */
m_gfxdecode->m_gfx[1]->transpen(bitmap,cliprect, m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1);
/* draw ball */
for (int y = bally; y < bally + 2; y++)
for (int x = ballx; x < ballx + 2; x++)
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = 1;
return 0;
}
UINT32 isa8_cga_tetriskr_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y;
int yi;
const UINT8 *bg_rom = memregion("gfx2")->base();
//popmessage("%04x",m_start_offs);
bitmap.fill(rgb_t::black, cliprect);
for(y=0;y<200/8;y++)
{
for(yi=0;yi<8;yi++)
{
for(x=0;x<320/8;x++)
{
UINT8 color;
int xi,pen_i;
for(xi=0;xi<8;xi++)
{
color = 0;
/* TODO: first byte seems bogus? */
for(pen_i = 0;pen_i<4;pen_i++)
color |= ((bg_rom[y*320/8+x+(pen_i*0x20000)+yi*0x400+m_bg_bank*0x2000+1] >> (7-xi)) & 1) << pen_i;
if(cliprect.contains(x*8+xi, y*8+yi))
bitmap.pix32(y*8+yi, x*8+xi) = m_palette->pen(color);
}
}
}
}
isa8_cga_device::screen_update(screen, bitmap, cliprect);
return 0;
}
UINT32 aristmk6_state::screen_update_aristmk6(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int x,y,count;
const UINT8 *blit_ram = memregion("maincpu")->base();
if(machine().input().code_pressed(KEYCODE_Z))
m_test_x++;
if(machine().input().code_pressed(KEYCODE_X))
m_test_x--;
if(machine().input().code_pressed(KEYCODE_A))
m_test_y++;
if(machine().input().code_pressed(KEYCODE_S))
m_test_y--;
if(machine().input().code_pressed(KEYCODE_Q))
m_start_offs+=0x2000;
if(machine().input().code_pressed(KEYCODE_W))
m_start_offs-=0x2000;
if(machine().input().code_pressed(KEYCODE_E))
m_start_offs++;
if(machine().input().code_pressed(KEYCODE_R))
m_start_offs--;
if(machine().input().code_pressed_once(KEYCODE_L))
m_type^=1;
popmessage("%d %d %04x %d",m_test_x,m_test_y,m_start_offs,m_type);
bitmap.fill(get_black_pen(machine()), cliprect);
count = (m_start_offs);
for(y=0;y<m_test_y;y++)
{
for(x=0;x<m_test_x;x++)
{
if(m_type)
{
UINT16 vram;
int r,g,b;
vram = blit_ram[count+0] | blit_ram[count+1]<<8;
r = (vram & 0x001f)>>0;
g = (vram & 0x07e0)>>5;
b = (vram & 0xf800)>>11;
r = (r << 3) | (r & 0x7);
g = (g << 2) | (g & 3);
b = (b << 3) | (b & 0x7);
if(cliprect.contains(x, y))
bitmap.pix32(y, x) = r | g<<8 | b<<16;
count+=2;
}
else
{
UINT8 color;
color = blit_ram[count];
if(cliprect.contains(x, y))
bitmap.pix32(y, x) = machine().pens[color];
count++;
}
}
}
/*
* Sprite Format
* ------------------
*
* Word | Bit(s) | Use
* -----+-fedcba9876543210-+----------------
* 0 | --------xxxxxxxx | display y start
* 0 | xxxxxxxx-------- | display y end
* 2 | -------xxxxxxxxx | x position
* 2 | ------x--------- | unknown (used in logicpr2, maybe just a bug?)
* 2 | xxxxxx---------- | unused?
* 4 | ---------xxxxxxx | width
* 4 | --------x------- | is this flip y like in System 16?
* 4 | -------x-------- | flip x
* 4 | xxxxxxx--------- | unused?
* 6 | xxxxxxxxxxxxxxxx | ROM address low bits
* 8 | ----------xxxxxx | color
* 8 | --------xx------ | priority
* 8 | ---xxxxx-------- | ROM address high bits
* 8 | xxx------------- | unused? (extra address bits for larger ROMs?)
* a | ---------------- | zoomx like in System 16?
* c | ---------------- | zoomy like in System 16?
* e | ---------------- |
*/
void deniam_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int offs;
UINT8 *gfx = memregion("gfx2")->base();
for (offs = m_spriteram.bytes() / 2 - 8; offs >= 0; offs -= 8)
{
int sx, starty, endy, x, y, start, color, width, flipx, primask;
UINT8 *rom = gfx;
sx = (m_spriteram[offs + 1] & 0x01ff) + 16 * 8 - 1;
if (sx >= 512) sx -= 512;
starty = m_spriteram[offs + 0] & 0xff;
endy = m_spriteram[offs + 0] >> 8;
width = m_spriteram[offs + 2] & 0x007f;
flipx = m_spriteram[offs + 2] & 0x0100;
if (flipx) sx++;
color = 0x40 + (m_spriteram[offs + 4] & 0x3f);
primask = 8;
switch (m_spriteram[offs + 4] & 0xc0)
{
case 0x00:
primask |= 4 | 2 | 1;
break; /* below everything */
case 0x40:
primask |= 4 | 2;
break; /* below fg and tx */
case 0x80:
primask |= 4;
break; /* below tx */
case 0xc0:
break; /* above everything */
}
start = m_spriteram[offs + 3] + ((m_spriteram[offs + 4] & 0x1f00) << 8);
rom += 2 * start;
for (y = starty + 1; y <= endy; y++)
{
int drawing = 0;
int i = 0;
rom += 2 * width; /* note that the first line is skipped */
x = 0;
while (i < 512) /* safety check */
{
if (flipx)
{
if ((rom[i] & 0x0f) == 0x0f)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0x0f)
{
if (cliprect.contains(sx + x, y))
{
if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f);
machine().priority_bitmap.pix8(y, sx + x) = 8;
}
}
x++;
}
if ((rom[i] & 0xf0) == 0xf0)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0xf0)
{
if (cliprect.contains(sx + x, y))
{
if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16+(rom[i] >> 4);
machine().priority_bitmap.pix8(y, sx + x) = 8;
}
}
x++;
}
i--;
}
else
{
if ((rom[i] & 0xf0) == 0xf0)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0xf0)
{
if (cliprect.contains(sx + x, y))
{
if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] >> 4);
machine().priority_bitmap.pix8(y, sx + x) = 8;
}
}
x++;
}
if ((rom[i] & 0x0f) == 0x0f)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0x0f)
{
if (cliprect.contains(sx + x, y))
{
if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f);
machine().priority_bitmap.pix8(y, sx + x) = 8;
}
}
x++;
}
i++;
}
}
}
}
int main(int argc, char** argv)
{
try
{
command_line_parser parser;
parser.add_option("h","Displays this information.");
parser.add_option("v","Display version.");
parser.set_group_name("Creating XML files");
parser.add_option("c","Create an XML file named <arg> listing a set of images.",1);
parser.add_option("r","Search directories recursively for images.");
parser.add_option("convert","Convert foreign image Annotations from <arg> format to the imglab format. "
"Supported formats: pascal-xml, pascal-v1, idl.",1);
parser.set_group_name("Viewing XML files");
parser.add_option("tile","Chip out all the objects and save them as one big image called <arg>.",1);
parser.add_option("size","When using --tile or --cluster, make each extracted object contain "
"about <arg> pixels (default 8000).",1);
parser.add_option("l","List all the labels in the given XML file.");
parser.add_option("stats","List detailed statistics on the object labels in the given XML file.");
parser.set_group_name("Editing/Transforming XML files");
parser.add_option("rename", "Rename all labels of <arg1> to <arg2>.",2);
parser.add_option("parts","The display will allow image parts to be labeled. The set of allowable parts "
"is defined by <arg> which should be a space separated list of parts.",1);
parser.add_option("rmdupes","Remove duplicate images from the dataset. This is done by comparing "
"the md5 hash of each image file and removing duplicate images. " );
parser.add_option("rmdiff","Set the ignored flag to true for boxes marked as difficult.");
parser.add_option("rmtrunc","Set the ignored flag to true for boxes that are partially outside the image.");
parser.add_option("shuffle","Randomly shuffle the order of the images listed in file <arg>.");
parser.add_option("seed", "When using --shuffle, set the random seed to the string <arg>.",1);
parser.add_option("split", "Split the contents of an XML file into two separate files. One containing the "
"images with objects labeled <arg> and another file with all the other images. Additionally, the file "
"containing the <arg> labeled objects will not contain any other labels other than <arg>. "
"That is, the images in the first file are stripped of all labels other than the <arg> labels.",1);
parser.add_option("add", "Add the image metadata from <arg1> into <arg2>. If any of the image "
"tags are in both files then the ones in <arg2> are deleted and replaced with the "
"image tags from <arg1>. The results are saved into merged.xml and neither <arg1> or "
"<arg2> files are modified.",2);
parser.add_option("flip", "Read an XML image dataset from the <arg> XML file and output a left-right flipped "
"version of the dataset and an accompanying flipped XML file named flipped_<arg>.",1);
parser.add_option("rotate", "Read an XML image dataset and output a copy that is rotated counter clockwise by <arg> degrees. "
"The output is saved to an XML file prefixed with rotated_<arg>.",1);
parser.add_option("cluster", "Cluster all the objects in an XML file into <arg> different clusters and save "
"the results as cluster_###.xml and cluster_###.jpg files.",1);
parser.add_option("resample", "Crop out images that are centered on each object in the dataset. Make the "
"crops so that the objects have <arg> pixels in them. The output is a new XML dataset.",1);
parser.add_option("extract-chips", "Crops out images with tight bounding boxes around each object. Also crops out "
"many background chips. All these image chips are serialized into one big data file. The chips will contain <arg> pixels each",1);
parser.parse(argc, argv);
const char* singles[] = {"h","c","r","l","convert","parts","rmdiff", "rmtrunc", "rmdupes", "seed", "shuffle", "split", "add",
"flip", "rotate", "tile", "size", "cluster", "resample", "extract-chips"};
parser.check_one_time_options(singles);
const char* c_sub_ops[] = {"r", "convert"};
parser.check_sub_options("c", c_sub_ops);
parser.check_sub_option("shuffle", "seed");
const char* size_parent_ops[] = {"tile", "cluster"};
parser.check_sub_options(size_parent_ops, "size");
parser.check_incompatible_options("c", "l");
parser.check_incompatible_options("c", "rmdiff");
parser.check_incompatible_options("c", "rmdupes");
parser.check_incompatible_options("c", "rmtrunc");
parser.check_incompatible_options("c", "add");
parser.check_incompatible_options("c", "flip");
parser.check_incompatible_options("c", "rotate");
parser.check_incompatible_options("c", "rename");
parser.check_incompatible_options("c", "parts");
parser.check_incompatible_options("c", "tile");
parser.check_incompatible_options("c", "cluster");
parser.check_incompatible_options("c", "resample");
parser.check_incompatible_options("c", "extract-chips");
parser.check_incompatible_options("l", "rename");
parser.check_incompatible_options("l", "add");
parser.check_incompatible_options("l", "parts");
parser.check_incompatible_options("l", "flip");
parser.check_incompatible_options("l", "rotate");
parser.check_incompatible_options("add", "flip");
parser.check_incompatible_options("add", "rotate");
parser.check_incompatible_options("add", "tile");
parser.check_incompatible_options("flip", "tile");
parser.check_incompatible_options("rotate", "tile");
parser.check_incompatible_options("cluster", "tile");
parser.check_incompatible_options("resample", "tile");
parser.check_incompatible_options("extract-chips", "tile");
parser.check_incompatible_options("flip", "cluster");
parser.check_incompatible_options("rotate", "cluster");
parser.check_incompatible_options("add", "cluster");
parser.check_incompatible_options("flip", "resample");
parser.check_incompatible_options("rotate", "resample");
parser.check_incompatible_options("add", "resample");
parser.check_incompatible_options("flip", "extract-chips");
parser.check_incompatible_options("rotate", "extract-chips");
parser.check_incompatible_options("add", "extract-chips");
parser.check_incompatible_options("shuffle", "tile");
parser.check_incompatible_options("convert", "l");
parser.check_incompatible_options("convert", "rename");
parser.check_incompatible_options("convert", "parts");
parser.check_incompatible_options("convert", "cluster");
parser.check_incompatible_options("convert", "resample");
parser.check_incompatible_options("convert", "extract-chips");
parser.check_incompatible_options("rmdiff", "rename");
parser.check_incompatible_options("rmdupes", "rename");
parser.check_incompatible_options("rmtrunc", "rename");
const char* convert_args[] = {"pascal-xml","pascal-v1","idl"};
parser.check_option_arg_range("convert", convert_args);
parser.check_option_arg_range("cluster", 2, 999);
parser.check_option_arg_range("rotate", -360, 360);
parser.check_option_arg_range("size", 10*10, 1000*1000);
parser.check_option_arg_range("resample", 4, 1000*1000);
parser.check_option_arg_range("extract-chips", 4, 1000*1000);
if (parser.option("h"))
{
cout << "Usage: imglab [options] <image files/directories or XML file>\n";
parser.print_options(cout);
cout << endl << endl;
return EXIT_SUCCESS;
}
if (parser.option("add"))
{
merge_metadata_files(parser);
return EXIT_SUCCESS;
}
if (parser.option("flip"))
{
flip_dataset(parser);
return EXIT_SUCCESS;
}
if (parser.option("rotate"))
{
rotate_dataset(parser);
return EXIT_SUCCESS;
}
if (parser.option("v"))
{
cout << "imglab v" << VERSION
<< "\nCompiled: " << __TIME__ << " " << __DATE__
<< "\nWritten by Davis King\n";
cout << "Check for updates at http://dlib.net\n\n";
return EXIT_SUCCESS;
}
if (parser.option("tile"))
{
return tile_dataset(parser);
}
if (parser.option("cluster"))
{
return cluster_dataset(parser);
}
if (parser.option("resample"))
{
return resample_dataset(parser);
}
if (parser.option("extract-chips"))
{
return extract_chips(parser);
}
if (parser.option("c"))
{
if (parser.option("convert"))
{
if (parser.option("convert").argument() == "pascal-xml")
convert_pascal_xml(parser);
else if (parser.option("convert").argument() == "pascal-v1")
convert_pascal_v1(parser);
else if (parser.option("convert").argument() == "idl")
convert_idl(parser);
}
else
{
create_new_dataset(parser);
}
return EXIT_SUCCESS;
}
if (parser.option("rmdiff"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --rmdiff option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
for (unsigned long i = 0; i < data.images.size(); ++i)
{
for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
{
if (data.images[i].boxes[j].difficult)
data.images[i].boxes[j].ignore = true;
}
}
save_image_dataset_metadata(data, parser[0]);
return EXIT_SUCCESS;
}
if (parser.option("rmdupes"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --rmdupes option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data, data_out;
std::set<std::string> hashes;
load_image_dataset_metadata(data, parser[0]);
data_out = data;
data_out.images.clear();
for (unsigned long i = 0; i < data.images.size(); ++i)
{
ifstream fin(data.images[i].filename.c_str(), ios::binary);
string hash = md5(fin);
if (hashes.count(hash) == 0)
{
hashes.insert(hash);
data_out.images.push_back(data.images[i]);
}
}
save_image_dataset_metadata(data_out, parser[0]);
return EXIT_SUCCESS;
}
if (parser.option("rmtrunc"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --rmtrunc option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
{
locally_change_current_dir chdir(get_parent_directory(file(parser[0])));
for (unsigned long i = 0; i < data.images.size(); ++i)
{
array2d<unsigned char> img;
load_image(img, data.images[i].filename);
const rectangle area = get_rect(img);
for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
{
if (!area.contains(data.images[i].boxes[j].rect))
data.images[i].boxes[j].ignore = true;
}
}
}
save_image_dataset_metadata(data, parser[0]);
return EXIT_SUCCESS;
}
if (parser.option("l"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The -l option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
print_all_labels(data);
return EXIT_SUCCESS;
}
if (parser.option("split"))
{
return split_dataset(parser);
}
if (parser.option("shuffle"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The -shuffle option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
const string default_seed = cast_to_string(time(0));
const string seed = get_option(parser, "seed", default_seed);
dlib::rand rnd(seed);
randomize_samples(data.images, rnd);
save_image_dataset_metadata(data, parser[0]);
return EXIT_SUCCESS;
}
if (parser.option("stats"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --stats option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
print_all_label_stats(data);
return EXIT_SUCCESS;
}
if (parser.option("rename"))
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --rename option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
dlib::image_dataset_metadata::dataset data;
load_image_dataset_metadata(data, parser[0]);
for (unsigned long i = 0; i < parser.option("rename").count(); ++i)
{
rename_labels(data, parser.option("rename").argument(0,i), parser.option("rename").argument(1,i));
}
save_image_dataset_metadata(data, parser[0]);
return EXIT_SUCCESS;
}
if (parser.number_of_arguments() == 1)
{
metadata_editor editor(parser[0]);
if (parser.option("parts"))
{
std::vector<string> parts = split(parser.option("parts").argument());
for (unsigned long i = 0; i < parts.size(); ++i)
{
editor.add_labelable_part_name(parts[i]);
}
}
editor.wait_until_closed();
}
}
catch (exception& e)
{
cerr << e.what() << endl;
return EXIT_FAILURE;
}
}
int resample_dataset(const command_line_parser& parser)
{
if (parser.number_of_arguments() != 1)
{
cerr << "The --resample option requires you to give one XML file on the command line." << endl;
return EXIT_FAILURE;
}
const size_t obj_size = get_option(parser,"resample",100*100);
const double margin_scale = 2.5; // cropped image will be this times wider than the object.
const size_t image_size = obj_size*margin_scale*margin_scale;
dlib::image_dataset_metadata::dataset data, resampled_data;
resampled_data.comment = data.comment;
resampled_data.name = data.name + " RESAMPLED";
load_image_dataset_metadata(data, parser[0]);
locally_change_current_dir chdir(get_parent_directory(file(parser[0])));
console_progress_indicator pbar(data.images.size());
for (unsigned long i = 0; i < data.images.size(); ++i)
{
// don't even bother loading images that don't have objects.
if (data.images[i].boxes.size() == 0)
continue;
pbar.print_status(i);
array2d<rgb_pixel> img, chip;
load_image(img, data.images[i].filename);
// figure out what chips we want to take from this image
for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
{
const rectangle rect = data.images[i].boxes[j].rect;
if (data.images[i].boxes[j].ignore || !get_rect(img).contains(rect))
continue;
const rectangle crop_rect = centered_rect(rect, rect.width()*margin_scale, rect.height()*margin_scale);
// skip crops that have a lot of border pixels
if (get_rect(img).intersect(crop_rect).area() < crop_rect.area()*0.8)
continue;
const rectangle_transform tform = get_mapping_to_chip(chip_details(crop_rect, image_size));
extract_image_chip(img, chip_details(crop_rect, image_size), chip);
image_dataset_metadata::image dimg;
// Now transform the boxes to the crop and also mark them as ignored if they
// have already been cropped out or are outside the crop.
for (size_t k = 0; k < data.images[i].boxes.size(); ++k)
{
image_dataset_metadata::box box = data.images[i].boxes[k];
// ignore boxes outside the cropped image
if (crop_rect.intersect(box.rect).area() == 0)
continue;
// mark boxes we include in the crop as ignored. Also mark boxes that
// aren't totally within the crop as ignored.
if (crop_rect.contains(grow_rect(box.rect,10)))
data.images[i].boxes[k].ignore = true;
else
box.ignore = true;
box.rect = tform(box.rect);
for (auto&& p : box.parts)
p.second = tform.get_tform()(p.second);
dimg.boxes.push_back(box);
}
dimg.filename = data.images[i].filename + "RESAMPLED"+cast_to_string(j)+".jpg";
save_jpeg(chip,dimg.filename, 98);
resampled_data.images.push_back(dimg);
}
}
save_image_dataset_metadata(resampled_data, parser[0] + ".RESAMPLED.xml");
return EXIT_SUCCESS;
}
UINT32 archimedes_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
int xstart,ystart,xend,yend;
int res_x,res_y;
int xsize,ysize;
int calc_dxs = 0,calc_dxe = 0;
const UINT8 x_step[4] = { 5, 7, 11, 19 };
/* border color */
bitmap.fill(m_palette->pen(0x10), cliprect);
/* define X display area through BPP mode register */
calc_dxs = (m_vidc_regs[VIDC_HDSR]*2)+x_step[m_vidc_bpp_mode & 3];
calc_dxe = (m_vidc_regs[VIDC_HDER]*2)+x_step[m_vidc_bpp_mode & 3];
/* now calculate display clip rectangle start/end areas */
xstart = (calc_dxs)-m_vidc_regs[VIDC_HBSR];
ystart = (m_vidc_regs[VIDC_VDSR])-m_vidc_regs[VIDC_VBSR];
xend = (calc_dxe)+xstart;
yend = m_vidc_regs[VIDC_VDER]+ystart;
/* disable the screen if display params are invalid */
if(xstart > xend || ystart > yend)
return 0;
xsize = calc_dxe-calc_dxs;
ysize = m_vidc_regs[VIDC_VDER]-m_vidc_regs[VIDC_VDSR];
{
int count;
int x,y,xi;
UINT8 pen;
static UINT8 *vram = memregion("vram")->base();
count = (0);
switch(m_vidc_bpp_mode)
{
case 0: //1 bpp
{
for(y=0;y<ysize;y++)
{
for(x=0;x<xsize;x+=8)
{
pen = vram[count];
for(xi=0;xi<8;xi++)
{
res_x = x+xi+xstart;
res_y = (y+ystart)*(m_vidc_interlace+1);
if(m_vidc_interlace)
{
if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend)
bitmap.pix32(res_y, res_x) = m_palette->pen((pen>>(xi))&0x1);
if (cliprect.contains(res_x, res_y+1) && (res_x) <= xend && (res_y+1) <= yend)
bitmap.pix32(res_y+1, res_x) = m_palette->pen((pen>>(xi))&0x1);
}
else
{
if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend)
bitmap.pix32(res_y, res_x) = m_palette->pen((pen>>(xi))&0x1);
}
}
count++;
}
}
}
break;
case 3: //8 bpp
{
for(y=0;y<ysize;y++)
{
for(x=0;x<xsize;x++)
{
pen = vram[count];
res_x = x+xstart;
res_y = (y+ystart)*(m_vidc_interlace+1);
if(m_vidc_interlace)
{
if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend)
bitmap.pix32(res_y, res_x) = m_palette->pen((pen&0xff)+0x100);
if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y+1) <= yend)
bitmap.pix32(res_y+1, res_x) = m_palette->pen((pen&0xff)+0x100);
}
else
{
if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend)
bitmap.pix32(res_y, res_x) = m_palette->pen((pen&0xff)+0x100);
}
count++;
}
}
}
break;
}
}