struct drccore *drc_init(UINT8 cpunum, struct drcconfig *config) { int address_bits = config->address_bits; int effective_address_bits = address_bits - config->lsbs_to_ignore; struct drccore *drc; /* allocate memory */ drc = osd_malloc(sizeof(*drc)); if (!drc) return NULL; memset(drc, 0, sizeof(*drc)); /* copy in relevant data from the config */ drc->pcptr = config->pcptr; drc->icountptr = config->icountptr; drc->esiptr = config->esiptr; drc->cb_reset = config->cb_reset; drc->cb_recompile = config->cb_recompile; drc->cb_entrygen = config->cb_entrygen; drc->uses_fp = config->uses_fp; drc->uses_sse = config->uses_sse; drc->pc_in_memory = config->pc_in_memory; drc->icount_in_memory = config->icount_in_memory; drc->fpcw_curr = fp_control[0]; drc->mxcsr_curr = sse_control[0]; /* allocate cache */ drc->cache_base = osd_alloc_executable(config->cache_size); if (!drc->cache_base) return NULL; drc->cache_end = drc->cache_base + config->cache_size; drc->cache_danger = drc->cache_end - 65536; /* compute shifts and masks */ drc->l1bits = effective_address_bits/2; drc->l2bits = effective_address_bits - drc->l1bits; drc->l1shift = config->lsbs_to_ignore + drc->l2bits; drc->l2mask = ((1 << drc->l2bits) - 1) << config->lsbs_to_ignore; drc->l2scale = 4 >> config->lsbs_to_ignore; /* allocate lookup tables */ drc->lookup_l1 = osd_malloc(sizeof(*drc->lookup_l1) * (1 << drc->l1bits)); drc->lookup_l2_recompile = osd_malloc(sizeof(*drc->lookup_l2_recompile) * (1 << drc->l2bits)); if (!drc->lookup_l1 || !drc->lookup_l2_recompile) return NULL; memset(drc->lookup_l1, 0, sizeof(*drc->lookup_l1) * (1 << drc->l1bits)); memset(drc->lookup_l2_recompile, 0, sizeof(*drc->lookup_l2_recompile) * (1 << drc->l2bits)); /* allocate the sequence and tentative lists */ drc->sequence_count_max = config->max_instructions; drc->sequence_list = osd_malloc(drc->sequence_count_max * sizeof(*drc->sequence_list)); drc->tentative_count_max = config->max_instructions; drc->tentative_list = osd_malloc(drc->tentative_count_max * sizeof(*drc->tentative_list)); if (!drc->sequence_list || !drc->tentative_list) return NULL; /* seed the cache */ drc_cache_reset(drc); return drc; }
int tms36xx_sh_start(const struct MachineSound *msound) { int i, j; intf = msound->sound_interface; for( i = 0; i < intf->num; i++ ) { int enable; struct TMS36XX *tms; char name[16]; if (intf->subtype[i] == MM6221AA) sprintf(name, "MM6221AA #%d", i); else sprintf(name, "TMS36%02d #%d", intf->subtype[i], i); tms36xx[i] = osd_malloc(sizeof(struct TMS36XX)); if( !tms36xx[i] ) { logerror("%s failed to malloc struct TMS36XX\n", name); return 1; } tms = tms36xx[i]; memset(tms, 0, sizeof(struct TMS36XX)); tms->subtype = osd_malloc(strlen(name) + 1); strcpy(tms->subtype, name); tms->channel = stream_init(name, intf->mixing_level[i], Machine->sample_rate, i, tms36xx_sound_update); if( tms->channel == -1 ) { logerror("%s stream_init failed\n", name); return 1; } tms->samplerate = Machine->sample_rate ? Machine->sample_rate : 1; tms->basefreq = intf->basefreq[i]; enable = 0; for (j = 0; j < 6; j++) { if( intf->decay[i][j] > 0 ) { tms->decay[j+0] = tms->decay[j+6] = VMAX / intf->decay[i][j]; enable |= 0x41 << j; } } tms->speed = (intf->speed[i] > 0) ? VMAX / intf->speed[i] : VMAX; tms3617_enable_w(i,enable); LOG(("%s samplerate %d\n", name, tms->samplerate)); LOG(("%s basefreq %d\n", name, tms->basefreq)); LOG(("%s decay %d,%d,%d,%d,%d,%d\n", name, tms->decay[0], tms->decay[1], tms->decay[2], tms->decay[3], tms->decay[4], tms->decay[5])); LOG(("%s speed %d\n", name, tms->speed)); } return 0; }
MACHINE_DRIVER_END /*************************************************************************** ROMs Loading ***************************************************************************/ /* Address lines scrambling */ static void decryptcode( int a23, int a22, int a21, int a20, int a19, int a18, int a17, int a16, int a15, int a14, int a13, int a12, int a11, int a10, int a9, int a8, int a7, int a6, int a5, int a4, int a3, int a2, int a1, int a0 ) { int i; data8_t *RAM = memory_region( REGION_CPU1 ); size_t size = memory_region_length( REGION_CPU1 ); data8_t *buffer = osd_malloc( size ); if( buffer ) { memcpy( buffer, RAM, size ); for( i = 0; i < size; i++ ) { RAM[ i ] = buffer[ BITSWAP24( i, a23, a22, a21, a20, a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, a9, a8, a7, a6, a5, a4, a3, a2, a1, a0 ) ]; } free( buffer ); } }
void *malloc_file_line(size_t size, const char *file, int line) { // allocate the memory and fail if we can't void *ret = osd_malloc(size); memset(ret, 0, size); return ret; }
void *malloc_or_die_file_line(size_t size, const char *file, int line) { void *result; /* fail on attempted allocations of 0 */ if (size == 0) fatalerror("Attempted to malloc zero bytes (%s:%d)", file, line); /* allocate and return if we succeeded */ #ifdef MALLOC_DEBUG result = malloc_file_line(size, file, line); #elif _PS3_ result = osd_malloc(size); #else result = malloc(size); #endif if (result != NULL) { #ifdef MAME_DEBUG rand_memory(result, size); #endif return result; } /* otherwise, die horribly */ fatalerror("Failed to allocate %d bytes (%s:%d)", (int)size, file, line); }
osd_lock *osd_lock_alloc(void) { pthread_mutexattr_t mutexattr; if (pthread_mutexattr_init(&mutexattr) || pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE)) { return NULL; } pthread_mutex_t *ret = (pthread_mutex_t *) osd_malloc(sizeof(pthread_mutex_t)); if (ret == NULL) { return NULL; } if (pthread_mutex_init(ret, &mutexattr)) { osd_free(ret); return NULL; } return (osd_lock *) ret; }
void wav_add_data_32(wav_file *wav, INT32 *data, int samples, int shift) { INT16 *temp; int i; if (!wav) return; /* allocate temp memory */ temp = (INT16 *)osd_malloc(samples * sizeof(temp[0])); if (!temp) return; /* clamp */ for (i = 0; i < samples; i++) { int val = data[i] >> shift; temp[i] = (val < -32768) ? -32768 : (val > 32767) ? 32767 : val; } /* write and flush */ fwrite(temp, 2, samples, wav->file); fflush(wav->file); /* free memory */ osd_free(temp); }
int stream_init_multi(int channels,const char **names,const int *default_mixing_levels, int sample_rate, int param,void (*callback)(int param,INT16 **buffer,int length)) { int channel,i; channel = mixer_allocate_channels(channels,default_mixing_levels); stream_joined_channels[channel] = channels; for (i = 0;i < channels;i++) { mixer_set_name(channel+i,names[i]); if ((stream_buffer[channel+i] = osd_malloc(sizeof(INT16)*BUFFER_LEN)) == 0) return -1; stream_sample_rate[channel+i] = sample_rate; stream_buffer_pos[channel+i] = 0; if (sample_rate) stream_sample_length[channel+i] = 1000000 / sample_rate; else stream_sample_length[channel+i] = 0; } stream_param[channel] = param; stream_callback_multi[channel] = callback; set_RC_filter(channel,0,0,0,0); return channel; }
void *malloc_file_line(size_t size, const char *file, int line, bool array, bool throw_on_fail, bool clear) { // allocate the memory and fail if we can't void *result = array ? osd_malloc_array(size) : osd_malloc(size); if (result == nullptr) { fprintf(stderr, "Failed to allocate %d bytes (%s:%d)\n", UINT32(size), file, line); osd_break_into_debugger("Failed to allocate RAM"); if (throw_on_fail) throw std::bad_alloc(); return nullptr; } // zap the memory if requested if (clear) memset(result, 0, size); else { #if !__has_feature(memory_sanitizer) && defined(INITIALIZE_ALLOCATED_MEMORY) && !defined(MAME_DEBUG_FAST) memset(result, 0xdd, size); #endif } // add a new entry memory_entry::allocate(size, result, file, line, array); return result; }
int stream_init(const char *name,int default_mixing_level, int sample_rate, int param,void (*callback)(int param,INT16 *buffer,int length)) { int channel; channel = mixer_allocate_channel(default_mixing_level); stream_joined_channels[channel] = 1; mixer_set_name(channel,name); if ((stream_buffer[channel] = osd_malloc(sizeof(INT16)*BUFFER_LEN)) == 0) return -1; stream_sample_rate[channel] = sample_rate; stream_buffer_pos[channel] = 0; if (sample_rate) stream_sample_length[channel] = 1000000 / sample_rate; else stream_sample_length[channel] = 0; stream_param[channel] = param; stream_callback[channel] = callback; set_RC_filter(channel,0,0,0,0); return channel; }
text_buffer *text_buffer_alloc(UINT32 bytes, UINT32 lines) { text_buffer *text; /* allocate memory for the text buffer object */ text = (text_buffer *)osd_malloc(sizeof(*text)); if (!text) return NULL; /* allocate memory for the buffer itself */ text->buffer = (char *)osd_malloc_array(bytes); if (!text->buffer) { osd_free(text); return NULL; } /* allocate memory for the lines array */ text->lineoffs = (INT32 *)osd_malloc_array(lines * sizeof(text->lineoffs[0])); if (!text->lineoffs) { osd_free(text->buffer); osd_free(text); return NULL; } /* initialize the buffer description */ text->bufsize = bytes; text->linesize = lines; text_buffer_clear(text); return text; }
static osd_shared_mem *osd_sharedmem_alloc(const char *path, int create, size_t size) { int fd; osd_shared_mem *os_shmem = (osd_shared_mem *) osd_malloc(sizeof(osd_shared_mem)); if (create) { char *buf = (char *) osd_malloc_array(size); memset(buf,0, size); fd = open(path, O_RDWR | O_CREAT, S_IRWXU); write(fd, buf, size); os_shmem->creator = 1; } else { fd = open(path, O_RDWR); if (fd == -1) { osd_free(os_shmem); return NULL; } os_shmem->creator = 0; } os_shmem->fn = (char *) osd_malloc_array(strlen(path)+1); strcpy(os_shmem->fn, path); assert(fd != -1); os_shmem->ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); os_shmem->size = size; close(fd); return os_shmem; }
static inline void execute_sync(osd_work_callback callback, const worker_param &wp) { worker_param *wp_temp = (worker_param *) osd_malloc(sizeof(worker_param)); *wp_temp = wp; callback((void *) wp_temp, 0); }
file_error osd_get_full_path(char **dst, const char *path) { file_error err; char path_buffer[512]; err = FILERR_NONE; if (getcwd(path_buffer, 511) == NULL) { printf("osd_get_full_path: failed!\n"); err = FILERR_FAILURE; } else { *dst = (char *)osd_malloc(strlen(path_buffer)+strlen(path)+3); // if it's already a full path, just pass it through if (path[0] == '/') { strcpy(*dst, path); } else { sprintf(*dst, "%s%s%s", path_buffer, PATH_SEPARATOR, path); } } return err; }
osd_directory_entry *osd_stat(const char *path) { int err; osd_directory_entry *result = NULL; #if defined(SDLMAME_DARWIN) || defined(SDLMAME_NO64BITIO) struct stat st; #else struct stat64 st; #endif #if defined(SDLMAME_DARWIN) || defined(SDLMAME_NO64BITIO) err = stat(path, &st); #else err = stat64(path, &st); #endif if( err == -1) return NULL; // create an osd_directory_entry; be sure to make sure that the caller can // free all resources by just freeing the resulting osd_directory_entry result = (osd_directory_entry *) osd_malloc(sizeof(*result) + strlen(path) + 1); strcpy(((char *) result) + sizeof(*result), path); result->name = ((char *) result) + sizeof(*result); result->type = S_ISDIR(st.st_mode) ? ENTTYPE_DIR : ENTTYPE_FILE; result->size = (UINT64)st.st_size; return result; }
static void hs_save (void) { mame_file *f = mame_fopen (Machine->gamedrv->name, 0, FILETYPE_HIGHSCORE, 1); LOG(("hs_save\n")); if (f) { struct mem_range *mem_range = state.mem_range; LOG(("saving...\n")); while (mem_range) { UINT8 *data = osd_malloc (mem_range->num_bytes); if (data) { /* this buffer will almost certainly be small enough to be dynamically allocated, but let's avoid memory trashing just in case */ copy_from_memory (mem_range->cpu, mem_range->addr, data, mem_range->num_bytes); mame_fwrite(f, data, mem_range->num_bytes); } mem_range = mem_range->next; } mame_fclose(f); } }
static void hs_load (void) { mame_file *f = mame_fopen (Machine->gamedrv->name, 0, FILETYPE_HIGHSCORE, 0); state.hiscores_have_been_loaded = 1; LOG(("hs_load\n")); if (f) { struct mem_range *mem_range = state.mem_range; LOG(("loading...\n")); while (mem_range) { UINT8 *data = osd_malloc (mem_range->num_bytes); if (data) { /* this buffer will almost certainly be small enough to be dynamically allocated, but let's avoid memory trashing just in case */ mame_fread (f, data, mem_range->num_bytes); copy_to_memory (mem_range->cpu, mem_range->addr, data, mem_range->num_bytes); free (data); } mem_range = mem_range->next; } mame_fclose (f); } }
void wav_add_data_32lr(wav_file *wav, INT32 *left, INT32 *right, int samples, int shift) { INT16 *temp; int i; if (!wav) return; /* allocate temp memory */ temp = (INT16 *)osd_malloc(samples * 2 * sizeof(temp[0])); if (!temp) return; /* interleave */ for (i = 0; i < samples * 2; i++) { int val = (i & 1) ? right[i / 2] : left[i / 2]; val >>= shift; temp[i] = (val < -32768) ? -32768 : (val > 32767) ? 32767 : val; } /* write and flush */ fwrite(temp, 4, samples, wav->file); fflush(wav->file); /* free memory */ osd_free(temp); }
int sdl_window_info::window_init() { worker_param *wp = (worker_param *) osd_malloc(sizeof(worker_param)); int result; ASSERT_MAIN_THREAD(); // set the initial maximized state // FIXME: Does not belong here sdl_options &options = downcast<sdl_options &>(m_machine.options()); m_startmaximized = options.maximize(); // add us to the list *last_window_ptr = this; last_window_ptr = &this->m_next; set_renderer(draw.create(this)); // create an event that we can use to skip blitting m_rendered_event = osd_event_alloc(FALSE, TRUE); // load the layout m_target = m_machine.render().target_alloc(); // set the specific view set_starting_view(m_index, options.view(), options.view(m_index)); // make the window title if (video_config.numscreens == 1) sprintf(m_title, "%s: %s [%s]", emulator_info::get_appname(), m_machine.system().description, m_machine.system().name); else sprintf(m_title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), m_machine.system().description, m_machine.system().name, m_index); wp->set_window(this); // FIXME: pass error back in a different way if (multithreading_enabled) { osd_work_item *wi; wi = osd_work_item_queue(work_queue, &sdl_window_info::complete_create_wt, (void *) wp, 0); sdlwindow_sync(); result = *((int *) (osd_work_item_result)(wi)); osd_work_item_release(wi); } else result = *((int *) sdl_window_info::complete_create_wt((void *) wp, 0)); // handle error conditions if (result == 1) goto error; return 0; error: destroy(); return 1; }
static void add_list(copy_info **head, copy_info *element, Uint32 bm) { copy_info *newci = (copy_info *) osd_malloc(sizeof(copy_info)); *newci = *element; newci->bm_mask = bm; newci->next = *head; *head = newci; }
static osd_shared_mem *osd_sharedmem_alloc(const char *path, int create, size_t size) { osd_shared_mem *os_shmem = (osd_shared_mem *) osd_malloc(sizeof(osd_shared_mem)); os_shmem->creator = 0; os_shmem->ptr = (void *) osd_malloc_array(size); os_shmem->size = size; return os_shmem; }
TCHAR* win_tstring_strdup(LPCTSTR str) { TCHAR *cpy = NULL; if (str != NULL) { cpy = (TCHAR*)osd_malloc((_tcslen(str) + 1) * sizeof(TCHAR)); if (cpy != NULL) _tcscpy(cpy, str); } return cpy; }
static inline void execute_async(osd_work_callback callback, const worker_param &wp) { worker_param *wp_temp = (worker_param *) osd_malloc(sizeof(worker_param)); *wp_temp = wp; if (multithreading_enabled) { osd_work_item_queue(work_queue, callback, (void *) wp_temp, WORK_ITEM_FLAG_AUTO_RELEASE); } else callback((void *) wp_temp, 0); }
static char *build_full_path(const char *path, const char *file) { char *ret = (char *) osd_malloc(strlen(path)+strlen(file)+2); char *p = ret; strcpy(p, path); p += strlen(path); *p++ = PATHSEPCH; strcpy(p, file); return ret; }
static win_i *add_win_i(running_machine &machine, int win_type) { win_i *win = (win_i *) osd_malloc(sizeof(*win)); memset(win, 0, sizeof(*win)); win->cpu = NULL; win->machine = &machine; win->type = win_type; win->next = win_list; win_list = win; return win; }
char *utf8_from_wstring(const WCHAR *wstring) { int char_count; char *result; // convert UTF-16 to MAME string (UTF-8) char_count = WideCharToMultiByte(CP_UTF8, 0, wstring, -1, NULL, 0, NULL, NULL); result = (char *)osd_malloc(char_count * sizeof(*result)); if (result != NULL) WideCharToMultiByte(CP_UTF8, 0, wstring, -1, result, char_count, NULL, NULL); return result; }
WCHAR *wstring_from_utf8(const char *utf8string) { int char_count; WCHAR *result; // convert MAME string (UTF-8) to UTF-16 char_count = MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, NULL, 0); result = (WCHAR *)osd_malloc(char_count * sizeof(*result)); if (result != NULL) MultiByteToWideChar(CP_UTF8, 0, utf8string, -1, result, char_count); return result; }
osd_midi_device *osd_open_midi_output(const char *devname) { int num_devs = Pm_CountDevices(); int found_dev = -1; const PmDeviceInfo *pmInfo; PortMidiStream *stm; osd_midi_device *ret; if (!strcmp("default", devname)) { found_dev = Pm_GetDefaultOutputDeviceID(); } else { for (int i = 0; i < num_devs; i++) { pmInfo = Pm_GetDeviceInfo(i); if (pmInfo->output) { if (!strcmp(devname, pmInfo->name)) { found_dev = i; break; } } } } if (found_dev >= 0) { if (Pm_OpenOutput(&stm, found_dev, NULL, 100, NULL, NULL, 0) == pmNoError) { ret = (osd_midi_device *)osd_malloc(sizeof(osd_midi_device)); memset(ret, 0, sizeof(osd_midi_device)); ret->pmStream = stm; return ret; } else { printf("Couldn't open PM device\n"); return NULL; } } else { return NULL; } return NULL; }
void sdlwindow_clear(sdl_window_info *window) { worker_param *wp = (worker_param *) osd_malloc(sizeof(worker_param)); clear_worker_param(wp); wp->window = window; if (SDL_ThreadID() == main_threadid) { execute_async_wait(&sdlwindow_clear_surface_wt, wp); osd_free(wp); } else sdlwindow_clear_surface_wt( (void *) wp, 0); }
INLINE void execute_async(osd_work_callback callback, worker_param *wp) { worker_param *wp_temp = NULL; if (wp) { wp_temp = (worker_param *) osd_malloc(sizeof(worker_param)); *wp_temp = *wp; } if (multithreading_enabled) { osd_work_item_queue(work_queue, callback, (void *) wp_temp, WORK_ITEM_FLAG_AUTO_RELEASE); } else callback((void *) wp_temp, 0); }