pyglet 2.1.12__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/image/codecs/__init__.py

@@ -141,6 +141,15 @@ def add_default_codecs():
     except ImportError:
         pass
 
+    # Compressed texture in KTX2 format
+    try:
+        from pyglet.image.codecs import ktx2
+        registry.add_encoders(ktx2)
+        registry.add_decoders(ktx2)
+    except ImportError:
+        pass
+
+
     # Mac OS X default: Quartz
     if compat_platform == 'darwin':
         try:

pyglet/image/codecs/bmp.py

@@ -9,6 +9,7 @@ encoding.  Alpha channel is supported for 32-bit BI_RGB only.
 #
 # But some details including alignment and bit/byte order are omitted; see
 # http://www.fileformat.info/format/bmp/egff.htm
+from __future__ import annotations
 
 import ctypes
 from ctypes.wintypes import DWORD, LONG, WORD
@@ -31,7 +32,7 @@ class BITMAPFILEHEADER(ctypes.LittleEndianStructure):
         ('bfSize', DWORD),
         ('bfReserved1', WORD),
         ('bfReserved2', WORD),
-        ('bfOffBits', DWORD)
+        ('bfOffBits', DWORD),
     ]
 
 class BITMAPINFOHEADER(ctypes.LittleEndianStructure):
@@ -47,7 +48,7 @@ class BITMAPINFOHEADER(ctypes.LittleEndianStructure):
         ('biXPelsPerMeter', LONG),
         ('biYPelsPerMeter', LONG),
         ('biClrUsed', DWORD),
-        ('biClrImportant', DWORD)
+        ('biClrImportant', DWORD),
     ]
 
 CIEXYZTRIPLE = FXPT2DOT30 * 9
@@ -92,7 +93,7 @@ class RGBQUAD(ctypes.LittleEndianStructure):
         ('rgbBlue', BYTE),
         ('rgbGreen', BYTE),
         ('rgbRed', BYTE),
-        ('rgbReserved', BYTE)
+        ('rgbReserved', BYTE),
     ]
 
     def __repr__(self):
@@ -137,7 +138,7 @@ class BMPImageDecoder(ImageDecoder):
         if width <= 0  or info_header.biPlanes != 1:
             raise ImageDecodeException(
                 'BMP file has corrupt parameters: %r' % (filename or file))
-        pitch_sign = height < 0 and -1 or 1
+        pitch_sign = (height < 0 and -1) or 1
         height = abs(height)
 
         compression = info_header.biCompression
@@ -146,7 +147,7 @@ class BMPImageDecoder(ImageDecoder):
                 'Unsupported compression: %r' % (filename or file))
 
         clr_used = 0
-        bitcount = info_header.biBitCount 
+        bitcount = info_header.biBitCount
         if bitcount == 1:
             pitch = (width + 7) // 8
             bits_type = ctypes.c_ubyte
@@ -166,7 +167,7 @@ class BMPImageDecoder(ImageDecoder):
         elif bitcount == 24:
             pitch = width * 3
             bits_type = ctypes.c_ubyte
-            decoder = decode_24bit 
+            decoder = decode_24bit
         elif bitcount == 32:
             pitch = width * 4
             if compression == BI_RGB:
@@ -185,17 +186,17 @@ class BMPImageDecoder(ImageDecoder):
         pitch = (pitch + 3) & ~3
         packed_width = pitch // ctypes.sizeof(bits_type)
 
-        if bitcount < 16 and compression == BI_RGB: 
+        if bitcount < 16 and compression == BI_RGB:
             clr_used = info_header.biClrUsed or (1 <<  bitcount)
             palette = to_ctypes(buffer, palette_offset, RGBQUAD * clr_used)
-            bits = to_ctypes(buffer, bits_offset, 
+            bits = to_ctypes(buffer, bits_offset,
                              bits_type * packed_width * height)
             return decoder(bits, palette, width, height, pitch, pitch_sign)
-        elif bitcount >= 16 and compression == BI_RGB:
-            bits = to_ctypes(buffer, bits_offset, 
+        if bitcount >= 16 and compression == BI_RGB:
+            bits = to_ctypes(buffer, bits_offset,
                              bits_type * (packed_width * height))
             return decoder(bits, None, width, height, pitch, pitch_sign)
-        elif compression == BI_BITFIELDS:
+        if compression == BI_BITFIELDS:
             if info_header.biSize >= ctypes.sizeof(BITMAPV4HEADER):
                 info_header = to_ctypes(buffer, info_header_offset,
                                         BITMAPV4HEADER)
@@ -204,7 +205,7 @@ class BMPImageDecoder(ImageDecoder):
                 b_mask = info_header.bV4BlueMask
             else:
                 fields_offset = info_header_offset + \
-                    ctypes.sizeof(BITMAPINFOHEADER) 
+                    ctypes.sizeof(BITMAPINFOHEADER)
                 fields = to_ctypes(buffer, fields_offset, RGBFields)
                 r_mask = fields.red
                 g_mask = fields.green
@@ -215,46 +216,60 @@ class BMPImageDecoder(ImageDecoder):
                     ('data', bits_type * packed_width * height),
                 ]
             bits = to_ctypes(buffer, bits_offset, _BitsArray).data
-            return decoder(bits, r_mask, g_mask, b_mask, 
-                           width, height, pitch, pitch_sign)
+            return decoder(bits, r_mask, g_mask, b_mask, width, height, pitch, pitch_sign)
+        return None
+
 
 def decode_1bit(bits, palette, width, height, pitch, pitch_sign):
-    rgb_pitch = (((pitch << 3) + 7) & ~0x7) * 3
+    rgb_pitch = width * 3
     buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
     i = 0
     for row in bits:
+        pixel_count = 0
         for packed in row:
             for _ in range(8):
+                if pixel_count >= width:
+                    break
                 rgb = palette[(packed & 0x80) >> 7]
                 buffer[i] = rgb.rgbRed
                 buffer[i + 1] = rgb.rgbGreen
                 buffer[i + 2] = rgb.rgbBlue
                 i += 3
+                pixel_count += 1
                 packed <<= 1
 
     return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
 
 def decode_4bit(bits, palette, width, height, pitch, pitch_sign):
-    rgb_pitch = (((pitch << 1) + 1) & ~0x1) * 3
+    packed_row_bytes = (width + 1) // 2
+    rgb_pitch = width * 3
     buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
-    i = 0
+    i  = 0
     for row in bits:
-        for packed in row:
-            for index in ((packed & 0xf0) >> 4, packed & 0xf):
+        pixel_count = 0
+        for byte_i in range(packed_row_bytes):
+            packed = row[byte_i]
+            for index in ((packed & 0xF0) >> 4, packed & 0x0F):
+                if pixel_count >= width:
+                    break
                 rgb = palette[index]
                 buffer[i] = rgb.rgbRed
                 buffer[i + 1] = rgb.rgbGreen
                 buffer[i + 2] = rgb.rgbBlue
                 i += 3
+                pixel_count += 1
 
     return ImageData(width, height, 'RGB', buffer, pitch_sign * rgb_pitch)
 
+
 def decode_8bit(bits, palette, width, height, pitch, pitch_sign):
-    rgb_pitch = pitch * 3
+    rgb_pitch = width * 3
     buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
+
     i = 0
     for row in bits:
-        for index in row:
+        for x in range(width):
+            index = row[x]
             rgb = palette[index]
             buffer[i] = rgb.rgbRed
             buffer[i + 1] = rgb.rgbGreen
@@ -265,9 +280,18 @@ def decode_8bit(bits, palette, width, height, pitch, pitch_sign):
 
 
 def decode_24bit(bits, palette, width, height, pitch, pitch_sign):
-    buffer = (ctypes.c_ubyte * (height * pitch))()
-    ctypes.memmove(buffer, bits, len(buffer))
-    return ImageData(width, height, 'BGR', buffer, pitch_sign * pitch)
+    row_bytes = width * 3
+    buffer = (ctypes.c_ubyte * (height * row_bytes))()
+
+    src_base = ctypes.addressof(bits)
+    dst_base = ctypes.addressof(buffer)
+
+    for y in range(height):
+        src_row = src_base + y * pitch
+        dst_row = dst_base + y * row_bytes
+        ctypes.memmove(dst_row, src_row, row_bytes)
+
+    return ImageData(width, height, 'BGR', buffer, pitch_sign * row_bytes)
 
 def decode_32bit_rgb(bits, palette, width, height, pitch, pitch_sign):
     buffer = (ctypes.c_ubyte * (height * pitch))()
@@ -291,21 +315,20 @@ def get_shift(mask):
     s = shift - (8 - shift_up)
     if s < 0:
         return 0, -s
-    else:
-        return s, 0
+    return s, 0
 
-def decode_bitfields(bits, r_mask, g_mask, b_mask, 
-                     width, height, pitch, pitch_sign):
+def decode_bitfields(bits, r_mask, g_mask, b_mask, width, height, pitch, pitch_sign):
     r_shift1, r_shift2 = get_shift(r_mask)
     g_shift1, g_shift2 = get_shift(g_mask)
     b_shift1, b_shift2 = get_shift(b_mask)
 
-    rgb_pitch = 3 * len(bits[0])
+    rgb_pitch = width * 3
     buffer = (ctypes.c_ubyte * (height * rgb_pitch))()
 
     i = 0
     for row in bits:
-        for packed in row:
+        for x in range(width):
+            packed = row[x]
             buffer[i] = (packed & r_mask) >> r_shift1 << r_shift2
             buffer[i+1] = (packed & g_mask) >> g_shift1 << g_shift2
             buffer[i+2] = (packed & b_mask) >> b_shift1 << b_shift2

pyglet/image/codecs/dds.py

@@ -2,15 +2,15 @@
 
 Reference: http://msdn2.microsoft.com/en-us/library/bb172993.aspx
 """
+from __future__ import annotations
 
 import struct
 import itertools
+from typing import BinaryIO
 
-from pyglet.gl import *
-from pyglet.image import CompressedImageData
+from pyglet.image.base import CompressedImageData, CompressionFormat
 from pyglet.image import codecs
-from pyglet.image.codecs import s3tc, ImageDecodeException
-
+from pyglet.image.codecs import ImageDecodeException
 
 # dwFlags of DDSURFACEDESC2
 DDSD_CAPS           = 0x00000001
@@ -53,10 +53,10 @@ class _FileStruct:
         for field, value in itertools.zip_longest(self._fields, items, fillvalue=None):
             setattr(self, field[0], value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         name = self.__class__.__name__
-        return '%s(%s)' % (name, (', \n%s' % (' ' * (len(name) + 1))).join(
-            ['%s = %s' % (field[0], repr(getattr(self, field[0]))) for field in self._fields]))
+        return '{}({})'.format(name, (', \n%s' % (' ' * (len(name) + 1))).join(
+            [f'{field[0]} = {getattr(self, field[0])!r}' for field in self._fields]))
 
     @classmethod
     def get_format(cls):
@@ -82,13 +82,21 @@ class DDSURFACEDESC2(_FileStruct):
         ('dwCaps1', 'I'),
         ('dwCaps2', 'I'),
         ('dwCapsReserved', '8s'),
-        ('dwReserved2', 'I')
+        ('dwReserved2', 'I'),
     ]
 
     def __init__(self, data):
         super().__init__(data)
         self.ddpfPixelFormat = DDPIXELFORMAT(self.ddpfPixelFormat)
 
+class DDS_HEADER_DXT10(_FileStruct):
+    _fields = [
+        ('dxgiFormat', 'I'),
+        ('resourceDimension', 'I'),
+        ('miscFlag', 'I'),
+        ('arraySize', 'I'),
+        ('miscFlags2', 'I'),
+    ]
 
 class DDPIXELFORMAT(_FileStruct):
     _fields = [
@@ -99,25 +107,39 @@ class DDPIXELFORMAT(_FileStruct):
         ('dwRBitMask', 'I'),
         ('dwGBitMask', 'I'),
         ('dwBBitMask', 'I'),
-        ('dwRGBAlphaBitMask', 'I')
+        ('dwRGBAlphaBitMask', 'I'),
     ]
 
+def _get_dds_block_size_dxgi(dxgi_format: int) -> int:
+    if dxgi_format in (71, 72, 80, 81):  # BC1 = 8 bytes per 4x4 block
+        return 8
+    if dxgi_format in (74, 75, # BC2  = 16 bytes per 4x4 block
+                       77, 78, # BC3
+                       83, 84, # BC5
+                       95, 96,  # B6
+                       98, 99):  # BC7
+        return 16
+    msg = f"Unsupported DXGI format {dxgi_format}"
+    raise ImageDecodeException(msg)
 
-_compression_formats = {
-    (b'DXT1', False): (GL_COMPRESSED_RGB_S3TC_DXT1_EXT,  s3tc.decode_dxt1_rgb),
-    (b'DXT1', True):  (GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, s3tc.decode_dxt1_rgba),
-    (b'DXT3', False): (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, s3tc.decode_dxt3),
-    (b'DXT3', True):  (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, s3tc.decode_dxt3),
-    (b'DXT5', False): (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, s3tc.decode_dxt5),
-    (b'DXT5', True):  (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, s3tc.decode_dxt5),
-}
+
+def _get_dds_block_size(fourcc: bytes) -> int:
+    """Return block size in bytes based on the below formats."""
+    if fourcc in (b'DXT1', b'BC1 '):
+        return 8
+    if fourcc in (b'DXT3', b'DXT5', b'BC2 ', b'BC3 ', b'BC5 ', b'ATI2'):
+        return 16
+    if fourcc in (b'BC4 ', b'ATI1'):
+        return 8
+
+    return 0  # Not block compressed
 
 
 class DDSImageDecoder(codecs.ImageDecoder):
-    def get_file_extensions(self):
+    def get_file_extensions(self) -> list[str]:
         return ['.dds']
 
-    def decode(self, filename, file):
+    def decode(self, filename: str, file: BinaryIO | None = None):
         if not file:
             file = open(filename, 'rb')
 
@@ -147,19 +169,19 @@ class DDSImageDecoder(codecs.ImageDecoder):
 
         has_alpha = desc.ddpfPixelFormat.dwRGBAlphaBitMask != 0
 
-        selector = (desc.ddpfPixelFormat.dwFourCC, has_alpha)
-        if selector not in _compression_formats:
-            raise ImageDecodeException('Unsupported texture compression %s' % desc.ddpfPixelFormat.dwFourCC)
-
-        dformat, decoder = _compression_formats[selector]
-        if dformat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-            block_size = 8
+        fourcc = desc.ddpfPixelFormat.dwFourCC
+        if fourcc == b'DX10':
+            dx10_header_data = file.read(DDS_HEADER_DXT10.get_size())
+            dx10_header = DDS_HEADER_DXT10(dx10_header_data)
+            fmt = CompressionFormat(fourcc, has_alpha, dx10_header.dxgiFormat)
+            block_size = _get_dds_block_size_dxgi(dx10_header.dxgiFormat)
         else:
-            block_size = 16
+            block_size = _get_dds_block_size(fourcc)
+            fmt = CompressionFormat(fourcc, has_alpha)
 
         datas = []
         w, h = width, height
-        for i in range(mipmaps):
+        for _ in range(mipmaps):
             if not w and not h:
                 break
             if not w:
@@ -172,7 +194,7 @@ class DDSImageDecoder(codecs.ImageDecoder):
             w >>= 1
             h >>= 1
 
-        image = CompressedImageData(width, height, dformat, datas[0], 'GL_EXT_texture_compression_s3tc', decoder)
+        image = CompressedImageData(width, height, fmt, datas[0])
         level = 0
         for data in datas[1:]:
             level += 1
@@ -181,9 +203,9 @@ class DDSImageDecoder(codecs.ImageDecoder):
         return image
 
 
-def get_decoders():
+def get_decoders() -> list[DDSImageDecoder]:
     return [DDSImageDecoder()]
 
 
-def get_encoders():
+def get_encoders() -> list:
     return []

pyglet/image/codecs/gdiplus.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from ctypes import (
+    addressof,
     POINTER,
     Structure,
     c_buffer,
@@ -15,10 +18,14 @@ from ctypes import (
     create_string_buffer,
     memmove,
     windll,
+    byref,
+    c_int,
+    c_uint,
+    sizeof,
 )
 from ctypes.wintypes import BOOL, BYTE, INT, UINT, ULONG
 
-from pyglet.image import Animation, AnimationFrame, ImageData, byref, c_int, c_uint, sizeof
+from pyglet.image import Animation, AnimationFrame, ImageData
 from pyglet.image.codecs import ImageDecodeException, ImageDecoder
 from pyglet.libs.win32 import _kernel32 as kernel32
 from pyglet.libs.win32 import _ole32 as ole32
@@ -58,14 +65,14 @@ class GdiplusStartupInput(Structure):
         ('GdiplusVersion', c_uint32),
         ('DebugEventCallback', c_void_p),
         ('SuppressBackgroundThread', BOOL),
-        ('SuppressExternalCodecs', BOOL)
+        ('SuppressExternalCodecs', BOOL),
     ]
 
 
 class GdiplusStartupOutput(Structure):
     _fields = [
         ('NotificationHookProc', c_void_p),
-        ('NotificationUnhookProc', c_void_p)
+        ('NotificationUnhookProc', c_void_p),
     ]
 
 
@@ -76,7 +83,7 @@ class BitmapData(Structure):
         ('Stride', c_int),
         ('PixelFormat', c_int),
         ('Scan0', POINTER(c_byte)),
-        ('Reserved', POINTER(c_uint))
+        ('Reserved', POINTER(c_uint)),
     ]
 
 
@@ -85,7 +92,7 @@ class Rect(Structure):
         ('X', c_int),
         ('Y', c_int),
         ('Width', c_int),
-        ('Height', c_int)
+        ('Height', c_int),
     ]
 
 
@@ -94,7 +101,7 @@ class PropertyItem(Structure):
         ('id', c_uint),
         ('length', c_ulong),
         ('type', c_short),
-        ('value', c_void_p)
+        ('value', c_void_p),
     ]
 
 
@@ -221,9 +228,7 @@ class GDIPlusDecoder(ImageDecoder):
         fmt = 'BGRA'
         if pf == PixelFormat24bppRGB:
             fmt = 'BGR'
-        elif pf == PixelFormat32bppRGB:
-            pass
-        elif pf == PixelFormat32bppARGB:
+        elif pf == PixelFormat32bppRGB or pf == PixelFormat32bppARGB:
             pass
         elif pf in (PixelFormat16bppARGB1555, PixelFormat32bppPARGB,
                     PixelFormat64bppARGB, PixelFormat64bppPARGB):
@@ -240,15 +245,34 @@ class GDIPlusDecoder(ImageDecoder):
         rect.Height = height
         bitmap_data = BitmapData()
         gdiplus.GdipBitmapLockBits(bitmap, byref(rect), ImageLockModeRead, pf, byref(bitmap_data))
-        
+
         # Create buffer for RawImage
         buffer = create_string_buffer(bitmap_data.Stride * height)
-        memmove(buffer, bitmap_data.Scan0, len(buffer))
-        
+        if fmt == 'BGR':
+            stride = bitmap_data.Stride
+            components = len(fmt)
+            packed_row = width * components
+            src_stride = abs(stride)
+
+            src_addr = cast(bitmap_data.Scan0, c_void_p).value
+            src = (c_byte * (src_stride * height)).from_address(src_addr)
+
+            buf_address = addressof(buffer)
+            src_address = addressof(src)
+
+            for y in range(height):
+                src_y = y if stride < 0 else (height - 1 - y)
+                src_off = src_y * src_stride
+                dst_off = y * packed_row
+                memmove(buf_address + dst_off, src_address + src_off, packed_row)
+        else:
+            memmove(buffer, bitmap_data.Scan0, len(buffer))
+            packed_row = -bitmap_data.Stride
+
         # Unlock data
         gdiplus.GdipBitmapUnlockBits(bitmap, byref(bitmap_data))
 
-        return ImageData(width, height, fmt, buffer, -bitmap_data.Stride)
+        return ImageData(width, height, fmt, buffer, packed_row)
 
     def _delete_bitmap(self, bitmap):
         # Release image and stream
@@ -286,7 +310,7 @@ class GDIPlusDecoder(ImageDecoder):
         gdiplus.GdipGetPropertyItemSize(bitmap, prop_id, byref(prop_size))
 
         prop_buffer = c_buffer(prop_size.value)
-        prop_item = cast(prop_buffer, POINTER(PropertyItem)).contents 
+        prop_item = cast(prop_buffer, POINTER(PropertyItem)).contents
         gdiplus.GdipGetPropertyItem(bitmap, prop_id, prop_size.value, prop_buffer)
 
         n_delays = prop_item.length // sizeof(c_long)

pyglet/image/codecs/gdkpixbuf2.py

@@ -1,11 +1,9 @@
 from ctypes import *
 
-from pyglet.gl import *
 from pyglet.image import *
 from pyglet.image.codecs import *
 from pyglet.image.codecs import gif
 
-import pyglet.lib
 import pyglet.window
 
 gdk = pyglet.lib.load_library('gdk-x11-2.0')

pyglet/image/codecs/js_image.py

@@ -0,0 +1,99 @@
+import asyncio
+import base64
+import time
+
+from pyglet.image import ImageDecoder
+from pyglet.image import ImageData
+from pyglet.image.codecs import ImageDecodeException
+
+try:
+    import js
+    import pyodide.ffi
+except ImportError:
+    raise ImportError
+
+
+_image_canvas = js.document.createElement("canvas")
+_image_context = _image_canvas.getContext("2d", willReadFrequently=True)
+
+async def check_image_exists(url):
+    """Check if an image exists at the given URL."""
+    try:
+        response = await js.fetch(url, {"method": "HEAD"})  # HEAD request (faster than GET)
+        if response.ok:
+            print(f"Image exists: {url}")
+            return True
+        else:
+            print(f"Image does NOT exist: {url} (Status: {response.status})")
+            return False
+    except Exception as e:
+        print(f"Error checking image: {e}")
+        return False
+
+async def load_image_from_vfs(vfs_path):
+    # Read image from Pyodide's VFS
+    with open(vfs_path, "rb") as f:
+        img_data = f.read()
+
+    # Convert image to Base64
+    base64_data = base64.b64encode(img_data).decode("utf-8")
+
+    # Create a Data URL
+    mime_type = "image/png"  # Change this based on file type (e.g., "image/jpeg")
+    data_url = f"data:{mime_type};base64,{base64_data}"
+
+    # Use the Data URL as the image source
+    img = js.Image.new()
+    img.src = data_url
+
+    # Wait for image to load before returning
+    await pyodide.ffi.to_js(img.decode())
+
+    return img
+
+class JSImageDecoder(ImageDecoder):
+    def get_file_extensions(self):
+        return ['.png']
+
+    async def decode(self, filename, file) -> ImageData:
+        t = time.perf_counter()
+        #img = js.Image.new()
+        #img.src = filename
+
+        #await pyodide.ffi.to_js(img.decode())  # Wait for image to load
+        img = await load_image_from_vfs(filename)
+
+        _image_canvas.width = img.width
+        _image_canvas.height = img.height
+
+        # Clear previous image
+        _image_context.clearRect(0, 0, img.width, img.height)
+
+        # Draw to context
+        _image_context.translate(0, img.height)  # Move down
+        _image_context.scale(1, -1)  # Flip vertically
+        _image_context.drawImage(img, 0, 0)
+
+        image_data = _image_context.getImageData(0, 0, img.width, img.height)
+        pixel_data = image_data.data  # Uint8Array
+
+        print("Took", time.perf_counter() - t, "seconds")
+
+        return ImageData(img.width, img.height, 'RGBA', pixel_data)
+
+    def decode_animation(self, filename, file):
+        """Decode the given file object and return an instance of :py:class:`~pyglet.image.Animation`.
+        Throws ImageDecodeException if there is an error.  filename
+        can be a file type hint.
+        """
+        raise ImageDecodeException('This decoder cannot decode animations.')
+
+    def __repr__(self) -> str:
+        return "{}{}".format(self.__class__.__name__,
+                               self.get_animation_file_extensions() +
+                               self.get_file_extensions())
+def get_decoders():
+    return [JSImageDecoder()]
+
+def get_encoders():
+    return []