int starcrus_vh_start(void)
{
if ((ship1_vid = bitmap_alloc(16,16)) == 0)
{
return 1;
}
if ((ship2_vid = bitmap_alloc(16,16)) == 0)
{
bitmap_free(ship1_vid);
return 1;
}
if ((proj1_vid = bitmap_alloc(16,16)) == 0)
{
bitmap_free(ship1_vid);
bitmap_free(ship2_vid);
return 1;
}
if ((proj2_vid = bitmap_alloc(16,16)) == 0)
{
bitmap_free(ship1_vid);
bitmap_free(ship2_vid);
bitmap_free(proj1_vid);
return 1;
}
return 0;
}
int toaplan1_vh_start(void)
{
tmpbitmap1 = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height);
tmpbitmap2 = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height);
tmpbitmap3 = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height);
if ((toaplan1_spriteram16 = calloc(TOAPLAN1_SPRITERAM16_SIZE, 2)) == 0)
{
return 1;
}
if ((toaplan1_buffered_spriteram16 = calloc(TOAPLAN1_SPRITERAM16_SIZE, 2)) == 0)
{
free(toaplan1_spriteram16);
return 1;
}
if ((toaplan1_spritesizeram16 = calloc(TOAPLAN1_SPRITESIZERAM16_SIZE, 2)) == 0)
{
free(toaplan1_buffered_spriteram16);
free(toaplan1_spriteram16);
return 1;
}
if ((toaplan1_buffered_spritesizeram16 = calloc(TOAPLAN1_SPRITESIZERAM16_SIZE, 2)) == 0)
{
free(toaplan1_spritesizeram16);
free(toaplan1_buffered_spriteram16);
free(toaplan1_spriteram16);
return 1;
}
/* Also include all allocated stuff in Rally Bike startup */
return rallybik_vh_start();
}
BITMAP *bitmap_convert_msb8(Uchar *data, int w, int h, int stride)
{
BITMAP *bm;
Uchar *unit;
Uchar *curr;
int i;
int bytes;
bm = bitmap_alloc(w, h);
bytes = ROUND(w, 8);
unit = (Uchar *)bm->data;
curr = data;
for(i = 0; i < h; i++) {
#ifdef WORD_LITTLE_ENDIAN
int j;
for(j = 0; j < bytes; curr++, j++)
unit[j] = bit_swap[*curr];
curr += stride - bytes;
#else
memcpy(unit, curr, bytes);
curr += stride;
#endif
memset(unit + bytes, 0, bm->stride - bytes);
unit += bm->stride;
}
if(SHOW_OP_DATA)
bitmap_print(stderr, bm);
return bm;
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
int generic_vh_start(void)
{
dirtybuffer = 0;
tmpbitmap = 0;
if (videoram_size == 0)
{
logerror("Error: generic_vh_start() called but videoram_size not initialized\n");
return 1;
}
if ((dirtybuffer = malloc(videoram_size)) == 0)
return 1;
memset(dirtybuffer,1,videoram_size);
if ((tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
{
free(dirtybuffer);
return 1;
}
state_save_register_func_postload(generic_vh_postload);
return 0;
}
/* =============================================================================
* gene_alloc
* -- Does all memory allocation necessary for gene creation
* -- Returns NULL on failure
* =============================================================================
*/
gene_t*
gene_alloc (long length)
{
gene_t* genePtr;
assert(length > 1);
genePtr = (gene_t*)malloc(sizeof(gene_t));
if (genePtr == NULL) {
return NULL;
}
genePtr->contents = (char*)malloc((length + 1) * sizeof(char));
if (genePtr->contents == NULL) {
return NULL;
}
genePtr->contents[length] = '\0';
genePtr->length = length;
genePtr->startBitmapPtr = bitmap_alloc(length);
if (genePtr->startBitmapPtr == NULL) {
return NULL;
}
return genePtr;
}
// Write data from (simulated) physical memory 'frame' to 'swap_offset'
// in swap file. Allocates space in swap file for virtual page if needed.
// Input: frame - the physical frame number (not byte offset in physmem)
// swap_offset - the byte position in the swap file.
// Return: the swap_offset where the data was written on success,
// or INVALID_SWAP on failure
//
int swap_pageout(unsigned frame, int swap_offset) {
char *frame_ptr;
off_t pos;
unsigned idx;
ssize_t bytes_written;
// Check if swap has already been allocated for this page
if (swap_offset == INVALID_SWAP) {
if (bitmap_alloc(swapmap, &idx) != 0) {
fprintf(stderr,"swap_pageout: Could not allocate space in swapfile. Try running again with a larger swapsize.\n");
return INVALID_SWAP;
}
swap_offset = idx*SIMPAGESIZE;
}
assert(swap_offset != INVALID_SWAP);
// Get pointer to page data in (simulated) physical memory
frame_ptr = &physmem[frame * SIMPAGESIZE];
// Seek to position in swap file where this page will be stored
pos = lseek(swapfd, swap_offset, SEEK_SET);
if (pos != swap_offset) {
assert(pos == (off_t)-1);
perror("swap_pageout: failed to set write position");
return INVALID_SWAP;
}
// Read page data from swapfile into memory
bytes_written = write(swapfd, frame_ptr, SIMPAGESIZE);
if (bytes_written != SIMPAGESIZE) {
fprintf(stderr,"swap_pageout: did not write whole page\n");
return INVALID_SWAP;
}
return swap_offset;
}
static u_int32_t ToDisk(vaddr_t vaddr)
{
assert(lock_do_i_hold(&vmlock));
assert((vaddr & 0xfffff000) == vaddr);
struct uio ku;
int result;
u_int32_t bitmaploc, diskloc, diskindex, flatloc;
result = bitmap_alloc(diskmap, &bitmaploc);
if (result) {
panic("no disk space.");
}
flatloc = bitmaploc * PAGE_SIZE;
diskindex = flatloc / DISKSPACE;
diskloc = flatloc - diskindex * DISKSPACE;
mk_kuio(&ku, (void*)vaddr , PAGE_SIZE, diskloc, UIO_WRITE);
result = VOP_WRITE(disk[diskindex], &ku);
if (result) {
panic(strerror(result));
}
return flatloc;
}
BITMAP *bitmap_copy(BITMAP *bm)
{
BITMAP *nb = bitmap_alloc(bm->width, bm->height);
DEBUG((DBG_BITMAP_OPS, "copy %dx%d\n", bm->width, bm->height));
memcpy(nb->data, bm->data, bm->height * bm->stride);
return nb;
}
int generic_bitmapped_vh_start(void)
{
if ((tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
{
return 1;
}
return 0;
}
int kangaroo_vh_start(void)
{
if ((tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
return 1;
if ((tmpbitmap2 = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
{
bitmap_free(tmpbitmap);
return 1;
}
if ((videoram = (unsigned char*)malloc(Machine->drv->screen_width*Machine->drv->screen_height)) == 0)
{
bitmap_free(tmpbitmap);
bitmap_free(tmpbitmap2);
}
return 0;
}
int bitmap_ts_alloc(struct bitmap_ts* b, unsigned* index) {
assert(b != NULL);
assert(index != NULL);
lock_acquire(b->lk);
int ret = bitmap_alloc(b->bm, index);
lock_release(b->lk);
// may return ENOMEM
return ret;
}
static void
tester (long geneLength, long segmentLength, long minNumSegment, bool_t doPrint)
{
gene_t* genePtr;
segments_t* segmentsPtr;
random_t* randomPtr;
bitmap_t* startBitmapPtr;
long i;
long j;
genePtr = gene_alloc(geneLength);
segmentsPtr = segments_alloc(segmentLength, minNumSegment);
randomPtr = random_alloc();
startBitmapPtr = bitmap_alloc(geneLength);
random_seed(randomPtr, 0);
gene_create(genePtr, randomPtr);
random_seed(randomPtr, 0);
segments_create(segmentsPtr, genePtr, randomPtr);
assert(segmentsPtr->minNum == minNumSegment);
assert(vector_getSize(segmentsPtr->contentsPtr) >= minNumSegment);
if (doPrint) {
printf("Gene = %s\n", genePtr->contents);
}
/* Check that each segment occurs in gene */
for (i = 0; i < vector_getSize(segmentsPtr->contentsPtr); i++) {
char *charPtr = strstr(genePtr->contents,
(char*)vector_at(segmentsPtr->contentsPtr, i));
assert(charPtr != NULL);
j = charPtr - genePtr->contents;
bitmap_set(startBitmapPtr, j);
if (doPrint) {
printf("Segment %li (@%li) = %s\n",
i, j, (char*)vector_at(segmentsPtr->contentsPtr, i));
}
}
/* Check that there is complete overlap */
assert(bitmap_isSet(startBitmapPtr, 0));
for (i = 0, j = 0; i < geneLength; i++ ) {
if (bitmap_isSet(startBitmapPtr, i)) {
assert((i-j-1) < segmentLength);
j = i;
}
}
gene_free(genePtr);
segments_free(segmentsPtr);
random_free(randomPtr);
bitmap_free(startBitmapPtr);
}
/*
* sfs_block_alloc - check and get a free disk block
*/
static int
sfs_block_alloc(struct sfs_fs *sfs, uint32_t *ino_store) {
int ret;
if ((ret = bitmap_alloc(sfs->freemap, ino_store)) != 0) {
return ret;
}
assert(sfs->super.unused_blocks > 0);
sfs->super.unused_blocks --, sfs->super_dirty = 1;
assert(sfs_block_inuse(sfs, *ino_store));
return sfs_clear_block(sfs, *ino_store, 1);
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
int ccastles_vh_start(void)
{
if ((tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
return 1;
if ((maskbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
{
bitmap_free(tmpbitmap);
return 1;
}
if ((sprite_bm = bitmap_alloc(16,16)) == 0)
{
bitmap_free(maskbitmap);
bitmap_free(tmpbitmap);
return 1;
}
return 0;
}
/* return free inode number or negative value */
int testfs_get_inode_freemap(struct super_block *sb) {
u_int32_t index;
int ret;
assert(sb->inode_freemap);
ret = bitmap_alloc(sb->inode_freemap, &index);
if (ret < 0)
return ret;
testfs_write_inode_freemap(sb, index);
return index;
}
static void create_bitmap(running_machine *machine, int player)
{
int x, y;
char filename[20];
rgb_t color = crosshair_colors[player];
/* if we have a bitmap for this player, kill it */
if (global.bitmap[player] != NULL)
bitmap_free(global.bitmap[player]);
if (global.name[player][0] != 0)
{
/* look for user specified file */
sprintf(filename, "%s.png", global.name[player]);
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, NULL, filename, NULL, NULL);
}
else
{
/* look for default cross?.png in crsshair\game dir */
sprintf(filename, "cross%d.png", player + 1);
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, machine->gamedrv->name, filename, NULL, NULL);
/* look for default cross?.png in crsshair dir */
if (global.bitmap[player] == NULL)
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, NULL, filename, NULL, NULL);
}
/* if that didn't work, use the built-in one */
if (global.bitmap[player] == NULL)
{
/* allocate a blank bitmap to start with */
global.bitmap[player] = bitmap_alloc(CROSSHAIR_RAW_SIZE, CROSSHAIR_RAW_SIZE, BITMAP_FORMAT_ARGB32);
bitmap_fill(global.bitmap[player], NULL, MAKE_ARGB(0x00,0xff,0xff,0xff));
/* extract the raw source data to it */
for (y = 0; y < CROSSHAIR_RAW_SIZE / 2; y++)
{
/* assume it is mirrored vertically */
UINT32 *dest0 = BITMAP_ADDR32(global.bitmap[player], y, 0);
UINT32 *dest1 = BITMAP_ADDR32(global.bitmap[player], CROSSHAIR_RAW_SIZE - 1 - y, 0);
/* extract to two rows simultaneously */
for (x = 0; x < CROSSHAIR_RAW_SIZE; x++)
if ((crosshair_raw_top[y * CROSSHAIR_RAW_ROWBYTES + x / 8] << (x % 8)) & 0x80)
dest0[x] = dest1[x] = MAKE_ARGB(0xff,0x00,0x00,0x00) | color;
}
}
/* create a texture to reference the bitmap */
global.texture[player] = render_texture_alloc(render_texture_hq_scale, NULL);
render_texture_set_bitmap(global.texture[player], global.bitmap[player], NULL, TEXFORMAT_ARGB32, NULL);
}
int victory_vh_start(void)
{
/* allocate bitmapram */
rram = (UINT8*)malloc(0x4000);
gram = (UINT8*)malloc(0x4000);
bram = (UINT8*)malloc(0x4000);
/* allocate bitmaps */
bgbitmap = bitmap_alloc(32 * 8, 32 * 8);
fgbitmap = bitmap_alloc(32 * 8, 32 * 8);
/* allocate dirty maps */
bgdirty = (UINT8*)malloc(32 * 32);
chardirty = (UINT8*)malloc(256);
scandirty = (UINT8*)malloc(512);
/* fail if something went wrong */
if (!rram || !gram || !bram || !bgbitmap || !fgbitmap || !bgdirty || !chardirty || !scandirty)
{
victory_vh_stop();
return 1;
}
/* mark everything dirty */
memset(bgdirty, 1, 32 * 32);
memset(chardirty, 1, 256);
memset(scandirty, 1, 512);
/* reset globals */
vblank_irq = 0;
fgcoll = fgcollx = fgcolly = 0;
bgcoll = bgcollx = bgcolly = 0;
scrollx = scrolly = 0;
update_complete = 0;
video_control = 0;
memset(µ, 0, sizeof(micro));
return 0;
}
int bjtwin_vh_start(void)
{
dirtybuffer = (unsigned char*)malloc(bjtwin_txvideoram_size/2);
tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height);
if (!dirtybuffer || !tmpbitmap)
{
if (tmpbitmap) bitmap_free(tmpbitmap);
if (dirtybuffer) free(dirtybuffer);
return 1;
}
bjtwin_spriteram = bjtwin_workram + 0x8000;
return 0;
}
int splash_vh_start(void)
{
screen[0] = tilemap_create(get_tile_info_splash_screen0,tilemap_scan_rows,TILEMAP_TRANSPARENT, 8, 8,64,32);
screen[1] = tilemap_create(get_tile_info_splash_screen1,tilemap_scan_rows,TILEMAP_TRANSPARENT,16,16,32,32);
screen2 = bitmap_alloc (512, 256);
if (!screen[0] || !screen[1] || !screen2)
return 1;
tilemap_set_transparent_pen(screen[0],0);
tilemap_set_transparent_pen(screen[1],0);
tilemap_set_scrollx(screen[0], 0, 4);
return 0;
}
static int writelog_create(struct tdlog_state *s)
{
uint64_t bmsize;
bmsize = bitmap_size(s->size);
BDPRINTF("allocating %"PRIu64" bytes for dirty bitmap", bmsize);
s->writelog = bitmap_alloc(s->size);
if (!s->writelog) {
BWPRINTF("could not allocate dirty bitmap of size %"PRIu64, bmsize);
return -1;
}
return 0;
}
off_t
swap_alloc() {
unsigned ix;
int res;
LOCK_SWAP();
res = bitmap_alloc( bm_sw, &ix );
if( res ) {
UNLOCK_SWAP();
return INVALID_SWAPADDR;
}
//update stats
--ss_sw.ss_free;
UNLOCK_SWAP();
return ix * PAGE_SIZE;
}
/*
* Allocate a block.
*/
static
int
sfs_balloc(struct sfs_fs *sfs, uint32_t *diskblock)
{
int result;
result = bitmap_alloc(sfs->sfs_freemap, diskblock);
if (result) {
return result;
}
sfs->sfs_freemapdirty = true;
if (*diskblock >= sfs->sfs_super.sp_nblocks) {
panic("sfs: balloc: invalid block %u\n", *diskblock);
}
/* Clear block before returning it */
return sfs_clearblock(sfs, *diskblock);
}
/*
* Get an empty chunk from the swap area to store a swapped out page
* We use a bitmap to describe the swap area. So, just look get an unmarked
* bit index from the swap_memmap and return the address of the chunk indexed
* by the index found. If there is no empty chunk then we are in great trouble.
* We can't handle this request, so kill the thread and exit.
*/
u_int32_t get_empty_chunk()
{
int spl=splhigh();
unsigned chunk_index;
int no_free_chunk = bitmap_alloc(swap_memmap, &chunk_index);
if(!no_free_chunk)
{
splx(spl);
return (chunk_index*PAGE_SIZE);
}
else
{
splx(spl);
kprintf("VM: Swap Space full, killing curthread");
sys__exit(0);
}
}
int shangha3_vh_start(void)
{
if ((rawbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
return 1;
if (shangha3_do_shadows)
{
int i;
/* Prepare the shadow table */
/* We draw in a raw bitmap so we don't have to remap pens through Machine->pens */
for (i = 0;i < 14;i++)
gfx_drawmode_table[i] = DRAWMODE_SOURCE;
gfx_drawmode_table[14] = DRAWMODE_SHADOW;
for (i = 0;i < 128;i++)
palette_shadow_table[Machine->pens[i]] = Machine->pens[i+128];
}
return 0;
}
/*
* Allocate a block.
*/
int
sfs_balloc(struct sfs_fs *sfs, daddr_t *diskblock)
{
int result;
result = bitmap_alloc(sfs->sfs_freemap, diskblock);
if (result) {
return result;
}
sfs->sfs_freemapdirty = true;
if (*diskblock >= sfs->sfs_sb.sb_nblocks) {
panic("sfs: balloc: invalid block %u\n", *diskblock);
}
/* Clear block before returning it */
result = sfs_clearblock(sfs, *diskblock);
if (result) {
bitmap_unmark(sfs->sfs_freemap, *diskblock);
}
return result;
}
int starfire_vh_start(void)
{
/* make a temporary bitmap */
tmpbitmap = bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height);
if (!tmpbitmap)
return 1;
/* make a dirty array */
scanline_dirty = (unsigned char*)malloc(256);
if (!scanline_dirty)
{
bitmap_free(tmpbitmap);
return 1;
}
/* reset videoram */
memset(starfire_videoram, 0, 0x2000);
memset(starfire_colorram, 0, 0x2000);
memset(scanline_dirty, 1, 256);
return 0;
}
/* =============================================================================
* net_generateRandomEdges
* =============================================================================
*/
void
net_generateRandomEdges (net_t* netPtr,
long maxNumParent,
long percentParent,
random_t* randomPtr)
{
vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
long numNode = vector_getSize(nodeVectorPtr);
bitmap_t* visitedBitmapPtr = bitmap_alloc(numNode);
assert(visitedBitmapPtr);
queue_t* workQueuePtr = queue_alloc(-1);
long n;
for (n = 0; n < numNode; n++) {
long p;
for (p = 0; p < maxNumParent; p++) {
long value = random_generate(randomPtr) % 100;
if (value < percentParent) {
long parent = random_generate(randomPtr) % numNode;
if ((parent != n) &&
!net_hasEdge(netPtr, parent, n) &&
!net_isPath(netPtr, n, parent, visitedBitmapPtr, workQueuePtr))
{
#ifdef TEST_NET
printf("node=%li parent=%li\n", n, parent);
#endif
insertEdge(netPtr, parent, n);
}
}
}
}
assert(!net_isCycle(netPtr));
bitmap_free(visitedBitmapPtr);
queue_free(workQueuePtr);
}
/***************************************************************************
Start the video hardware emulation.
***************************************************************************/
int spiders_vh_start(void)
{
int loop;
if ((tmpbitmap = bitmap_alloc(Machine->drv->screen_width,Machine->drv->screen_height)) == 0) return 1;
for(loop=0;loop<256;loop++)
{
bitflip[loop]=(loop&0x01)?0x80:0x00;
bitflip[loop]|=(loop&0x02)?0x40:0x00;
bitflip[loop]|=(loop&0x04)?0x20:0x00;
bitflip[loop]|=(loop&0x08)?0x10:0x00;
bitflip[loop]|=(loop&0x10)?0x08:0x00;
bitflip[loop]|=(loop&0x20)?0x04:0x00;
bitflip[loop]|=(loop&0x40)?0x02:0x00;
bitflip[loop]|=(loop&0x80)?0x01:0x00;
}
if ((screenbuffer = (int*)malloc(SCREENBUFFER_SIZE*sizeof(int))) == 0) return 1;
memset(screenbuffer,1,SCREENBUFFER_SIZE*sizeof(int));
return 0;
}
int main()
{
int i = 0, k = 1;
pthread_t pid;
bitmap_t bmp = bitmap_alloc(SIZE);
check(bmp, k++);
check(bmp, k++);
check(bmp, k++);
check(bmp, k++);
check(bmp, k++);
printf("index : %lu = %d\n", SIZE + 1, bitmap_get(bmp, SIZE + 1));
printf("index : %lu = %d\n", SIZE + 66, bitmap_get(bmp, SIZE + 66));
for (i = 0; i < SIZE; i++) {
unsigned long index = bitmap_zero_index(bmp);
printf("bitmap_zero_index : %d\n", index);
bitmap_set(bmp, index);
}
return 0;
}
/*
* swap_alloc: allocates a page in the swapfile.
* The page should have already been reserved with swap_reserve.
*
* Synchronization: uses swaplock.
*/
off_t
swap_alloc(void)
{
uint32_t rv, index;
lock_acquire(swaplock);
KASSERT(swap_free_pages <= swap_total_pages);
KASSERT(swap_reserved_pages <= swap_free_pages);
KASSERT(swap_reserved_pages>0);
KASSERT(swap_free_pages>0);
rv = bitmap_alloc(swapmap, &index);
/* If this blows up, our counters are wrong */
KASSERT(rv == 0);
swap_reserved_pages--;
swap_free_pages--;
lock_release(swaplock);
return index*PAGE_SIZE;
}
