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; }