import io import os import sys import ctypes import pytest import sdl2 from sdl2 import SDL_Init, SDL_Quit, version, surface, rwops, render from .conftest import _check_error_msg sdlimage = pytest.importorskip("sdl2.sdlimage") formats = [ "bmp", "cur", "gif", "ico", "jpg", "lbm", "pbm", "pcx", "pgm", "png", "pnm", "ppm", "svg", "tga", "tif", "webp", "xcf", "xpm", #"xv", # no idea how to create one, seems like a long-dead format? "qoi", #"jxl", # not yet available in official Windows/macOS binaries #"avif", # not yet available in official Windows/macOS binaries ] animation_formats = [ "gif", "webp", ] ### Disable problem formats on specific versions/platforms ### img_ver = sdlimage.dll.version is32bit = sys.maxsize <= 2**32 ismacos = sys.platform == "darwin" iswindows = "win" in sys.platform isconda = os.getenv("CONDA_PREFIX") != None # QOI unsupported on SDL2_image < 2.6.0 if img_ver < 2060: formats.remove("qoi") # WEBP animations unsupported on SDL2_image < 2.8.0 if img_ver < 2080: animation_formats.remove("webp") # SVG unsupported on SDL2_image < 2.0.2 as well as in Conda's current (2.0.5) # Windows binaries if img_ver < 2002 or (isconda and iswindows): formats.remove("svg") # Prior to 2.6.0, XCF was broken on official 32-bit builds and macOS frameworks. # It is also currently broken in Conda's SDL2_image Windows binaries bad_xcf = False xcf_broken = img_ver <= 2005 and (is32bit or ismacos) if xcf_broken or (isconda and iswindows): formats.remove("xcf") bad_xcf = True # WEBP support seems to be broken in the 32-bit Windows SDL2_image 2.0.2 binary # and is missing in the official macOS 2.6.0 binary bad_webp = (is32bit and img_ver == 2002) or (ismacos and img_ver == 2060) if bad_webp: formats.remove("webp") # JPG saving requires SDL2_image >= 2.0.2 and is broken in older macOS binaries no_jpeg_save = img_ver < 2002 or (ismacos and img_ver < 2060) @pytest.fixture(scope="module") def with_sdl_image(with_sdl): flags = ( sdlimage.IMG_INIT_JPG | sdlimage.IMG_INIT_PNG | sdlimage.IMG_INIT_TIF | sdlimage.IMG_INIT_WEBP ) sdlimage.IMG_Init(flags) yield sdlimage.IMG_Quit() @pytest.fixture def sw_renderer(with_sdl_image): sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0) rd = render.SDL_CreateSoftwareRenderer(sf) yield rd render.SDL_DestroyRenderer(rd) surface.SDL_FreeSurface(sf) def _get_image_path(fmt): fname = "surfacetest.{0}".format(fmt) testdir = os.path.dirname(os.path.abspath(__file__)) return os.path.join(testdir, "resources", fname) def _get_image_rw(fmt): fpath = _get_image_path(fmt).encode('utf-8') return sdl2.SDL_RWFromFile(fpath, b"r") def _get_animation_path(fmt): fname = "animationtest.{0}".format(fmt) testdir = os.path.dirname(os.path.abspath(__file__)) return os.path.join(testdir, "resources", fname) def _verify_img_load(surf): if not surf: assert sdlimage.IMG_GetError() == b"" assert surf assert isinstance(surf.contents, surface.SDL_Surface) def _verify_anim_load(anim): if not anim: assert sdlimage.IMG_GetError() == b"" assert anim assert isinstance(anim.contents, sdlimage.IMG_Animation) assert anim.contents.w == 32 assert anim.contents.h == 32 assert anim.contents.count == 4 def test_IMG_Linked_Version(): v = sdlimage.IMG_Linked_Version() assert isinstance(v.contents, version.SDL_version) assert v.contents.major == 2 assert v.contents.minor >= 0 assert v.contents.patch >= 0 t = (v.contents.major, v.contents.minor, v.contents.patch) assert t >= (2, 0, 1) assert t == sdlimage.dll.version_tuple def test_IMG_Init(): global formats SDL_Init(0) supported = [] libs = { 'JPEG': sdlimage.IMG_INIT_JPG, 'PNG': sdlimage.IMG_INIT_PNG, 'TIFF': sdlimage.IMG_INIT_TIF, 'WEBP': sdlimage.IMG_INIT_WEBP, 'JPEG XL': sdlimage.IMG_INIT_JXL, 'AVIF': sdlimage.IMG_INIT_AVIF, } for lib in libs.keys(): flags = libs[lib] ret = sdlimage.IMG_Init(flags) err = sdlimage.IMG_GetError() if err: err = err.decode('utf-8') print("Error loading {0} library: {1}".format(lib, err)) sdl2.SDL_ClearError() if ret & flags == flags: supported.append(lib) elif lib.lower() in formats: formats.remove(lib.lower()) sdlimage.IMG_Quit() print("Supported image libraries:") print(supported) assert len(supported) # Only fail if none supported def test_IMG_Load(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) sf = sdlimage.IMG_Load(fpath.encode("utf-8")) _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_Load_RW(with_sdl_image): skip = ['tga'] # TGA broken for Load_RW for fmt in formats: if fmt in skip: continue rw = _get_image_rw(fmt) sf = sdlimage.IMG_Load_RW(rw, False) sdl2.SDL_RWclose(rw) _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadTexture(sw_renderer): rd = sw_renderer skip = [] for fmt in formats: if fmt in skip: continue fpath = _get_image_path(fmt) tex = sdlimage.IMG_LoadTexture(rd, fpath.encode("utf-8")) if not tex: assert sdlimage.IMG_GetError() == b"" assert tex assert isinstance(tex.contents, render.SDL_Texture) render.SDL_DestroyTexture(tex) def test_IMG_LoadTexture_RW(sw_renderer): rd = sw_renderer skip = ['svg', 'tga'] # TGA & SVG broken for LoadTexture_RW for fmt in formats: if fmt in skip: continue fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: tex = sdlimage.IMG_LoadTexture_RW(rd, rwops.rw_from_object(fp), 0) if not tex: assert sdlimage.IMG_GetError() == b"" assert tex assert isinstance(tex.contents, render.SDL_Texture) render.SDL_DestroyTexture(tex) def test_IMG_LoadTextureTyped_RW(sw_renderer): rd = sw_renderer skip = ['svg'] # SVG broken for LoadTextureTyped_RW for fmt in formats: if fmt in skip: continue fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: rw = rwops.rw_from_object(fp) fmtx = fmt.upper().encode("utf-8") tex = sdlimage.IMG_LoadTextureTyped_RW(rd, rw, 0, fmtx) if not tex: assert sdlimage.IMG_GetError() == b"" assert tex assert isinstance(tex.contents, render.SDL_Texture) render.SDL_DestroyTexture(tex) def test_IMG_LoadTyped_RW(with_sdl_image): skip = [] for fmt in formats: if fmt in skip: continue rw = _get_image_rw(fmt) sf = sdlimage.IMG_LoadTyped_RW(rw, False, fmt.upper().encode("utf-8")) sdl2.SDL_RWclose(rw) _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skip("not yet available in official binaries") @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadAVIF_RW(with_sdl_image): fp = io.open(_get_image_path("avif"), "rb") sf = sdlimage.IMG_LoadBMP_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadBMP_RW(with_sdl_image): fp = io.open(_get_image_path("bmp"), "rb") sf = sdlimage.IMG_LoadBMP_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadCUR_RW(with_sdl_image): fp = io.open(_get_image_path("cur"), "rb") sf = sdlimage.IMG_LoadCUR_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadGIF_RW(with_sdl_image): fp = io.open(_get_image_path("gif"), "rb") sf = sdlimage.IMG_LoadGIF_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadICO_RW(with_sdl_image): fp = io.open(_get_image_path("ico"), "rb") sf = sdlimage.IMG_LoadICO_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadJPG_RW(with_sdl_image): fp = io.open(_get_image_path("jpg"), "rb") sf = sdlimage.IMG_LoadJPG_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skip("not yet available in official binaries") @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadJXL_RW(with_sdl_image): fp = io.open(_get_image_path("jxl"), "rb") sf = sdlimage.IMG_LoadBMP_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadLBM_RW(with_sdl_image): fp = io.open(_get_image_path("lbm"), "rb") sf = sdlimage.IMG_LoadLBM_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadPCX_RW(with_sdl_image): fp = io.open(_get_image_path("pcx"), "rb") sf = sdlimage.IMG_LoadPCX_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadPNG_RW(with_sdl_image): fp = io.open(_get_image_path("png"), "rb") sf = sdlimage.IMG_LoadPNG_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadPNM_RW(with_sdl_image): fp = io.open(_get_image_path("pnm"), "rb") sf = sdlimage.IMG_LoadPNM_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skipif(sdlimage.dll.version < 2002, reason="Added in 2.0.2") @pytest.mark.xfail(isconda and iswindows, reason="Broken w/ win64 Conda") def test_IMG_LoadSVG_RW(with_sdl_image): fp = io.open(_get_image_path("svg"), "rb") sf = sdlimage.IMG_LoadSVG_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadQOI_RW(with_sdl_image): fp = io.open(_get_image_path("qoi"), "rb") sf = sdlimage.IMG_LoadQOI_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadTGA_RW(with_sdl_image): fp = io.open(_get_image_path("tga"), "rb") sf = sdlimage.IMG_LoadTGA_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadTIF_RW(with_sdl_image): fp = io.open(_get_image_path("tif"), "rb") sf = sdlimage.IMG_LoadTIF_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.xfail(bad_webp, reason="WEBP not availale or broken") def test_IMG_LoadWEBP_RW(with_sdl_image): fp = io.open(_get_image_path("webp"), "rb") sf = sdlimage.IMG_LoadWEBP_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.xfail(bad_xcf, reason="XCF currently broken on some platforms") def test_IMG_LoadXCF_RW(with_sdl_image): fp = io.open(_get_image_path("xcf"), "rb") sf = sdlimage.IMG_LoadXCF_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) def test_IMG_LoadXPM_RW(with_sdl_image): fp = io.open(_get_image_path("xpm"), "rb") sf = sdlimage.IMG_LoadXPM_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skip("not implemented") def test_IMG_LoadXV_RW(with_sdl_image): fp = io.open(_get_image_path("xv"), "rb") sf = sdlimage.IMG_LoadXV_RW(rwops.rw_from_object(fp)) fp.close() _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.xfail(isconda and iswindows, reason="Broken w/ win64 Conda") @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadSizedSVG_RW(with_sdl_image): fp = io.open(_get_image_path("svg"), "rb") sf = sdlimage.IMG_LoadSizedSVG_RW(rwops.rw_from_object(fp), 100, 0) fp.close() _verify_img_load(sf) assert sf.contents.w == 100 assert sf.contents.h == 100 surface.SDL_FreeSurface(sf) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_isAVIF(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "avif": assert sdlimage.IMG_isAVIF(imgrw) else: assert not sdlimage.IMG_isAVIF(imgrw) def test_IMG_isBMP(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "bmp": assert sdlimage.IMG_isBMP(imgrw) else: assert not sdlimage.IMG_isBMP(imgrw) def test_IMG_isCUR(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "cur": assert sdlimage.IMG_isCUR(imgrw) else: assert not sdlimage.IMG_isCUR(imgrw) def test_IMG_isGIF(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "gif": assert sdlimage.IMG_isGIF(imgrw) else: assert not sdlimage.IMG_isGIF(imgrw) def test_IMG_isICO(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "ico": assert sdlimage.IMG_isICO(imgrw) else: assert not sdlimage.IMG_isICO(imgrw) def test_IMG_isJPG(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "jpg": assert sdlimage.IMG_isJPG(imgrw) else: assert not sdlimage.IMG_isJPG(imgrw) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_isJXL(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "jxl": assert sdlimage.IMG_isJXL(imgrw) else: assert not sdlimage.IMG_isJXL(imgrw) def test_IMG_isLBM(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "lbm": assert sdlimage.IMG_isLBM(imgrw) else: assert not sdlimage.IMG_isLBM(imgrw) def test_IMG_isPCX(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "pcx": assert sdlimage.IMG_isPCX(imgrw) else: assert not sdlimage.IMG_isPCX(imgrw) def test_IMG_isPNG(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "png": assert sdlimage.IMG_isPNG(imgrw) else: assert not sdlimage.IMG_isPNG(imgrw) def test_IMG_isPNM(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt in ("pnm", "pbm", "ppm", "pgm"): assert sdlimage.IMG_isPNM(imgrw) else: assert not sdlimage.IMG_isPNM(imgrw) @pytest.mark.skipif(sdlimage.dll.version < 2002, reason="Added in 2.0.2") @pytest.mark.xfail(isconda and iswindows, reason="Broken w/ win64 Conda") def test_IMG_isSVG(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "svg": assert sdlimage.IMG_isSVG(imgrw) else: assert not sdlimage.IMG_isSVG(imgrw) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_isQOI(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "qoi": assert sdlimage.IMG_isQOI(imgrw) else: assert not sdlimage.IMG_isQOI(imgrw) def test_IMG_isTIF(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "tif": assert sdlimage.IMG_isTIF(imgrw) else: assert not sdlimage.IMG_isTIF(imgrw) @pytest.mark.xfail(bad_webp, reason="WEBP not availale or broken") def test_IMG_isWEBP(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "webp": assert sdlimage.IMG_isWEBP(imgrw) else: assert not sdlimage.IMG_isWEBP(imgrw) @pytest.mark.xfail(bad_xcf, reason="XCF currently broken on some platforms") def test_IMG_isXCF(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "xcf": assert sdlimage.IMG_isXCF(imgrw) else: assert not sdlimage.IMG_isXCF(imgrw) def test_IMG_isXPM(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "xpm": assert sdlimage.IMG_isXPM(imgrw) else: assert not sdlimage.IMG_isXPM(imgrw) @pytest.mark.skip("not implemented") def test_IMG_isXV(with_sdl_image): for fmt in formats: fpath = _get_image_path(fmt) with io.open(fpath, "rb") as fp: imgrw = rwops.rw_from_object(fp) if fmt == "xv": assert sdlimage.IMG_isXV(imgrw) else: assert not sdlimage.IMG_isXV(imgrw) @pytest.mark.skipif(hasattr(sys, "pypy_version_info"), reason="PyPy's ctypes fails to pass a correct string array") def test_IMG_ReadXPMFromArray(with_sdl_image): fp = io.open(_get_image_path("xpm"), "rb") xpm = b"" fp.readline() # /* XPM */ fp.readline() # static char * surfacetest_xpm[] = { lbuf = fp.readlines() fp.close() for line in lbuf: if line.endswith(b"};"): xpm += line[1:-4] else: xpm += line[1:-3] pxpm = ctypes.c_char_p(xpm) sf = sdlimage.IMG_ReadXPMFromArray(ctypes.byref(pxpm)) _verify_img_load(sf) surface.SDL_FreeSurface(sf) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_ReadXPMFromArrayToRGB888(with_sdl_image): fp = io.open(_get_image_path("xpm"), "rb") xpm = b"" fp.readline() # /* XPM */ fp.readline() # static char * surfacetest_xpm[] = { lbuf = fp.readlines() fp.close() for line in lbuf: if line.endswith(b"};"): xpm += line[1:-4] else: xpm += line[1:-3] pxpm = ctypes.c_char_p(xpm) sf = sdlimage.IMG_ReadXPMFromArrayToRGB888(ctypes.byref(pxpm)) _verify_img_load(sf) assert sf.contents.format.contents.format == sdl2.SDL_PIXELFORMAT_ARGB8888 surface.SDL_FreeSurface(sf) def test_IMG_SavePNG(tmpdir): # Open a PNG that we can re-save fpath = _get_image_path("png") sf = sdlimage.IMG_Load(fpath.encode("utf-8")) assert isinstance(sf.contents, surface.SDL_Surface) # Try saving the PNG to a new folder outpath = os.path.join(str(tmpdir), "save_test.png") ret = sdlimage.IMG_SavePNG(sf, outpath.encode("utf-8")) assert ret == 0, _check_error_msg() assert os.path.exists(outpath) surface.SDL_FreeSurface(sf) def test_IMG_SavePNG_RW(tmpdir): # Open a PNG that we can re-save fpath = _get_image_path("png") sf = sdlimage.IMG_Load(fpath.encode("utf-8")) assert isinstance(sf.contents, surface.SDL_Surface) # Try saving the PNG to a new folder outpath = os.path.join(str(tmpdir), "save_test.png") rw = rwops.SDL_RWFromFile(outpath.encode("utf-8"), b"wb") ret = sdlimage.IMG_SavePNG_RW(sf, rw, 0) sdl2.SDL_RWclose(rw) assert ret == 0, _check_error_msg() assert os.path.exists(outpath) # Try reopening the RW as a PNG sf2 = sdlimage.IMG_Load(outpath.encode("utf-8")) _verify_img_load(sf2) surface.SDL_FreeSurface(sf) surface.SDL_FreeSurface(sf2) @pytest.mark.skipif(no_jpeg_save, reason="Added in 2.0.2, not in macOS bnaries") def test_IMG_SaveJPG(tmpdir): # Open a PNG that we can save to JPG fpath = _get_image_path("png") sf = sdlimage.IMG_Load(fpath.encode("utf-8")) assert isinstance(sf.contents, surface.SDL_Surface) # Try saving as JPG to a new folder outpath = os.path.join(str(tmpdir), "save_test.jpg") ret = sdlimage.IMG_SaveJPG(sf, outpath.encode("utf-8"), 90) assert ret == 0, _check_error_msg() assert os.path.exists(outpath) surface.SDL_FreeSurface(sf) @pytest.mark.skipif(no_jpeg_save, reason="Added in 2.0.2, not in macOS bnaries") def test_IMG_SaveJPG_RW(tmpdir): # Open a PNG that we can save to JPG fpath = _get_image_path("png") sf = sdlimage.IMG_Load(fpath.encode("utf-8")) assert isinstance(sf.contents, surface.SDL_Surface) # Try saving as JPG to a new folder outpath = os.path.join(str(tmpdir), "save_test.jpg") rw = rwops.SDL_RWFromFile(outpath.encode("utf-8"), b"wb") ret = sdlimage.IMG_SaveJPG_RW(sf, rw, 0, 90) sdl2.SDL_RWclose(rw) assert ret == 0, _check_error_msg() assert os.path.exists(outpath) # Try reopening the RW as a JPG sf2 = sdlimage.IMG_Load(outpath.encode("utf-8")) _verify_img_load(sf2) surface.SDL_FreeSurface(sf) surface.SDL_FreeSurface(sf2) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadFreeAnimation(with_sdl_image): for fmt in animation_formats: fpath = _get_animation_path(fmt) anim = sdlimage.IMG_LoadAnimation(fpath.encode("utf-8")) _verify_anim_load(anim) # Do full test of IMG_Animation structure for frame in range(anim.contents.count): assert anim.contents.delays[frame] == 1000 framesurf = anim.contents.frames[frame].contents assert isinstance(framesurf, surface.SDL_Surface) assert framesurf.w == 32 sdlimage.IMG_FreeAnimation(anim) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadAnimation_RW(): for fmt in animation_formats: fpath = _get_animation_path(fmt) with io.open(fpath, "rb") as fp: anim = sdlimage.IMG_LoadAnimation_RW(rwops.rw_from_object(fp), 0) _verify_anim_load(anim) sdlimage.IMG_FreeAnimation(anim) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadAnimationTyped_RW(): for fmt in animation_formats: fpath = _get_animation_path(fmt) with io.open(fpath, "rb") as fp: anim = sdlimage.IMG_LoadAnimationTyped_RW( rwops.rw_from_object(fp), 0, fmt.upper().encode("utf-8") ) _verify_anim_load(anim) sdlimage.IMG_FreeAnimation(anim) @pytest.mark.skipif(sdlimage.dll.version < 2060, reason="Added in 2.6.0") def test_IMG_LoadGIFAnimation_RW(): fp = io.open(_get_animation_path("gif"), "rb") anim = sdlimage.IMG_LoadGIFAnimation_RW(rwops.rw_from_object(fp)) fp.close() _verify_anim_load(anim) sdlimage.IMG_FreeAnimation(anim) @pytest.mark.skipif(sdlimage.dll.version < 2080, reason="Added in 2.8.0") def test_IMG_LoadWEBPAnimation_RW(): fp = io.open(_get_animation_path("webp"), "rb") anim = sdlimage.IMG_LoadWEBPAnimation_RW(rwops.rw_from_object(fp)) fp.close() _verify_anim_load(anim) sdlimage.IMG_FreeAnimation(anim)