├── requirements.txt
├── README.md
├── ktx.py
└── dumpsc.py


/requirements.txt:
--------------------------------------------------------------------------------
1 | Pillow
2 | pylzham
3 | zstandard
4 | pyliblzfse
5 | texture2ddecoder
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Dumpsc
 2 | **Dumpsc** is an adapted version of [cr-sc-dump](https://github.com/123456abcdef/cr-sc-dump). This version aim to support all kind of **_tex.sc** files from different Supercell games.
 3 | 
 4 | 
 5 | 
 6 | ## Usage
 7 | 
 8 | If your file is compressed run the following command:
 9 | 
10 | > python dumpsc.py <your_tex_sc_file> -d
11 | 
12 | else simply use:
13 | 
14 | > python dumpsc.py <your_tex_sc_file>
15 | 
16 | 
17 | 
18 | ## Dependencies
19 | 
20 | To install **Dumpsc** dependencies run the following command:
21 | 
22 | > python -m pip install -r requirements.txt
23 | 


--------------------------------------------------------------------------------
/ktx.py:
--------------------------------------------------------------------------------
 1 | import struct
 2 | import liblzfse
 3 | 
 4 | from PIL import Image
 5 | from texture2ddecoder import decode_astc
 6 | 
 7 | 
 8 | def load_ktx(data):
 9 |     header = data[:64]
10 |     ktx_data = data[64:]
11 | 
12 |     if header[12:16] == bytes.fromhex('01020304'):
13 |         endianness = '<'
14 | 
15 |     else:
16 |         endianness = '>'
17 | 
18 |     if header[0:7] != b'\xabKTX 11':
19 |         raise TypeError('Unsupported or unknown KTX version: {}'.format(header[0:7]))
20 | 
21 |     glInternalFormat, = struct.unpack(endianness + 'I', header[28:32])
22 |     pixelWidth, pixelHeight = struct.unpack(endianness + '2I', header[36:44])
23 |     bytesOfKeyValueData, = struct.unpack(endianness + 'I', header[60:64])
24 | 
25 |     if glInternalFormat not in (0x93B0, 0x93B4, 0x93B7):
26 |         raise TypeError('Unsupported texture format: {}'.format(hex(glInternalFormat)))
27 | 
28 |     if glInternalFormat == 0x93B0:
29 |         block_width, block_height = 4, 4
30 | 
31 |     elif glInternalFormat == 0x93B4:
32 |         block_width, block_height = 6, 6
33 | 
34 |     else:
35 |         block_width, block_height = 8, 8
36 | 
37 |     key_value_data = ktx_data[:bytesOfKeyValueData]
38 |     ktx_data = ktx_data[bytesOfKeyValueData:]
39 | 
40 |     if b'Compression_APPLE' in key_value_data:
41 |         if ktx_data[12:15] == b'bvx':
42 |             image_data = liblzfse.decompress(ktx_data[12:])
43 | 
44 |         else:
45 |             raise ValueError('Unsupported compression type: {}'.format(
46 |                 ktx_data[12:15])
47 |             )
48 | 
49 |     else:
50 |         image_data = ktx_data[4:]
51 | 
52 |     decoded_data = decode_astc(image_data, pixelWidth, pixelHeight, block_width, block_height)
53 |     return Image.frombytes('RGBA', (pixelWidth, pixelHeight), decoded_data, 'raw', ('BGRA'))
54 | 


--------------------------------------------------------------------------------
/dumpsc.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import lzma
  3 | import lzham
  4 | import struct
  5 | import argparse
  6 | import zstandard
  7 | 
  8 | from PIL import Image
  9 | from texture2ddecoder import decode_astc
 10 | 
 11 | from ktx import load_ktx
 12 | 
 13 | 
 14 | def convert_pixel(pixel, type):
 15 |     if type == 0 or type == 1:
 16 |         # RGB8888
 17 |         return struct.unpack('4B', pixel)
 18 |     elif type == 2:
 19 |         # RGB4444
 20 |         pixel, = struct.unpack('<H', pixel)
 21 |         return (((pixel >> 12) & 0xF) << 4, ((pixel >> 8) & 0xF) << 4,
 22 |                 ((pixel >> 4) & 0xF) << 4, ((pixel >> 0) & 0xF) << 4)
 23 |     elif type == 3:
 24 |         # RBGA5551
 25 |         pixel, = struct.unpack('<H', pixel)
 26 |         return (((pixel >> 11) & 0x1F) << 3, ((pixel >> 6) & 0x1F) << 3,
 27 |                 ((pixel >> 1) & 0x1F) << 3, ((pixel) & 0xFF) << 7)
 28 |     elif type == 4:
 29 |         # RGB565
 30 |         pixel, = struct.unpack("<H", pixel)
 31 |         return (((pixel >> 11) & 0x1F) << 3, ((pixel >> 5) & 0x3F) << 2, (pixel & 0x1F) << 3)
 32 |     elif type == 6:
 33 |         # LA88 = Luminance Alpha 88
 34 |         pixel, = struct.unpack("<H", pixel)
 35 |         return (pixel >> 8), (pixel >> 8), (pixel >> 8), (pixel & 0xFF)
 36 |     elif type == 10:
 37 |         # L8 = Luminance8
 38 |         pixel, = struct.unpack("<B", pixel)
 39 |         return pixel, pixel, pixel
 40 |     elif type == 15:
 41 |         raise NotImplementedError("Pixel type 15 is not supported")
 42 |     else:
 43 |         raise Exception("Unknown pixel type {}.".format(type))
 44 | 
 45 | 
 46 | def read_sctx_texture(sctx_data):
 47 |     i=0
 48 |     streaming_texture_length, = struct.unpack('<I', sctx_data[i:i+4])
 49 | 
 50 |     # Read streaming texture data
 51 |     streaming_texture_header_length, = struct.unpack('<I', sctx_data[i+4:i+8])
 52 |     i += streaming_texture_header_length + 8
 53 | 
 54 |     pixel_type, = struct.unpack('<I', sctx_data[i:i+4])
 55 |     i = streaming_texture_length + 32
 56 | 
 57 |     # Read texture data
 58 |     texture_width, = struct.unpack('<H', sctx_data[i:i+2])
 59 |     texture_height, = struct.unpack('<H', sctx_data[i+2:i+4])
 60 | 
 61 |     hash_length, = struct.unpack('<I', sctx_data[i+8:i+12])
 62 |     i += hash_length + 12
 63 | 
 64 |     texture_data = sctx_data[i:]
 65 | 
 66 |     if texture_data.startswith(bytes.fromhex('28 B5 2F FD')):
 67 |         texture_data = zstandard.decompress(texture_data)
 68 | 
 69 |         if pixel_type == 0x46:
 70 |             img = Image.frombytes('RGBA', (texture_width, texture_height), texture_data, 'raw', ('RGBA'))
 71 | 
 72 |         elif pixel_type == 0xD4:
 73 |             astc_decompressed_data =  decode_astc(texture_data, texture_width, texture_height, 8, 8)
 74 |             img = Image.frombytes('RGBA', (texture_width, texture_height), astc_decompressed_data, 'raw', ('BGRA'))
 75 | 
 76 |         else:
 77 |             raise ValueError("Invalid pixel format {} in external texture".format(pixel_type))
 78 | 
 79 |     else:
 80 |         raise ValueError("Encountered non zstandard compressed sctx texture !")
 81 | 
 82 |     return img
 83 | 
 84 | 
 85 | def process_sc(texturePath, baseName, data, path, decompress):
 86 |     if decompress:
 87 |         version = None
 88 | 
 89 |         if data[:2] == b'SC':
 90 |             # Skip the header if there's any
 91 |             pre_version = int.from_bytes(data[2: 6], 'big')
 92 | 
 93 |             if pre_version == 4:
 94 |                 version = int.from_bytes(data[6: 10], 'big')
 95 |                 hash_length = int.from_bytes(data[10: 14], 'big')
 96 |                 end_block_size = int.from_bytes(data[-4:], 'big')
 97 | 
 98 |                 if version == 3:
 99 |                     # skip the end block size and the 'START' tag
100 |                     data = data[14 + hash_length:-end_block_size - 9]
101 | 
102 |                 else:
103 |                     # version != 3 does not have a 'START' tag
104 |                     data = data[14 + hash_length:-end_block_size - 4]
105 | 
106 |             else:
107 |                 version = pre_version
108 |                 hash_length = int.from_bytes(data[6: 10], 'big')
109 |                 data = data[10 + hash_length:]
110 | 
111 |         if version in (None, 1, 3):
112 |             try:
113 |                 if data[:4] == b'SCLZ':
114 |                     print('[*] Detected LZHAM compression !')
115 | 
116 |                     dict_size = int.from_bytes(data[4:5], 'big')
117 |                     uncompressed_size = int.from_bytes(data[5:9], 'little')
118 |                     decompressed = lzham.decompress(data[9:], uncompressed_size, {'dict_size_log2': dict_size})
119 | 
120 |                 elif data[:4] == bytes.fromhex('28 B5 2F FD'):
121 |                     print('[*] Detected Zstandard compression !')
122 |                     decompressed = zstandard.decompress(data)
123 | 
124 |                 else:
125 |                     print('[*] Detected LZMA compression !')
126 |                     data = data[0:9] + (b'\x00' * 4) + data[9:]
127 |                     decompressor = lzma.LZMADecompressor()
128 | 
129 |                     output = []
130 | 
131 |                     while decompressor.needs_input:
132 |                         output.append(decompressor.decompress(data))
133 | 
134 |                     decompressed = b''.join(output)
135 | 
136 |             except Exception as _:
137 |                 print('Cannot decompress {} !'.format(baseName))
138 |                 return
139 | 
140 |         else:
141 |             decompressed = data
142 | 
143 |     else:
144 |         decompressed = data
145 | 
146 |     i = 0
147 |     picCount = 0
148 |     while len(decompressed[i:]) > 5:
149 |         fileType, = struct.unpack('<b', bytes([decompressed[i]]))
150 | 
151 |         if fileType == 0x2D:
152 |             i += 4  # Ignore this uint32, it's basically the fileSize + the size of subType + width + height (9 bytes)
153 | 
154 |         fileSize, = struct.unpack('<I', decompressed[i + 1:i + 5])
155 |         i += 5
156 | 
157 |         if fileType == 0x2F:
158 |             external_texture_path = decompressed[i + 1: i + 1 + decompressed[i]].decode('utf-8')
159 |             i += decompressed[i] + 1
160 | 
161 |         subType, = struct.unpack('<b', bytes([decompressed[i]]))
162 |         width, = struct.unpack('<H', decompressed[i + 1:i + 3])
163 |         height, = struct.unpack('<H', decompressed[i + 3:i + 5])
164 |         i += 5
165 | 
166 |         print('fileType: {}, fileSize: {}, subType: {}, width: {}, '
167 |               'height: {}'.format(fileType, fileSize, subType, width, height))
168 | 
169 |         if fileType != 0x2D and fileType != 0x2F:
170 |             if subType in (0, 1):
171 |                 pixelSize = 4
172 |             elif subType in (2, 3, 4, 6):
173 |                 pixelSize = 2
174 |             elif subType == 10:
175 |                 pixelSize = 1
176 |             elif subType != 15:
177 |                 raise Exception("Unknown pixel type {}.".format(subType))
178 | 
179 |             if subType == 15:
180 |                 ktx_size, = struct.unpack('<I', decompressed[i:i + 4])
181 |                 img = load_ktx(decompressed[i + 4: i + 4 + ktx_size])
182 |                 i += 4 + ktx_size
183 | 
184 |             else:
185 |                 img = Image.new("RGBA", (width, height))
186 |                 pixels = []
187 | 
188 |                 for y in range(height):
189 |                     for x in range(width):
190 |                         pixels.append(convert_pixel(decompressed[i:i + pixelSize], subType))
191 |                         i += pixelSize
192 | 
193 |                 img.putdata(pixels)
194 | 
195 |             if fileType == 29 or fileType == 28 or fileType == 27:
196 |                 imgl = img.load()
197 |                 iSrcPix = 0
198 | 
199 |                 for l in range(height // 32):  # block of 32 lines
200 |                     # normal 32-pixels blocks
201 |                     for k in range(width // 32):  # 32-pixels blocks in a line
202 |                         for j in range(32):  # line in a multi line block
203 |                             for h in range(32):  # pixels in a block
204 |                                 imgl[h + (k * 32), j + (l * 32)] = pixels[iSrcPix]
205 |                                 iSrcPix += 1
206 |                     # line end blocks
207 |                     for j in range(32):
208 |                         for h in range(width % 32):
209 |                             imgl[h + (width - (width % 32)), j + (l * 32)] = pixels[iSrcPix]
210 |                             iSrcPix += 1
211 |                 # final lines
212 |                 for k in range(width // 32):  # 32-pixels blocks in a line
213 |                     for j in range(height % 32):  # line in a multi line block
214 |                         for h in range(32):  # pixels in a 32-pixels-block
215 |                             imgl[h + (k * 32), j + (height - (height % 32))] = pixels[iSrcPix]
216 |                             iSrcPix += 1
217 |                 # line end blocks
218 |                 for j in range(height % 32):
219 |                     for h in range(width % 32):
220 |                         imgl[h + (width - (width % 32)), j + (height - (height % 32))] = pixels[iSrcPix]
221 |                         iSrcPix += 1
222 | 
223 |         elif fileType == 0x2F:
224 |             external_texture_path = os.path.join(texturePath, external_texture_path)
225 | 
226 |             if os.path.isfile(external_texture_path):
227 |                 with open(external_texture_path, 'rb') as f:
228 |                     external_texture_data = f.read()
229 | 
230 |                 if external_texture_path.endswith('.zktx'):
231 |                     img = load_ktx(zstandard.decompress(external_texture_data))
232 | 
233 |                 elif external_texture_path.endswith('.sctx'):
234 |                     img = read_sctx_texture(external_texture_data)
235 | 
236 |                 else:
237 |                     raise Exception('External texture {} has an unknown format !'.format(external_texture_path))
238 | 
239 |             else:
240 |                 raise Exception('External texture {} cannot be found !'.format(external_texture_path))
241 | 
242 |         else:
243 |             img = load_ktx(decompressed[i:i + fileSize])
244 |             i += fileSize
245 | 
246 |         img.save(path + baseName + ('_' * picCount) + '.png', 'PNG')
247 |         picCount += 1
248 | 
249 | 
250 | if __name__ == "__main__":
251 |     parser = argparse.ArgumentParser(description='Extract png files from Supercell "*_tex.sc" files')
252 |     parser.add_argument('files', help='sc file', nargs='+')
253 |     parser.add_argument('-o', help='Extract pngs to directory', type=str)
254 |     parser.add_argument('-d', '--decompress', help='Try to decompress _tex.sc before processing it', action='store_true')
255 | 
256 |     args = parser.parse_args()
257 | 
258 |     if args.o:
259 |         path = os.path.normpath(args.o) + '/'
260 | 
261 |     else:
262 |         path = os.path.dirname(os.path.realpath(__file__)) + '/'
263 | 
264 |     for file in args.files:
265 |         if file.endswith('tex.sc'):
266 |             basename, _ = os.path.splitext(os.path.basename(file))
267 |             texturePath = os.path.dirname(file)
268 | 
269 |             with open(file, 'rb') as f:
270 |                 print('[*] Processing {}'.format(f.name))
271 |                 process_sc(texturePath, basename, f.read(), path, args.decompress)
272 | 
273 |         else:
274 |             print('[*] Only tex.sc are supported !')
275 | 


--------------------------------------------------------------------------------