int main(int argc, char * argv[])
{
	//Load the config and apply
		//Load the configs of screen
	win_w = cfg.Load(KEY_WINWIDTH);
	win_h = cfg.Load(KEY_WINHEIGHT);
		//Load the volumn and apply
	snd.ApplyCfg(BGMCN, cfg.Load(BGMCN));
	snd.ApplyCfg(SECN,  cfg.Load(SECN));
	snd.ApplyCfg(VCECN, cfg.Load(VCECN));

	//Init
	SDL_Init(SDL_INIT_EVENTS);
	win = SDL_CreateWindow("MaikazeSekai", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, win_w, win_h, SDL_WINDOW_OPENGL);
	ren = SDL_CreateRenderer(win, -1, 0);
	SDL_RenderSetLogicalSize(ren, 1280, 720);
	blk = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, win_w, win_h);
		//sent the renderer to Class Image as a stage and init them with the FileMgr
	img.Init(ren, &file);
	snd.Init(&file);

    
    auto *rw = SDL_RWFromFile("z:/star.png", "r");
    auto sur = IMG_Load_RW(rw, AUTOFREE);
    auto tex = SDL_CreateTextureFromSurface(ren, sur);
    SDL_FreeSurface(sur);
    SDL_Rect rt = { 0, 0, 2362, 7087 };
    SDL_RenderCopy(ren, tex, NULL, &rt);
    SDL_RenderPresent(ren);
    SDL_DestroyTexture(tex);

    auto *rw2 = SDL_RWFromFile("z:/1.png", "r");
    auto sur2 = IMG_Load_RW(rw2, AUTOFREE);
    auto tex2 = SDL_CreateTextureFromSurface(ren, sur2);
    SDL_FreeSurface(sur2);
    SDL_Rect rt2 = { 0, 0, 800, 900 };
    SDL_RenderCopy(ren, tex2, NULL, &rt2);
    SDL_RenderPresent(ren);
    //SDL_DestroyTexture(tex);
    
	
	//
	BGM("yui.wav", 1, 0);
	BG("sample.png");
	img.OnDraw();

	//Refresh the textures on renderer
	SDL_RenderPresent(ren);
    UnLoadBG();
    //SDL_DestroyTexture()
	//Logo();
	//Title();
	SDL_Quit();
	return 0;
}

surface get_no_cache(const std::string& key)
{
	std::string fname = path + key;
#if defined(__ANDROID__)
	if(fname[0] == '.' && fname[1] == '/') {
		fname = fname.substr(2);
	}
	SDL_RWops *rw = sys::read_sdl_rw_from_asset(module::map_file(fname).c_str());
	surface surf;
	if(rw) {
		surf = surface(IMG_Load_RW(rw,1));
	} else {
		surf = surface(IMG_Load(module::map_file(fname).c_str()));
	}
#else
	surface surf = surface(IMG_Load(module::map_file(fname).c_str()));
#endif // ANDROID
	//std::cerr << "loading image '" << fname << "'\n";
	if(surf.get() == false || surf->w == 0) {
		std::cerr << "failed to load image '" << key << "'\n";
		throw load_image_error();
	}

	//std::cerr << "IMAGE SIZE: " << (surf->w*surf->h) << "\n";
	return surf;
}

/**
* @brief Needs Debug 
* @param file_name name of the image file to load, relative to the base directory specified
* @param base_directory the base directory to use
*/
Surface::Surface(const std::string& file_name, ImageDirectory base_directory): Drawable(), internal_surface_created(true)
{
	std::string prefix = "";
	bool language_specific = false;
	
	if(base_directory == DIR_SPRITES)
	{
		prefix = "sprites/";
	}
	
	std::string prefixed_file_name = prefix + file_name;
	std::cout << prefixed_file_name << std::endl;
	size_t size;
	char* buffer;
	FileTools::data_file_open_buffer(prefixed_file_name, &buffer, &size);
	SDL_RWops* rw = SDL_RWFromMem(buffer, int(size));
	if(rw == NULL)
		std::cout << "rw didn't load\n";
	this->internal_surface = IMG_Load_RW(rw, 0);
	if(!internal_surface)
	{
		printf( "IMG_Load: %s\n", IMG_GetError());
		return;
	}
	FileTools::data_file_close_buffer(buffer);
	SDL_RWclose(rw);

	//Debug assertion
	
}

Image::Image(const char *filename) {
	SDL_RWops *image = SDL_RWFromFile(filename, "rb");
	m_surface = IMG_Load_RW(image, 1);
	
	if(!m_surface) {
		fprintf(stderr, "Failed to load image \"%s\": %s\n", filename, IMG_GetError());
		exit(EXIT_FAILURE);
	}
	
	m_width = m_surface->w;
	m_height = m_surface->h;
	
	m_texture = SDL_CreateTextureFromSurface(Window::main->renderer(), m_surface);
	if(!m_texture) {
		fprintf(stderr, "Failed to create texture from image: %s", SDL_GetError());
		exit(EXIT_FAILURE);
	}
	
	m_clipRect.x = 0;
	m_clipRect.y = 0;
	m_clipRect.w = m_width;
	m_clipRect.h = m_height;
	
	m_posRect.x = 0;
	m_posRect.y = 0;
	m_posRect.w = m_width;
	m_posRect.h = m_height;
}

gcn::Image* InfraellyImageLoader::load(unsigned char *buffer, long bufferLength, bool convertToDisplayFormat){
    //make rWop out of character buffer
    SDL_RWops *source_Rwop = SDL_RWFromMem(buffer, bufferLength);

    //load the rWop into a SDL Surface
    SDL_Surface *loadedSurface = IMG_Load_RW(source_Rwop, 1);

    if (loadedSurface == NULL)
    {
        throw GCN_EXCEPTION( std::string("Unable to load image file: ") );
    }

    SDL_Surface *surface = convertToStandardFormat(loadedSurface);
    SDL_FreeSurface(loadedSurface);

    if (surface == NULL)
    {
        throw GCN_EXCEPTION( std::string("Not enough memory to load: ") );
    }

    gcn::Image *image = new gcn::SDLImage(surface, true);

    if (convertToDisplayFormat)
    {
        image->convertToDisplayFormat();
    }

    return image;
}

gSurface *gLoadImage(const char *name)
{
   gSurface    *ret;
   SDL_RWops   *ops;

   if(!PHYSFS_exists(name))
   {
      gSetError("gLoadImage was unable to load the image %s", name);
      return NULL;
   }

   ops = PHYSFSRWOPS_openRead(name);
   if(!ops)
   {
      gSetError("gLoadImage was unable to load the image %s: failed _openRead", name);
      return NULL;
   }

   if(!(ret = IMG_Load_RW(ops, true)))
   {
      gSetError("gLoadImage was unable to load the image %s: %s", name, SDL_GetError());
      return NULL;
   }

   return ret;
}

void SetWindowIcon(photon_window &window, const std::string &filename){
    if(PHYSFS_exists(filename.c_str())){
        auto fp = PHYSFS_openRead(filename.c_str());
        intmax_t length = PHYSFS_fileLength(fp);
        if(length > 0){
            uint8_t *buffer = new uint8_t[length];

            PHYSFS_read(fp, buffer, 1, length);

            PHYSFS_close(fp);

            SDL_RWops *rw = SDL_RWFromMem(buffer, length);
            SDL_Surface *icon = IMG_Load_RW(rw, 1);

            if(icon == nullptr){
                PrintToLog("ERROR: icon loading failed! %s", IMG_GetError());
            }

            SDL_SetWindowIcon(window.window_SDL, icon);

            SDL_FreeSurface(icon);
            delete[] buffer;
        }else{
            PrintToLog("ERROR: Unable to open image file \"%s\"!");
        }
    }else{
        PrintToLog("ERROR: Image file \"%s\" does not exist!", filename.c_str());
    }
}

SDL_Surface *WadImageCache::image_from_desc(WadImageDescriptor& desc)
{
	SDL_Surface *surface = NULL;
	OpenedFile wad_file;
	if (open_wad_file_for_reading(desc.file, wad_file))
	{
		struct wad_header header;
		if (read_wad_header(wad_file, &header))
		{
			struct wad_data *wad;
			wad = read_indexed_wad_from_file(wad_file, &header, desc.index, true);
			if (wad)
			{
				void *data;
				size_t length;
				data = extract_type_from_wad(wad, desc.tag, &length);
				if (data && length)
				{
					SDL_RWops *rwops = SDL_RWFromConstMem(data, length);
#ifdef HAVE_SDL_IMAGE
					surface = IMG_Load_RW(rwops, 1);
#else
					surface = SDL_LoadBMP_RW(rwops, 1);
#endif
				}
				free_wad(wad);
			}
		}
		close_wad_file(wad_file);
	}
	clear_game_error();
	return surface;
}

int img_read(char *filein) {

	SDL_PixelFormat *fmt;   // we need that to determine which BPP
	SDL_RWops *rw;

	if (g_statics.debug) {
		printf("Reading from %s\n", filein);
		fflush(stdout);
	}

	if (!strcmp(filein, "-")) { // stdin as input. Shouldn't work but we try anyways
		rw = SDL_RWFromFP(stdin, 0);
	} else { // a regular file name
		rw = SDL_RWFromFile(filein, "rb");
	}

	g_statics.image_in = IMG_Load_RW(rw, 0);
	if (g_statics.image_in == NULL) {
		fprintf(stderr, "ERROR: %s\n", SDL_GetError());
		SDL_FreeRW(rw);
		return(-1);
	}

	// check if image is in 8bpp format
	fmt = g_statics.image_in->format;
	if (fmt->BitsPerPixel != 8) {
		fprintf(stderr, "ERROR: the image file is not in 8 bpp. Please convert it.\n");
		SDL_FreeSurface(g_statics.image_in);
		SDL_FreeRW(rw);
		return(-1);
	}

	if (g_statics.image_in->w != 192 || g_statics.image_in->h != 192) {
		fprintf(stderr, "ERROR: The image file is not 192x192 pixels. Please modify it.\n");
		SDL_FreeSurface(g_statics.image_in);
		SDL_FreeRW(rw);
		return(-1);
	}

	if (g_statics.debug > 1) {
		printf("The image file uses %d colours\n", fmt->palette->ncolors);
		fflush(stdout);
	}

	if ((g_variables.image_out = SDL_CreateRGBSurfaceFrom(g_statics.image_in->pixels, g_statics.image_in->w, g_statics.image_in->h, g_statics.image_in->pitch, g_statics.image_in->format->BitsPerPixel, 0, 0, 0, 0)) == NULL) {
		fprintf(stderr, "ERROR: %s", SDL_GetError());
		return(-1);
	}

	// need to convert the image using proper values for format, since there is a strong likelyhood to have more colours in the palette than for image_in.
	// algo: create proper palette, retrieve number of colours
	//       update image_in->format->palette with new info
	//       launch SDL_ConvertSurface

	g_variables.image_out = SDL_ConvertSurface(g_variables.image_out, g_statics.image_in->format, SDL_SWSURFACE);

	// a bit of clean up
	SDL_FreeRW(rw);
	return(0);
}

//
// TextureResourceLoader::VLoadResource				- Chapter 14, page 492
//
bool TextureResourceLoader::VLoadResource( char *rawBuffer, unsigned int rawSize, shared_ptr<ResHandle> handle )
   {
 	Renderer renderer = EngineApp::GetRendererImpl();
	if ( renderer == Renderer::Renderer_OpenGL )
	   {
		
      SDL_RWops* p_RWops = SDL_RWFromMem( rawBuffer, rawSize );
      if( !p_RWops )
         {
         ENG_ERROR( SDL_GetError() );
         return false;
         }
      SDL_Surface* p_Surface = IMG_Load_RW( p_RWops, 0 );
      if( SDL_RWclose( p_RWops ) )
         {
         ENG_WARNING( SDL_GetError() );
         }
      if( !p_Surface )
         {
         ENG_ERROR( SDL_GetError() );
         return false;
         }
      shared_ptr<SDLTextureResourceExtraData> extra = shared_ptr<SDLTextureResourceExtraData>( ENG_NEW SDLTextureResourceExtraData() );
      extra->m_pSurface = p_Surface;
      handle->SetExtraData( extra );
      handle->SetSize( extra->m_pSurface->w * extra->m_pSurface->h * extra->m_pSurface->format->BytesPerPixel );
	   }

	return true;
   }

gcn::Image* InfraellyImageLoader::load(SDL_RWops *source_Rwop, bool freeRWOP, bool convertToDisplayFormat){
    //load the rWop into a SDL Surface
    SDL_Surface *loadedSurface = IMG_Load_RW(source_Rwop, freeRWOP);

    if (loadedSurface == NULL)
    {
        throw GCN_EXCEPTION( std::string("Unable to load image file: ") );
    }

    SDL_Surface *surface = convertToStandardFormat(loadedSurface);
    SDL_FreeSurface(loadedSurface);

    if (surface == NULL)
    {
        throw GCN_EXCEPTION( std::string("Not enough memory to load: ") );
    }

    gcn::Image *image = new gcn::SDLImage(surface, true);

    if (convertToDisplayFormat)
    {
        image->convertToDisplayFormat();
    }

    return image;
}

SDL_Texture* LoadTextureFromFile(const String &file, SDL_Renderer *renderer)
{
	SDL_Texture *texture = nullptr;
	SDL_Surface *loadedImage = nullptr;

	//android
	#if defined(__ANDROID__)
		SDL_RWops *f = SDL_RWFromFile(file.c_str(), "rb");
		loadedImage = IMG_Load_RW(f , 1);

		if(f > 0)
			__android_log_write(ANDROID_LOG_INFO, "Chain Drop", "File Loaded");
	#elif defined(_WIN32)
		loadedImage = IMG_Load(file.c_str());
	#endif

	//If the loading went ok, convert to texture and return the texture
	if (loadedImage != nullptr)
	{
		texture = SDL_CreateTextureFromSurface(renderer, loadedImage);
		SDL_FreeSurface(loadedImage);
		//Make sure converting went ok too
		if (texture == nullptr)
			logSDLError(std::cout, "LoadTextureFromFile");
	}
	else
		logSDLError(std::cout, "LoadTextureFromFile");

	return texture;
}

void ResourceFile::load(std::string source)
{
	std::ifstream is(source.c_str(), std::ifstream::binary);
	ResourceMarker marker = ResourceMarker();

	while(!is.eof())
	{
		is.read( (char*) &marker, sizeof(ResourceMarker) );
		int rlength = marker.length;
		std::string rname = marker.name;

		char * buffer = new char[rlength];

		is.read(buffer, rlength);

		SDL_RWops *rw = SDL_RWFromMem(buffer, rlength);

		SDL_Surface *sdlSurface = IMG_Load_RW(rw, 1);

		Surface *surface = new Surface(sdlSurface);
		surface->setReleaseSurface(true);
		std::cout << IMG_GetError() << std::endl;

		//some error handling to do here

		delete buffer;

		resources.insert(std::make_pair(rname, surface));
	}

	is.close();
}

/**\brief Load image from buffer
 */
bool Image::Load( char *buf, int bufSize ) {
	SDL_RWops *rw;
	SDL_Surface *s = NULL;

	rw = SDL_RWFromMem( buf, bufSize );
	if( !rw ) {
		LogMsg(WARN, "Image loading failed. Could not create RWops" );
		return( false );
	}

	s = IMG_Load_RW( rw, 0 );
	SDL_FreeRW(rw);

	if( !s ) {
		LogMsg(WARN, "Image loading failed. Could not load image from RWops" );
		return( false );
	}

	w = s->w;
	h = s->h;

	if( ConvertToTexture( s ) == false ) {
		LogMsg(WARN, "Failed to load image from buffer" );
		SDL_FreeSurface( s );
		return( false );
	}


	return( true );
}

GLuint Graphic::LoadTexture( const char* src, GLfloat *texcoord, Uint32* width, Uint32* height) {
    static std::pair<GLuint, TexCoordArray> dat;
    tex_iter iter = texMap.find(src);
    GLuint texture;
    if (iter != texMap.end()) {
        texture = iter->second.first;
        memcpy(texcoord, iter->second.second.data, 4 * sizeof(GLfloat));
        *width = iter->second.second.w;
        *height = iter->second.second.h;
    } else {
        SDL_Surface *surface = IMG_Load_RW(Storage::GetInstance()->OpenIFile(src), 1);
        if (!surface) {
            char buf[256];
            snprintf(buf, sizeof(buf), "Load file failed: %s", src);
            throw Exception(buf);
        }
        texture = SDL_GL_LoadTexture(surface, texcoord);
        if (texture == 0) {
            throw Exception("failed create texture.");
        }
        dat.first = texture;
        memcpy(dat.second.data, texcoord, 4*sizeof(GLfloat));
        dat.second.w = *width = surface->w;
        dat.second.h = *height = surface->h;
        texMap[src] = dat;
        SDL_FreeSurface(surface);

    }
    return texture;
}

int PLEXT_Window_SetIconImageFile(const DXCHAR *filename) {
    SDL_Surface *surface;
    SDL_RWops *file;
    
    file = PL_File_OpenStream(filename);
    if (file == NULL) {
        return -1;
    }

    surface = IMG_Load_RW(file, SDL_TRUE);
    if (surface == NULL) {
        return -1;
    }
    
    if (s_windowIcon != NULL) {
        SDL_FreeSurface(s_windowIcon);
    }
    s_windowIcon = surface;
    
    if (s_initialized == DXTRUE) {
        SDL_SetWindowIcon(s_window, s_windowIcon);
    }
    
    return 0;
}

	surface surface::load(std::streambuf* buf,string type) {
		surface surface;
		SDL_RWops* wop = build_rwops_stream(buf);
		struct noname {
            SDL_RWops* woop;
            ~noname() {
                if(woop!=NULL)
                    SDL_RWclose(woop);
            }
        } destroyer;
        destroyer.woop = wop;
		if(type=="auto")
			surface.build(IMG_Load_RW(wop,false));
		else
			surface.build(IMG_LoadTyped_RW(wop,false,(char*)type.c_str()));
        return surface;
		/*int beg = strea.tellg();
		strea.seekg(0,ios::end);
		int size = ((int)strea.tellg())-beg;
		strea.seekg(beg,ios::beg);
		vector<char> vec(size);
		strea.read(&vec[0],size);
		SDL_RWops* wop = SDL_RWFromConstMem(&vec[0],size);
		if(wop == NULL)
			throw exception_sdl();
		if(type=="auto")
			surface.build(IMG_Load_RW(wop,true));
		else
			surface.build(IMG_LoadTyped_RW(wop,true,(char*)type.c_str()));
		return surface;*/
	}

/**
 * \brief Creates a surface from the specified image file name.
 *
 * An assertion error occurs if the file cannot be loaded.
 *
 * \param file_name Name of the image file to load, relative to the base directory specified.
 * \param base_directory The base directory to use.
 */
Surface::Surface(const std::string& file_name, ImageDirectory base_directory):
  Drawable(),
  internal_surface(NULL),
  owns_internal_surface(true),
  with_colorkey(false),
  colorkey(0) {

  std::string prefix = "";
  bool language_specific = false;

  if (base_directory == DIR_SPRITES) {
    prefix = "sprites/";
  }
  else if (base_directory == DIR_LANGUAGE) {
    language_specific = true;
    prefix = "images/";
  }
  std::string prefixed_file_name = prefix + file_name;

  size_t size;
  char* buffer;
  FileTools::data_file_open_buffer(prefixed_file_name, &buffer, &size, language_specific);
  SDL_RWops* rw = SDL_RWFromMem(buffer, int(size));
  this->internal_surface = IMG_Load_RW(rw, 0);
  FileTools::data_file_close_buffer(buffer);
  SDL_RWclose(rw);

  Debug::check_assertion(internal_surface != NULL, StringConcat() <<
      "Cannot load image '" << prefixed_file_name << "'");
    
  with_colorkey = SDL_GetColorKey(internal_surface, &colorkey) == 0;
}

SDL_Texture* LoadData::LoadImages(char *filename)
{
	SDL_RWops* RW_src = NULL;
	SDL_Texture* ret = NULL;
	
	//RW_src = LoadFile_RW(filename);
	RW_src = loadFile_PHYSFS(filename);
	if (RW_src != NULL)
	{
		SDL_Surface* toLoadSurface = IMG_Load_RW(RW_src, 1);
		if (toLoadSurface == NULL)
		{
			LOG("Failed to load IMG from RW! ERROR: %s", IMG_GetError());
		}
		else
		{
			//ret = SDL_CreateTextureFromSurface(App->render->renderer, toLoadSurface);
			//App->tex->textures.add(ret);
			ret = App->tex->LoadSurface(toLoadSurface);
			SDL_FreeSurface(toLoadSurface);
			if (ret == NULL)
			{
				LOG("Failed to load IMG from RW! ERROR: %s", IMG_GetError());
			}
		}
	}
	return ret;
}

static SDL_Surface* IMG_Load_istream(std::istream* stream, int freesrc) {
    SDL_RWops* irwops = reinterpret_cast<SDL_RWops*>(malloc(sizeof SDL_RWops));
    SimKit::construct_istream_rwops_adapter(irwops, i);
    
    SDL_Surface* out = IMG_Load_RW(irwops, freesrc);
    if (freesrc == 0) free(irwops);
    return out;
};