static int zfread_alternate(unzFile * f, void *buffer, int length, int inc)
{
Uint8 *buf = buffer;
Uint8 tempbuf[4096];
Uint32 totread, r, i;
int totlength=length;
totread = 0;
while (length) {
r = length;
if (r > 4096)
r = 4096;
r = unzReadCurrentFile(f, tempbuf, r);
if (r == 0) {
terminate_progress_bar();
return totread;
}
for (i = 0; i < r; i++) {
*buf = tempbuf[i];
buf += inc;
}
totread += r;
length -= r;
update_progress_bar(totread,totlength);
}
terminate_progress_bar();
return totread;
}
static int zfread(unzFile * f, void *buffer, int length)
{
Uint8 *buf = (Uint8*)buffer;
Uint8 *tempbuf;
Uint32 totread, r, i;
int totlength=length;
totread = 0;
tempbuf=alloca(4097);
while (length) {
r = length;
if (r > 4096)
r = 4096;
r = unzReadCurrentFile(f, tempbuf, r);
if (r == 0) {
terminate_progress_bar();
return totread;
}
memcpy(buf, tempbuf, r);
buf += r;
totread += r;
length -= r;
update_progress_bar(totread,totlength);
}
terminate_progress_bar();
return totread;
}
int soundfile_load_file(char *filename, long lpos, long lsample_count,
int status_info)
{
sf_count_t pos = lpos;
sf_count_t sample_count = lsample_count;
int rc = -1;
if (sf_seek(sndfile, pos, SEEK_SET|SFM_WRITE) == pos) {
int channels = sfinfo.channels;
sf_count_t buffer_size = SBW*1000;
int *buffer = calloc(channels*buffer_size, sizeof(int));
if (buffer != NULL) {
SNDFILE *sndfile_new;
SF_INFO sfinfo_new = sfinfo;
sfinfo_new.format = 0;
sndfile_new = sf_open(filename, SFM_READ, &sfinfo_new);
if (sndfile_new != NULL) {
sf_count_t processed = 0;
sf_count_t read_size;
if (sample_count > sfinfo_new.frames)
sample_count = sfinfo_new.frames;
while (processed < sample_count) {
if (buffer_size > sample_count - processed)
buffer_size = sample_count - processed;
read_size = sf_readf_int(sndfile_new, buffer, buffer_size);
if (read_size > 0)
sf_writef_int(sndfile, buffer, read_size);
processed += buffer_size;
if (status_info)
update_progress_bar((gfloat)processed/sample_count,
PROGRESS_UPDATE_INTERVAL, FALSE);
}
sf_close(sndfile_new);
rc = 0;
/* remove(filename); */
}
free(buffer);
}
}
return rc;
}
static void load_previous_server_state(){
std::ifstream in("server_state.save");
if(in.is_open()){
std::vector<std::string> save;
char data[65536];
while(in.getline(data, 65536)){
save.push_back(data);
}
const uint_ save_size = save.size();
for(uint_ i = 0;i < save_size;i++){
update_class_data(save[i], ~0);
update_progress_bar(i/save_size, "load_previous_server_state");
}
}else{
printf("There doesn't appear to be a server_save file to use\n");
}
}
void
quick_check (void)
{
#ifdef QUICK_CHECK_ENABLED
static gboolean quick_check_running = FALSE;
GList *list_pointer;
gint nb_rom_not_checked;
gfloat done;
MameRomEntry *rom;
GMAMEUI_DEBUG ("Running quick check.");
if (game_list.num_games == 0)
return;
/*prevent user to launch several quick check at the same time */
if (quick_check_running)
{
GMAMEUI_DEBUG ("Quick check already running");
return;
}
quick_check_running = TRUE;
show_progress_bar ();
nb_rom_not_checked = g_list_length (game_list.not_checked_list);
g_message (_("Performing quick check, please wait:"));
/* Disable the callback */
g_signal_handlers_block_by_func (G_OBJECT (gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (main_gui.scrolled_window_games))),
(gpointer)adjustment_scrolled, NULL);
/* need to use the last or I can find the list anymore*/
for (list_pointer = game_list.not_checked_list;
list_pointer;
list_pointer = g_list_next (list_pointer))
{
rom = (MameRomEntry *)list_pointer->data;
/* Check for the existence of the ROM; if the ROM is a clone, the
parent set must exist as well */
if (mame_rom_entry_is_clone (rom))
if ((check_rom_exists_as_file (mame_rom_entry_get_romname (rom))) &&
(check_rom_exists_as_file (mame_rom_entry_get_parent_romname (rom))))
g_object_set (rom, "has-roms", UNKNOWN, NULL);
else
g_object_set (rom, "has-roms", NOT_AVAIL, NULL);
else if (check_rom_exists_as_file (mame_rom_entry_get_romname (rom)))
g_object_set (rom, "has-roms", UNKNOWN, NULL);
else
g_object_set (rom, "has-roms", NOT_AVAIL, NULL);
/* Looking for samples */
rom->has_samples = 0;
if (mame_rom_entry_has_samples (rom))
{
/* Check for the existence of the samples; if the samples is a clone, the
parent set must exist as well */
if (strcmp (rom->sampleof, "-")) {
if ((check_rom_exists_as_file (mame_rom_entry_get_romname (rom))) &&
(check_rom_exists_as_file (rom->sampleof)))
g_object_set (rom, "has-samples", CORRECT, NULL);
} else if (check_rom_exists_as_file (mame_rom_entry_get_romname (rom)))
g_object_set (rom, "has-samples", CORRECT, NULL);
}
list_pointer->data = NULL;
nb_rom_not_checked--;
done = (gfloat) (game_list.num_games - nb_rom_not_checked) / (gfloat)game_list.num_games;
#if 0
if (done >= 0.0 && done <= 1.0)
update_progress_bar (done);
#endif
/* if the game is in the list, update it */
if (rom->is_in_list)
mame_gamelist_view_update_game_in_list (rom);
}
g_list_free(game_list.not_checked_list);
game_list.not_checked_list = NULL;
hide_progress_bar ();
quick_check_running= FALSE;
/* Re-Enable the callback */
g_signal_handlers_unblock_by_func (G_OBJECT (gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (main_gui.scrolled_window_games))),
(gpointer)adjustment_scrolled, NULL);
#endif
}
/* shift all samples from 'first_pos' to begin of file
* (this removes 'sample_count' samples at end of file)
*/
int soundfile_shift_samples_left(long lfirst_pos, long lsample_count,
int status_info)
{
/* if 'last_pos' is equal 'end_pos' simply truncate the end
* else move sample i from 'last_pos' to the 'first_pos' position
* (for all i between 'last_pos' and end of file)
* and then truncate 'last_pos - first_pos' samples at the end.
*/
sf_count_t first_pos = lfirst_pos;
sf_count_t sample_count = lsample_count;
sf_count_t end_pos = sf_seek(sndfile, 0, SEEK_END|SFM_READ);
sf_count_t last_pos = first_pos + sample_count;
if (sample_count <= 0) {
puts("soundfile_shift_samples_left: no samples to move");
return 0;
}
/* printf("soundfile_shift_samples_left: " */
/* "first_pos=%lld, shift=%lld, samples in file=%lld\n", */
/* first_pos, sample_count, end_pos); */
if (last_pos < end_pos)
{
sf_count_t processed = 0;
sf_count_t buffer_size;
int channels = sfinfo.channels;
#define TMPBUFSIZE (4*SBW*1000)
int buffer[TMPBUFSIZE];
/* start position for writing */
if (sf_seek(sndfile, first_pos, SEEK_SET|SFM_WRITE) < 0)
{
perr("soundfile_shift_samples_left: sf_seek write pointer");
warning("Libsndfile reports write pointer seek error in audio file");
return -1;
}
/* start position for reading */
if (sf_seek(sndfile, last_pos, SEEK_SET|SFM_READ) < 0)
{
perr("soundfile_shift_samples_left: sf_seek read pointer");
warning("Libsndfile reports read pointer seek error in audio file");
return -1;
}
/* loop to end of file */
buffer_size = TMPBUFSIZE/channels;
while ((buffer_size = sf_readf_int(sndfile, buffer, buffer_size)) > 0)
{
if (sf_writef_int(sndfile, buffer, buffer_size) != buffer_size) {
perr("soundfile_shift_samples_left: sf_writef_int");
warning("Libsndfile reports write error in audio file");
return -1;
}
processed += buffer_size;
if (status_info)
update_progress_bar((gfloat)processed/(end_pos-first_pos-sample_count),
PROGRESS_UPDATE_INTERVAL, FALSE);
/* printf("soundfile_shift_samples_left: processed=%lld (%f.2)\n", */
/* processed, (gfloat)processed/(end_pos-first_pos-sample_count)); */
}
}
/* truncate file size for '-sample_count' samples */
end_pos -= sample_count;
if (sf_command(sndfile, SFC_FILE_TRUNCATE, &end_pos, sizeof(end_pos)))
{
perr("soundfile_shift_samples_left: sf_command");
warning("Libsndfile reports truncation of audio file failed");
return -1;
}
/* printf("soundfile_shift_samples_left: samples in file=%lld\n", */
/* sf_seek(sndfile, 0, SEEK_END|SFM_READ)); */
adjust_all_marker_positions(first_pos, -sample_count);
return 0;
}
/* append 'sample_count' samples and shift all samples from 'first_pos'
* to end of file (this creates 'sample_count' samples at 'first_pos')
*/
int soundfile_shift_samples_right(long lfirst_pos, long lsample_count,
int status_info)
{
sf_count_t first_pos = lfirst_pos;
sf_count_t sample_count = lsample_count;
sf_count_t end_pos = sf_seek(sndfile, 0, SEEK_END|SFM_READ);
if (sample_count <= 0) {
puts("soundfile_shift_samples_right: no samples to move");
return 0;
}
/* printf("soundfile_shift_samples_right: " */
/* "first_pos=%lld, shift=%lld, samples in file=%lld\n", */
/* first_pos, sample_count, end_pos); */
if (first_pos < end_pos) {
sf_count_t processed = 0;
sf_count_t read_pos, write_pos;
int channels = sfinfo.channels;
#define TMPBUFSIZE (4*SBW*1000)
int buffer[TMPBUFSIZE];
sf_count_t buffer_size = TMPBUFSIZE/channels;
/* go to end position and append enough space for the new data */
if (write_silence(end_pos, sample_count) < 0) {
return -1;
}
/* loop reading-writing from end */
write_pos = end_pos + sample_count;
read_pos = end_pos;
while (read_pos > first_pos) {
if (buffer_size > read_pos - first_pos)
buffer_size = read_pos - first_pos;
write_pos -= buffer_size;
read_pos -= buffer_size;
/* printf("soundfile_shift_samples_right: " */
/* "read_pos=%lld, write_pos=%lld, diff=%lld, buffer_size=%lld\n", */
/* read_pos, write_pos, write_pos-read_pos, buffer_size); */
/* start position for reading */
if (sf_seek(sndfile, read_pos, SEEK_SET|SFM_READ) < 0) {
perr("soundfile_shift_samples_right: sf_seek read pointer");
warning("Libsndfile reports read pointer seek error in audio file");
return -1;
}
if (sf_readf_int(sndfile, buffer, buffer_size) != buffer_size) {
perr("soundfile_shift_samples_right: sf_readf_int");
warning("Libsndfile reports read error in audio file");
return -1;
}
/* start position for writing */
if (sf_seek(sndfile, write_pos, SEEK_SET|SFM_WRITE) < 0) {
perr("soundfile_shift_samples_right: sf_seek write pointer");
warning("Libsndfile reports write pointer seek error in audio file");
return -1;
}
if (sf_writef_int(sndfile, buffer, buffer_size) != buffer_size) {
perr("soundfile_shift_samples_right: sf_writef_int");
warning("Libsndfile reports write error in audio file");
return -1;
}
processed += buffer_size;
if (status_info)
update_progress_bar((gfloat)processed/(end_pos-first_pos),
PROGRESS_UPDATE_INTERVAL, FALSE);
/* printf("soundfile_shift_samples_right: processed=%lld (%f.2)\n", */
/* processed, (gfloat)processed/(end_pos-first_pos)); */
}
}
/* printf("soundfile_shift_samples_right: samples in file=%lld\n", */
/* sf_seek(sndfile, 0, SEEK_END|SFM_READ)); */
adjust_all_marker_positions(first_pos, sample_count);
return 0;
}
/*--------------------------------------------------------------------------*/
static void
read_remote_file_callback( GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer buffer,
GnomeVFSFileSize bytes_requested,
GnomeVFSFileSize bytes_read,
gpointer callback_data )
{
DownloadCallbackData *data = (DownloadCallbackData *)callback_data;
GnomeVFSFileSize bytes_written;
gb_debug (DEBUG_UPDATE, "START");
if ( update_cancel_flag ) {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "END -- CANCEL");
return;
}
switch (result) {
case GNOME_VFS_OK:
if ( bytes_read > 0 ) {
data->total_bytes_read += bytes_read;
data->file_bytes_read += bytes_read;
update_progress_bar (GTK_PROGRESS_BAR(file_progress),
data->file_bytes_read,
data->file_bytes);
update_progress_bar (GTK_PROGRESS_BAR(total_progress),
data->total_bytes_read,
data->total_bytes);
gnome_vfs_write( data->local_handle,
buffer, bytes_read, &bytes_written );
if ( bytes_written != bytes_read ) {
g_warning( "Write failed: %d bytes written != %d bytes read",
(gint)bytes_written, (gint)bytes_read );
}
gnome_vfs_async_read( handle, data->buffer, data->buffer_length,
read_remote_file_callback, data );
}
else {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "0 length read");
}
break;
case GNOME_VFS_ERROR_EOF:
gb_debug (DEBUG_UPDATE, "EOF -- %" GNOME_VFS_OFFSET_FORMAT_STR,
bytes_read);
gnome_vfs_async_close( handle, close_remote_file_callback, data );
break;
default:
g_warning( "Read failed: %s", gnome_vfs_result_to_string(result) );
break;
}
gb_debug (DEBUG_UPDATE, "END");
}
/*--------------------------------------------------------------------------*/
static void open_remote_file_callback( GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer callback_data )
{
DownloadCallbackData *data = (DownloadCallbackData *)callback_data;
GnomeVFSFileInfo *info = (GnomeVFSFileInfo *)data->p->data;
gchar *local_path, *local_text_uri, *local_name;
GnomeVFSHandle *local_handle;
gchar *status_string;
GnomeVFSResult ret;
gb_debug (DEBUG_UPDATE, "START");
if ( update_cancel_flag ) {
gnome_vfs_async_close( handle, close_remote_file_callback, data );
gb_debug (DEBUG_UPDATE, "END -- CANCEL");
return;
}
switch (result) {
case GNOME_VFS_OK:
data->file_bytes_read = 0;
data->file_bytes = info->size;
status_string = g_strdup_printf( _("File: \"%s\" (%d of %d)"),
info->name, (data->i+1), data->n );
gtk_label_set_text( GTK_LABEL(file_label), status_string );
g_free( status_string );
update_progress_bar (GTK_PROGRESS_BAR(file_progress),
0,
data->file_bytes);
update_progress_bar (GTK_PROGRESS_BAR(total_progress),
data->total_bytes_read,
data->total_bytes);
local_name = hash_filename( info->name );
local_path = g_build_filename (gb_util_get_home_data_dir(),
local_name,
NULL);
local_text_uri = gnome_vfs_get_uri_from_local_path( local_path );
ret = gnome_vfs_create( &local_handle, local_text_uri,
GNOME_VFS_OPEN_WRITE, FALSE, 0664 );
if ( ret != GNOME_VFS_OK ) {
g_warning( "error opening local file %s, %s\n", local_path,
gnome_vfs_result_to_string(ret) );
}
else {
data->local_handle = local_handle;
gnome_vfs_async_read( handle, data->buffer, data->buffer_length,
read_remote_file_callback, data );
}
g_free( local_name );
g_free( local_path );
g_free( local_text_uri );
break;
default:
g_warning( "Open failed: %s.\n", gnome_vfs_result_to_string(result) );
break;
}
gb_debug (DEBUG_UPDATE, "END");
}
static void end_operation(void)
{
pop_status_text();
update_progress_bar(0.0, PROGRESS_UPDATE_INTERVAL, TRUE);
}
static void begin_operation(char *status_text)
{
push_status_text(status_text);
update_progress_bar(0.0, PROGRESS_UPDATE_INTERVAL, TRUE) ;
}
SDL_bool dr_load_game(DRIVER *dr,char *name) {
unzFile *gz;
int i;
LIST *l;
char *zip=get_zip_name(name);
gz = unzOpen(zip);
free(zip);
if (gz==NULL) {
return SDL_FALSE;
}
if (dr->special_bios) {
memory.bios=malloc(dr->bios.size);
memory.bios_size=dr->bios.size;
if (!dr_load_section(gz,dr->bios,memory.bios)) return SDL_FALSE;
}
for (i=0;i<SEC_MAX;i++) {
int s=dr->section[i].size;
Uint8 *current_buf=NULL;
//if (dr->section[i].item==NULL) continue;
if (s==0) continue;
// printf("%p %d \n",dr->section[i].item,i);
switch (i) {
case SEC_CPU:
memory.cpu = malloc(s);
current_buf = memory.cpu;
memory.cpu_size = s;
break;
case SEC_SFIX:
memory.sfix_game = malloc(s);
memory.fix_game_usage = malloc(s >> 5);
current_buf = memory.sfix_game;
memory.sfix_size = s;
break;
case SEC_SM1:
memory.sm1 = malloc(s);
current_buf = memory.sm1;
memory.sm1_size = s;
break;
case SEC_SOUND1:
memory.sound1 = malloc(s);
memory.sound1_size = s;
current_buf = memory.sound1;
break;
case SEC_SOUND2:
memory.sound2 = malloc(s);
memory.sound2_size = s;
current_buf = memory.sound2;
break;
case SEC_GFX:
memory.gfx = malloc(s);
//printf("Alloc %x for GFX: %p\n",s,memory.gfx);
memory.gfx_size = s;
current_buf = memory.gfx;
memory.pen_usage = malloc((s >> 7) * sizeof(int));
memset(memory.pen_usage, 0, (s >> 7) * sizeof(int));
memory.nb_of_tiles = s >> 7;
break;
/* TODO: Crypted rom */
default:
break;
}
if (!dr_load_section(gz,dr->section[i],current_buf)) return SDL_FALSE;
}
unzClose(gz);
/* TODO: Use directly the driver value insteed of recopying them */
conf.game=dr->name;
conf.rom_type=dr->rom_type;
conf.special_bios=dr->special_bios;
conf.extra_xor=dr->xor;
set_bankswitchers(dr->banksw_type);
for(i=0;i<6;i++)
memory.bksw_unscramble[i]=dr->banksw_unscramble[i];
for(i=0;i<64;i++)
memory.bksw_offset[i]=dr->banksw_off[i];
if (conf.rom_type == MGD2) {
create_progress_bar("Convert MGD2");
convert_mgd2_tiles(memory.gfx, memory.gfx_size);
convert_mgd2_tiles(memory.gfx, memory.gfx_size);
terminate_progress_bar();
}
if (conf.rom_type == MVS_CMC42) {
create_progress_bar("Decrypt GFX ");
kof99_neogeo_gfx_decrypt(conf.extra_xor);
terminate_progress_bar();
}
if (conf.rom_type == MVS_CMC50) {
create_progress_bar("Decrypt GFX ");
kof2000_neogeo_gfx_decrypt(conf.extra_xor);
terminate_progress_bar();
}
convert_all_char(memory.sfix_game, memory.sfix_size,
memory.fix_game_usage);
if (CF_BOOL(cf_get_item_by_name("convtile"))) {
create_progress_bar("Convert tile");
for (i = 0; i < memory.nb_of_tiles; i++) {
convert_tile(i);
if (i%100==0) update_progress_bar(i,memory.nb_of_tiles);
}
terminate_progress_bar();
}
if (memory.sound2 == NULL) {
memory.sound2 = memory.sound1;
memory.sound2_size = memory.sound1_size;
}
//backup neogeo game vectors
memcpy(memory.game_vector,memory.cpu,0x80);
printf(" \r");
return SDL_TRUE;
}
void Dialog::beginProgramming()
{
int numTries = 0;
char buf[1024];
int rc;
QMessageBox msgbox;
#ifdef _WIN32
Sleep(3000);
#else
usleep(3000000);
#endif
rc = Mobot_dongleGetTTY(buf, 1024);
if(rc) {
msgbox.setText("No connected robots detected.");
msgbox.exec();
return;
}
while(1) {
qDebug() << "Connecting to: " << buf;
stk_ = new CStkComms();
rc = stk_->connectWithTTY(buf);
qDebug() << "Connection finish with code: " << rc;
if(rc) {
if(numTries > 20) {
msgbox.setText("Detected robot not running valid bootloader. Please make "
"sure that the \"Program Firmware\" button is being clicked after "
"the red LED flashes but before the solid blue LED is showing. 1");
msgbox.exec();
return;
} else {
#ifdef _WIN32
Sleep(100);
#else
usleep(100000);
#endif
numTries++;
}
} else {
break;
}
numTries = 0;
#if 0
qDebug() << "Attempting handshake...";
rc = stk_->handshake();
qDebug() << "Handshake finished with code " << rc;
if(rc) {
if(numTries > 5) {
msgbox.setText("Detected robot not running valid bootloader. Please make "
"sure that the \"Program Firmware\" button is being clicked after "
"the red LED flashes but before the solid blue LED is showing. 2");
msgbox.exec();
return;
} else {
#ifdef _WIN32
Sleep(500);
#else
usleep(500000);
#endif
numTries++;
}
}
#endif
}
qDebug() << "Attempting to begin programming...";
stk_->programAllAsync(g_hexfilename.c_str());
ui->progressBar->setEnabled(true);
/* Start a timer to update the progress bar */
timer_ = new QTimer(this);
QObject::connect(timer_, SIGNAL(timeout()), this, SLOT(update_progress_bar()));
timer_->start(1000);
}
