int main(int argc, char *argv[])
{
    uint8_t *hsc;
    uint32_t lp;
    hsc=hsc_load("TECHNO.HSC");
    if(hsc==NULL)
    {
        printf("lostship.hsc not found. \n");
        return 3;
    }
    SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER);
    sound_init();
    start_opl_emulation();

    hsc_play(hsc,1);
    while(hsc_get_status())
    {
        if(lp!=hsc_get_pattpos())
        {
            printf("status - %d; pos - %d; pattpos - %d                       \r",hsc_get_status(),hsc_get_pos(),hsc_get_pattpos());
            lp=hsc_get_pattpos();
            fflush(stdout);
            usleep(100000);
        }
    }
    
    sound_end();
    return 0;
}

int eo_init( CONFIG* cfg )
{
  /* From main_.cpp */
  
  ATA_Init();
  sound_init();
  load_config();
  
  zx81.cwd[ 0 ] = 0;
  zx81.temppath[ 0 ] = 0;
  zx81.inipath[ 0 ] = 0;
  zx81.configpath[ 0 ] = 0;
  
  //RenderInit();
  SP0256_Init();

  AnimTimer1_Interval = 20;
  Timer2_Interval = 1000;

  //AccurateInit();
  
  int res = internal_init( cfg );
  
  AnimTimer1_Interval *= 1000;
  Timer2_Interval *= 1000;
  
  AnimTimer1_Count = AnimTimer1_Interval;
  return res;
}

void neogeo_main(void)
{
	Loop = LOOP_RESET;

	while (Loop >= LOOP_RESTART)
	{
		Loop = LOOP_EXEC;

		ui_popup_reset();

		fatal_error = 0;

		video_clear_screen();

		if (memory_init())
		{
			if (sound_init())
			{
				if (input_init())
				{
					if (neogeo_init())
					{
						neogeo_run();
					}
					neogeo_exit();
				}
				input_shutdown();
			}
			sound_exit();
		}
		memory_shutdown();
		show_fatal_error();
	}
}

int init()
{
	srand(time(0) ^ getpid());
	
	if (SDL_Init(0) < 0)
	{
		fprintf(stderr, "Error initialising SDL: %s\n", SDL_GetError());
		return -1;
	}
	
	if (config_init() == -1 ||
		input_init() == -1 ||
	    graphics_init() == -1 ||
	    sound_init() == -1 ||
	    level_init() == -1 ||
	    bomber_init() == -1 ||
	    bomb_init() == -1)
	{
		return -1;
	}
	
	// load images/animations - its done up ^ in init's
	
	// init calc_delta_time
	calc_delta_time();
	
	return 0;
}

bool emu_load_cart(const char *file_name) {
	FILE *f = fopen(file_name, "rb");
	if (f) {
		// Détermine la taille du fichier
		unsigned size = get_file_size(f);
		// Garde pour les sauvegardes d'état
		strcpy(emu_file_name, file_name);
		// Au moins un tableau couvrant la map 0000-7FFF...
		size = max(size, 0x8000);
		// Et multiple d'une page (arrondissement à la page supérieure)
		size = ((size + 0x3FFF) / 0x4000) * 0x4000;
		mem_rom = malloc(size);
		// La cartouche préparée, prépare le CPU
		cpu_init();
		lcd_init();
		sound_init();
		mem_init();
		// Charge le contenu
		fread(mem_rom, size, 1, f);
		fclose(f);
		// Démarrage
		mbc_init(size);
		load_sram();
		// Color-It
		ColorIt_init(file_name, mem_rom);
		return true;
	}
	return false;
}

int main(int argc, char *argv[])
{
    const char bar_length=50;
    dro_status drost;
    const char spin[]="-\\|/";
    int spin_index=0;
    int i;

    SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER);
    sound_init();
    start_opl_emulation();

    dro_load(data,data_length);
    dro_play(2);
    do
    {
        dro_get_status(&drost);
        printf("%c[",spin[spin_index]);
        for(i=0; i<bar_length-3; i++)
        {
            if (i<((float)drost.position/drost.length)*(bar_length-3)) printf("=");
            else printf(".");
        }
        printf("]\r");
        fflush(stdout);
        usleep(100000);
        spin_index=(spin_index+1) % 4;
    } while(drost.playing);
    usleep(1000000);

    dro_stop();
    sound_end();
    return 0;
}

void
system_sound_chipreset(void)
{

    sound_init(samplerate);
    return;
}

int BIKPlayer::doPlay()
{
	int done = 0;

	//bink is always truecolor
	g_truecolor = 1;

	frame_wait = 0;
	timer_last_sec = 0;
	video_frameskip = 0;

	if (sound_init( core->GetAudioDrv()->CanPlay())) {
		//sound couldn't be initialized
		return 1;
	}

	//last parameter is to enable YUV overlay
	outputwidth = (int) header.width;
	outputheight= (int) header.height;
	video->InitMovieScreen(outputwidth,outputheight, true);

	if (video_init(outputwidth,outputheight)) {
		return 2;
	}

	while (!done && next_frame()) {
		done = video->PollMovieEvents();
	}

	return 0;
}

void PICvision_init(void) {
    HardwareConfig();
    timers_init(TICK_FREQ);
    video_init();
    sound_init(1000/TICK_FREQ);
    splash_screen();
}//f()

int main(int argc, char **argv)
{
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);

    SDL_CreateWindowAndRenderer(SCREEN_WIDTH+232, SCREEN_HEIGHT+16, 0, &displayWindow, &displayRenderer);
    SDL_GetRendererInfo(displayRenderer, &displayRendererInfo);
    SDL_SetRenderDrawBlendMode(displayRenderer, SDL_BLENDMODE_BLEND);

    SCREEN_SHIFT_X = 8;
    SCREEN_SHIFT_Y = 8;

#ifdef __EMSCRIPTEN__
    emscripten_set_main_loop(null_loop_iter, 60, 1);
#endif

    srand(time(NULL));
    sound_init();
    resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT);
    load_resources();

    last_time = clock();

#ifdef __EMSCRIPTEN__
    emscripten_set_main_loop(loop_iter, 60, 1);
#else
    while (!done)
    {
        loop_iter();
    }
#endif

    sound_exit();
    Quit(0);
    return (0);
}

int ygInit(GameConfig *cfg)
{
  static int t;

  /* Init parseurs */
  CHECK_AND_RET(t = ydJsonInit(), -1, -1,
		    "json init failed");
  CHECK_AND_RET(jsonManager = ydNewManager(t), NULL, -1,
		    "json init failed");
  parsers[t] = jsonManager;

  /* Init scripting */
  /* TODO init internal lua function */
  CHECK_AND_RET(t = ysLuaInit(), -1, -1, "lua init failed");
  CHECK_AND_RET(luaManager = ysNewManager(NULL, t), NULL, -1,
		    "lua init failed");

  CHECK_AND_RET(yesLuaRegister(luaManager), -1, -1, "lua init failed");

  /* Init widgets */
  CHECK_AND_RET(ywidInitCallback(), -1, -1, "can not init callback");
  CHECK_AND_RET(ywinAddCallback(ywinCreateNativeCallback("FinishGame",
							 ygTerminateCallback)),
		-1, -1, "can not add game's callback");
  CHECK_AND_RET(ywMenuInit(), -1, -1, "Menu init failed");
  CHECK_AND_RET(ywMapInit(), -1, -1, "Map init failed");
  CHECK_AND_RET(ywTextScreenInit(), -1, -1, "Text Screen init failed");
  CHECK_AND_RET(ywContenerInit(), -1, -1, "Contener init failed");

  /* Init sound */
  sound_init(LIB_VLC);

  for (GList *tmp = cfg->rConf; tmp; tmp = tmp->next) {
    //TODO check which render to use :)
    if (yuiStrEqual(TO_RC(tmp->data)->name, "curses")) {
#ifdef WITH_CURSES
      ycursInit();
      CHECK_AND_RET(ycursRegistreMenu(), -1, -1, "Menu init failed");
      CHECK_AND_RET(ycursRegistreTextScreen(), -1, -1,
			"Text Screen init failed");
      CHECK_AND_RET(ycursRegistreMap(), -1, -1, "Map init failed");
#else
      /* print error */
#endif
    } else if (yuiStrEqual(TO_RC(tmp->data)->name, "sdl2")) {
#ifdef WITH_SDL
      ysdl2Init();
      CHECK_AND_RET(ysdl2RegistreTextScreen(), -1, -1,
			"Text Screen init failed");
      CHECK_AND_RET(ysdl2RegistreMenu(), -1, -1, "Menu init failed");
      CHECK_AND_RET(ysdl2RegistreMap(), -1, -1, "Map init failed");
#else
      /* print error */
#endif
    }
  }
  init = 1;
  return 0;
}

void AY8910_InitAll(int nClock, unsigned long nSampleRate)
{
	for (unsigned int i=0; i<MAX_8910; i++)
	{
		sound_init(&g_AY8910[i], NULL, nSampleRate);	// Inits mainly static members (except ay_tick_incr)
		sound_ay_init(&g_AY8910[i]);
	}
}

void AY8910_InitClock(int nClock, unsigned long nSampleRate)
{
	SetCLK( (double)nClock );
	for (unsigned int i=0; i<MAX_8910; i++)
	{
		sound_init(&g_AY8910[i], NULL, nSampleRate);	// ay_tick_incr is dependent on AY_CLK
	}
}

int coleco_init(int video_system) {
    int i;
    float tmp;
    int region = SMS_REGION_EXPORT;

    if(video_system == SMS_VIDEO_NTSC) {
        tmp = NTSC_Z80_CLOCK / PSG_DIVISOR / NTSC_FPS / NTSC_LINES_PER_FRAME /
              NTSC_CLOCKS_PER_SAMPLE;

        for(i = 0; i < NTSC_LINES_PER_FRAME; ++i) {
            psg_samples[i] = (uint32) (tmp * (i + 1)) -
                             (uint32) (tmp * i);
        }

        /* We end up generating 734 samples per frame @ 44100 Hz, 60fps, but we
           need 735. */
        psg_samples[261] += 1;

        region |= SMS_VIDEO_NTSC;

        sn76489_init(&psg, NTSC_Z80_CLOCK, 44100.0f,
                     SN76489_NOISE_BITS_NORMAL, SN76489_NOISE_TAPPED_NORMAL);
    }
    else {
        tmp = PAL_Z80_CLOCK / PSG_DIVISOR / PAL_FPS / PAL_LINES_PER_FRAME /
              PAL_CLOCKS_PER_SAMPLE;

        for(i = 0; i < PAL_LINES_PER_FRAME; ++i) {
            psg_samples[i] = (uint32) (tmp * (i + 1)) -
                             (uint32) (tmp * i);
        }

        /* We need 882 samples per frame @ 44100 Hz, 50fps. */
        region |= SMS_VIDEO_PAL;

        sn76489_init(&psg, PAL_Z80_CLOCK, 44100.0f,
                     SN76489_NOISE_BITS_NORMAL, SN76489_NOISE_TAPPED_NORMAL);
    }

    sms_region = region;

    gui_set_console((console_t *)&colecovision_cons);

    coleco_mem_init();

    sms_vdp_init(video_system, 0);
    sms_z80_init();
    sound_init(2, video_system);

    sms_z80_set_pread(&coleco_port_read);
    sms_z80_set_pwrite(&coleco_port_write);
    cycles_run = cycles_to_run = scanline = 0;

    colecovision_cons._base.initialized = 1;

    return 0;
}

void
sound_unpause( void )
{
  /* No sound if fastloading in progress */
  if( settings_current.fastload && tape_is_playing() )
    return;

  sound_init( settings_current.sound_device );
}

static int
machine_select_machine( fuse_machine_info *machine )
{
  int width, height, i;
  int capabilities;

  machine_current = machine;

  settings_set_string( &settings_current.start_machine, machine->id );
  
  tstates = 0;

  /* Reset the event stack */
  event_reset();
  if( event_add( 0, timer_event ) ) return 1;
  if( event_add( machine->timings.tstates_per_frame, spectrum_frame_event ) )
    return 1;

  sound_end();

  if( uidisplay_end() ) return 1;

  capabilities = libspectrum_machine_capabilities( machine->machine );

  /* Set screen sizes here */
  if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_VIDEO ) {
    width = DISPLAY_SCREEN_WIDTH;
    height = 2*DISPLAY_SCREEN_HEIGHT;
  } else {
    width = DISPLAY_ASPECT_WIDTH;
    height = DISPLAY_SCREEN_HEIGHT;
  }

  if( uidisplay_init( width, height ) ) return 1;

  sound_init( settings_current.sound_device );

  /* Mark RAM as not-present/read-only. The machine's reset function will
   * mark available pages as present/writeable.
   */
  for( i = 0; i < 2 * SPECTRUM_RAM_PAGES; i++ )
    memory_map_ram[i].writable = 0;

  /* Do a hard reset */
  if( machine_reset( 1 ) ) return 1;

  /* And the dock menu item */
  if( capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK ) {
    ui_menu_activate( UI_MENU_ITEM_MEDIA_CARTRIDGE_DOCK_EJECT, 0 );
  }

  /* Reset any dialogue boxes etc. which contain machine-dependent state */
  ui_widgets_reset();

  return 0;
}

void system_init(void)
{
    sms_init();
    pio_init();
    vdp_init();
    render_init();
    sound_init();

    sms.save = 0;
}

blargg_err_t Music_Player::init( long rate )
{
	sample_rate = rate;
	
	int min_size = sample_rate * 2 / fill_rate;
	int buf_size = 512;
	while ( buf_size < min_size )
		buf_size *= 2;
	
	return sound_init( sample_rate, buf_size, fill_buffer, this );
}

int main(int argc, char *argv[])
{
	gfx_width=640; gfx_height=480;
	gfx_fullscreen=0;

	c_minx=0;
	c_miny=0;
	c_maxx=gfx_width;
	c_maxy=gfx_height;

	fprintf(stderr, "Strange Adventures in Infinite Space - v" SAIS_VERSION_STRING "\n");
	fprintf(stderr, "Unofficial fork by Philip Boulain et. al. (see README.md)\n");

	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0)
	{
		fprintf(stderr, "Problem initialising SDL: %s\n", SDL_GetError());
		return 1;
	}
	SDL_WM_SetCaption("Strange Adventures In Infinite Space", "Strange Adventures In Infinite Space");

	// Enable UNICODE so we can emulate getch() in text input
	SDL_EnableUNICODE(1);

	// init SDL mixer
	if (Mix_OpenAudio(22050, AUDIO_S16, 2, 1024) < 0)
	{
		fprintf(stderr, "Problem initialising Audio: %s\n", SDL_GetError());
		return 1;
	}
	Mix_AllocateChannels(16);
	sound_init();

	// Must find the native resolution *before* setting the video mode
	const SDL_VideoInfo* video_info = SDL_GetVideoInfo();
	g_native_resolution.w = video_info->current_w;
	g_native_resolution.h = video_info->current_h;

	g_virtual_resolution.x = 0;
	g_virtual_resolution.y = 0;
	g_virtual_resolution.w = gfx_width;
	g_virtual_resolution.h = gfx_height;

	sdlsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, gfx_width, gfx_height, 8,
		0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);

	g_scaled_video = NULL;
	gfx_window_width  = gfx_width; // Start at 1:1 size
	gfx_window_height = gfx_height;
	gfx_resize();

	my_main();

	return 0;
}

void localinit(void)
{
    falloc_init();
/*    probe_init(true);*/
    sound_init();
#ifdef CMTSTUFF
    seqext_init();
#endif
    sine_init();
    stk_init();
}