Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/PIL/DdsImagePlugin.py: 81%

1"""

2A Pillow plugin for .dds files (S3TC-compressed aka DXTC)

3Jerome Leclanche <jerome@leclan.ch>

5Documentation:

6https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt

8The contents of this file are hereby released in the public domain (CC0)

9Full text of the CC0 license:

10https://creativecommons.org/publicdomain/zero/1.0/

11"""

13from __future__ import annotations

15import io

16import struct

17import sys

18from enum import IntEnum, IntFlag

19from typing import IO

21from . import Image, ImageFile, ImagePalette

22from ._binary import i32le as i32

23from ._binary import o8

24from ._binary import o32le as o32

26# Magic ("DDS ")

27DDS_MAGIC = 0x20534444

30# DDS flags

31class DDSD(IntFlag):

32 CAPS = 0x1

33 HEIGHT = 0x2

34 WIDTH = 0x4

35 PITCH = 0x8

36 PIXELFORMAT = 0x1000

37 MIPMAPCOUNT = 0x20000

38 LINEARSIZE = 0x80000

39 DEPTH = 0x800000

42# DDS caps

43class DDSCAPS(IntFlag):

44 COMPLEX = 0x8

45 TEXTURE = 0x1000

46 MIPMAP = 0x400000

49class DDSCAPS2(IntFlag):

50 CUBEMAP = 0x200

51 CUBEMAP_POSITIVEX = 0x400

52 CUBEMAP_NEGATIVEX = 0x800

53 CUBEMAP_POSITIVEY = 0x1000

54 CUBEMAP_NEGATIVEY = 0x2000

55 CUBEMAP_POSITIVEZ = 0x4000

56 CUBEMAP_NEGATIVEZ = 0x8000

57 VOLUME = 0x200000

60# Pixel Format

61class DDPF(IntFlag):

62 ALPHAPIXELS = 0x1

63 ALPHA = 0x2

64 FOURCC = 0x4

65 PALETTEINDEXED8 = 0x20

66 RGB = 0x40

67 LUMINANCE = 0x20000

70# dxgiformat.h

71class DXGI_FORMAT(IntEnum):

72 UNKNOWN = 0

73 R32G32B32A32_TYPELESS = 1

74 R32G32B32A32_FLOAT = 2

75 R32G32B32A32_UINT = 3

76 R32G32B32A32_SINT = 4

77 R32G32B32_TYPELESS = 5

78 R32G32B32_FLOAT = 6

79 R32G32B32_UINT = 7

80 R32G32B32_SINT = 8

81 R16G16B16A16_TYPELESS = 9

82 R16G16B16A16_FLOAT = 10

83 R16G16B16A16_UNORM = 11

84 R16G16B16A16_UINT = 12

85 R16G16B16A16_SNORM = 13

86 R16G16B16A16_SINT = 14

87 R32G32_TYPELESS = 15

88 R32G32_FLOAT = 16

89 R32G32_UINT = 17

90 R32G32_SINT = 18

91 R32G8X24_TYPELESS = 19

92 D32_FLOAT_S8X24_UINT = 20

93 R32_FLOAT_X8X24_TYPELESS = 21

94 X32_TYPELESS_G8X24_UINT = 22

95 R10G10B10A2_TYPELESS = 23

96 R10G10B10A2_UNORM = 24

97 R10G10B10A2_UINT = 25

98 R11G11B10_FLOAT = 26

99 R8G8B8A8_TYPELESS = 27

100 R8G8B8A8_UNORM = 28

101 R8G8B8A8_UNORM_SRGB = 29

102 R8G8B8A8_UINT = 30

103 R8G8B8A8_SNORM = 31

104 R8G8B8A8_SINT = 32

105 R16G16_TYPELESS = 33

106 R16G16_FLOAT = 34

107 R16G16_UNORM = 35

108 R16G16_UINT = 36

109 R16G16_SNORM = 37

110 R16G16_SINT = 38

111 R32_TYPELESS = 39

112 D32_FLOAT = 40

113 R32_FLOAT = 41

114 R32_UINT = 42

115 R32_SINT = 43

116 R24G8_TYPELESS = 44

117 D24_UNORM_S8_UINT = 45

118 R24_UNORM_X8_TYPELESS = 46

119 X24_TYPELESS_G8_UINT = 47

120 R8G8_TYPELESS = 48

121 R8G8_UNORM = 49

122 R8G8_UINT = 50

123 R8G8_SNORM = 51

124 R8G8_SINT = 52

125 R16_TYPELESS = 53

126 R16_FLOAT = 54

127 D16_UNORM = 55

128 R16_UNORM = 56

129 R16_UINT = 57

130 R16_SNORM = 58

131 R16_SINT = 59

132 R8_TYPELESS = 60

133 R8_UNORM = 61

134 R8_UINT = 62

135 R8_SNORM = 63

136 R8_SINT = 64

137 A8_UNORM = 65

138 R1_UNORM = 66

139 R9G9B9E5_SHAREDEXP = 67

140 R8G8_B8G8_UNORM = 68

141 G8R8_G8B8_UNORM = 69

142 BC1_TYPELESS = 70

143 BC1_UNORM = 71

144 BC1_UNORM_SRGB = 72

145 BC2_TYPELESS = 73

146 BC2_UNORM = 74

147 BC2_UNORM_SRGB = 75

148 BC3_TYPELESS = 76

149 BC3_UNORM = 77

150 BC3_UNORM_SRGB = 78

151 BC4_TYPELESS = 79

152 BC4_UNORM = 80

153 BC4_SNORM = 81

154 BC5_TYPELESS = 82

155 BC5_UNORM = 83

156 BC5_SNORM = 84

157 B5G6R5_UNORM = 85

158 B5G5R5A1_UNORM = 86

159 B8G8R8A8_UNORM = 87

160 B8G8R8X8_UNORM = 88

161 R10G10B10_XR_BIAS_A2_UNORM = 89

162 B8G8R8A8_TYPELESS = 90

163 B8G8R8A8_UNORM_SRGB = 91

164 B8G8R8X8_TYPELESS = 92

165 B8G8R8X8_UNORM_SRGB = 93

166 BC6H_TYPELESS = 94

167 BC6H_UF16 = 95

168 BC6H_SF16 = 96

169 BC7_TYPELESS = 97

170 BC7_UNORM = 98

171 BC7_UNORM_SRGB = 99

172 AYUV = 100

173 Y410 = 101

174 Y416 = 102

175 NV12 = 103

176 P010 = 104

177 P016 = 105

178 OPAQUE_420 = 106

179 YUY2 = 107

180 Y210 = 108

181 Y216 = 109

182 NV11 = 110

183 AI44 = 111

184 IA44 = 112

185 P8 = 113

186 A8P8 = 114

187 B4G4R4A4_UNORM = 115

188 P208 = 130

189 V208 = 131

190 V408 = 132

191 SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189

192 SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190

193

194

195class D3DFMT(IntEnum):

196 UNKNOWN = 0

197 R8G8B8 = 20

198 A8R8G8B8 = 21

199 X8R8G8B8 = 22

200 R5G6B5 = 23

201 X1R5G5B5 = 24

202 A1R5G5B5 = 25

203 A4R4G4B4 = 26

204 R3G3B2 = 27

205 A8 = 28

206 A8R3G3B2 = 29

207 X4R4G4B4 = 30

208 A2B10G10R10 = 31

209 A8B8G8R8 = 32

210 X8B8G8R8 = 33

211 G16R16 = 34

212 A2R10G10B10 = 35

213 A16B16G16R16 = 36

214 A8P8 = 40

215 P8 = 41

216 L8 = 50

217 A8L8 = 51

218 A4L4 = 52

219 V8U8 = 60

220 L6V5U5 = 61

221 X8L8V8U8 = 62

222 Q8W8V8U8 = 63

223 V16U16 = 64

224 A2W10V10U10 = 67

225 D16_LOCKABLE = 70

226 D32 = 71

227 D15S1 = 73

228 D24S8 = 75

229 D24X8 = 77

230 D24X4S4 = 79

231 D16 = 80

232 D32F_LOCKABLE = 82

233 D24FS8 = 83

234 D32_LOCKABLE = 84

235 S8_LOCKABLE = 85

236 L16 = 81

237 VERTEXDATA = 100

238 INDEX16 = 101

239 INDEX32 = 102

240 Q16W16V16U16 = 110

241 R16F = 111

242 G16R16F = 112

243 A16B16G16R16F = 113

244 R32F = 114

245 G32R32F = 115

246 A32B32G32R32F = 116

247 CxV8U8 = 117

248 A1 = 118

249 A2B10G10R10_XR_BIAS = 119

250 BINARYBUFFER = 199

251

252 UYVY = i32(b"UYVY")

253 R8G8_B8G8 = i32(b"RGBG")

254 YUY2 = i32(b"YUY2")

255 G8R8_G8B8 = i32(b"GRGB")

256 DXT1 = i32(b"DXT1")

257 DXT2 = i32(b"DXT2")

258 DXT3 = i32(b"DXT3")

259 DXT4 = i32(b"DXT4")

260 DXT5 = i32(b"DXT5")

261 DX10 = i32(b"DX10")

262 BC4S = i32(b"BC4S")

263 BC4U = i32(b"BC4U")

264 BC5S = i32(b"BC5S")

265 BC5U = i32(b"BC5U")

266 ATI1 = i32(b"ATI1")

267 ATI2 = i32(b"ATI2")

268 MULTI2_ARGB8 = i32(b"MET1")

269

270

271# Backward compatibility layer

272module = sys.modules[__name__]

273for item in DDSD:

274 assert item.name is not None

275 setattr(module, f"DDSD_{item.name}", item.value)

276for item1 in DDSCAPS:

277 assert item1.name is not None

278 setattr(module, f"DDSCAPS_{item1.name}", item1.value)

279for item2 in DDSCAPS2:

280 assert item2.name is not None

281 setattr(module, f"DDSCAPS2_{item2.name}", item2.value)

282for item3 in DDPF:

283 assert item3.name is not None

284 setattr(module, f"DDPF_{item3.name}", item3.value)

285

286DDS_FOURCC = DDPF.FOURCC

287DDS_RGB = DDPF.RGB

288DDS_RGBA = DDPF.RGB | DDPF.ALPHAPIXELS

289DDS_LUMINANCE = DDPF.LUMINANCE

290DDS_LUMINANCEA = DDPF.LUMINANCE | DDPF.ALPHAPIXELS

291DDS_ALPHA = DDPF.ALPHA

292DDS_PAL8 = DDPF.PALETTEINDEXED8

293

294DDS_HEADER_FLAGS_TEXTURE = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT

295DDS_HEADER_FLAGS_MIPMAP = DDSD.MIPMAPCOUNT

296DDS_HEADER_FLAGS_VOLUME = DDSD.DEPTH

297DDS_HEADER_FLAGS_PITCH = DDSD.PITCH

298DDS_HEADER_FLAGS_LINEARSIZE = DDSD.LINEARSIZE

299

300DDS_HEIGHT = DDSD.HEIGHT

301DDS_WIDTH = DDSD.WIDTH

302

303DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS.TEXTURE

304DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS.COMPLEX | DDSCAPS.MIPMAP

305DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS.COMPLEX

306

307DDS_CUBEMAP_POSITIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEX

308DDS_CUBEMAP_NEGATIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEX

309DDS_CUBEMAP_POSITIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEY

310DDS_CUBEMAP_NEGATIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEY

311DDS_CUBEMAP_POSITIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEZ

312DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEZ

313

314DXT1_FOURCC = D3DFMT.DXT1

315DXT3_FOURCC = D3DFMT.DXT3

316DXT5_FOURCC = D3DFMT.DXT5

317

318DXGI_FORMAT_R8G8B8A8_TYPELESS = DXGI_FORMAT.R8G8B8A8_TYPELESS

319DXGI_FORMAT_R8G8B8A8_UNORM = DXGI_FORMAT.R8G8B8A8_UNORM

320DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = DXGI_FORMAT.R8G8B8A8_UNORM_SRGB

321DXGI_FORMAT_BC5_TYPELESS = DXGI_FORMAT.BC5_TYPELESS

322DXGI_FORMAT_BC5_UNORM = DXGI_FORMAT.BC5_UNORM

323DXGI_FORMAT_BC5_SNORM = DXGI_FORMAT.BC5_SNORM

324DXGI_FORMAT_BC6H_UF16 = DXGI_FORMAT.BC6H_UF16

325DXGI_FORMAT_BC6H_SF16 = DXGI_FORMAT.BC6H_SF16

326DXGI_FORMAT_BC7_TYPELESS = DXGI_FORMAT.BC7_TYPELESS

327DXGI_FORMAT_BC7_UNORM = DXGI_FORMAT.BC7_UNORM

328DXGI_FORMAT_BC7_UNORM_SRGB = DXGI_FORMAT.BC7_UNORM_SRGB

329

330

331class DdsImageFile(ImageFile.ImageFile):

332 format = "DDS"

333 format_description = "DirectDraw Surface"

334

335 def _open(self) -> None:

336 if not _accept(self.fp.read(4)):

337 msg = "not a DDS file"

338 raise SyntaxError(msg)

339 (header_size,) = struct.unpack("<I", self.fp.read(4))

340 if header_size != 124:

341 msg = f"Unsupported header size {repr(header_size)}"

342 raise OSError(msg)

343 header_bytes = self.fp.read(header_size - 4)

344 if len(header_bytes) != 120:

345 msg = f"Incomplete header: {len(header_bytes)} bytes"

346 raise OSError(msg)

347 header = io.BytesIO(header_bytes)

348

349 flags, height, width = struct.unpack("<3I", header.read(12))

350 self._size = (width, height)

351 extents = (0, 0) + self.size

352

353 pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))

354 struct.unpack("<11I", header.read(44)) # reserved

355

356 # pixel format

357 pfsize, pfflags, fourcc, bitcount = struct.unpack("<4I", header.read(16))

358 n = 0

359 rawmode = None

360 if pfflags & DDPF.RGB:

361 # Texture contains uncompressed RGB data

362 if pfflags & DDPF.ALPHAPIXELS:

363 self._mode = "RGBA"

364 mask_count = 4

365 else:

366 self._mode = "RGB"

367 mask_count = 3

368

369 masks = struct.unpack(f"<{mask_count}I", header.read(mask_count * 4))

370 self.tile = [ImageFile._Tile("dds_rgb", extents, 0, (bitcount, masks))]

371 return

372 elif pfflags & DDPF.LUMINANCE:

373 if bitcount == 8:

374 self._mode = "L"

375 elif bitcount == 16 and pfflags & DDPF.ALPHAPIXELS:

376 self._mode = "LA"

377 else:

378 msg = f"Unsupported bitcount {bitcount} for {pfflags}"

379 raise OSError(msg)

380 elif pfflags & DDPF.PALETTEINDEXED8:

381 self._mode = "P"

382 self.palette = ImagePalette.raw("RGBA", self.fp.read(1024))

383 self.palette.mode = "RGBA"

384 elif pfflags & DDPF.FOURCC:

385 offset = header_size + 4

386 if fourcc == D3DFMT.DXT1:

387 self._mode = "RGBA"

388 self.pixel_format = "DXT1"

389 n = 1

390 elif fourcc == D3DFMT.DXT3:

391 self._mode = "RGBA"

392 self.pixel_format = "DXT3"

393 n = 2

394 elif fourcc == D3DFMT.DXT5:

395 self._mode = "RGBA"

396 self.pixel_format = "DXT5"

397 n = 3

398 elif fourcc in (D3DFMT.BC4U, D3DFMT.ATI1):

399 self._mode = "L"

400 self.pixel_format = "BC4"

401 n = 4

402 elif fourcc == D3DFMT.BC5S:

403 self._mode = "RGB"

404 self.pixel_format = "BC5S"

405 n = 5

406 elif fourcc in (D3DFMT.BC5U, D3DFMT.ATI2):

407 self._mode = "RGB"

408 self.pixel_format = "BC5"

409 n = 5

410 elif fourcc == D3DFMT.DX10:

411 offset += 20

412 # ignoring flags which pertain to volume textures and cubemaps

413 (dxgi_format,) = struct.unpack("<I", self.fp.read(4))

414 self.fp.read(16)

415 if dxgi_format in (

416 DXGI_FORMAT.BC1_UNORM,

417 DXGI_FORMAT.BC1_TYPELESS,

418 ):

419 self._mode = "RGBA"

420 self.pixel_format = "BC1"

421 n = 1

422 elif dxgi_format in (DXGI_FORMAT.BC2_TYPELESS, DXGI_FORMAT.BC2_UNORM):

423 self._mode = "RGBA"

424 self.pixel_format = "BC2"

425 n = 2

426 elif dxgi_format in (DXGI_FORMAT.BC3_TYPELESS, DXGI_FORMAT.BC3_UNORM):

427 self._mode = "RGBA"

428 self.pixel_format = "BC3"

429 n = 3

430 elif dxgi_format in (DXGI_FORMAT.BC4_TYPELESS, DXGI_FORMAT.BC4_UNORM):

431 self._mode = "L"

432 self.pixel_format = "BC4"

433 n = 4

434 elif dxgi_format in (DXGI_FORMAT.BC5_TYPELESS, DXGI_FORMAT.BC5_UNORM):

435 self._mode = "RGB"

436 self.pixel_format = "BC5"

437 n = 5

438 elif dxgi_format == DXGI_FORMAT.BC5_SNORM:

439 self._mode = "RGB"

440 self.pixel_format = "BC5S"

441 n = 5

442 elif dxgi_format == DXGI_FORMAT.BC6H_UF16:

443 self._mode = "RGB"

444 self.pixel_format = "BC6H"

445 n = 6

446 elif dxgi_format == DXGI_FORMAT.BC6H_SF16:

447 self._mode = "RGB"

448 self.pixel_format = "BC6HS"

449 n = 6

450 elif dxgi_format in (

451 DXGI_FORMAT.BC7_TYPELESS,

452 DXGI_FORMAT.BC7_UNORM,

453 DXGI_FORMAT.BC7_UNORM_SRGB,

454 ):

455 self._mode = "RGBA"

456 self.pixel_format = "BC7"

457 n = 7

458 if dxgi_format == DXGI_FORMAT.BC7_UNORM_SRGB:

459 self.info["gamma"] = 1 / 2.2

460 elif dxgi_format in (

461 DXGI_FORMAT.R8G8B8A8_TYPELESS,

462 DXGI_FORMAT.R8G8B8A8_UNORM,

463 DXGI_FORMAT.R8G8B8A8_UNORM_SRGB,

464 ):

465 self._mode = "RGBA"

466 if dxgi_format == DXGI_FORMAT.R8G8B8A8_UNORM_SRGB:

467 self.info["gamma"] = 1 / 2.2

468 else:

469 msg = f"Unimplemented DXGI format {dxgi_format}"

470 raise NotImplementedError(msg)

471 else:

472 msg = f"Unimplemented pixel format {repr(fourcc)}"

473 raise NotImplementedError(msg)

474 else:

475 msg = f"Unknown pixel format flags {pfflags}"

476 raise NotImplementedError(msg)

477

478 if n:

479 self.tile = [

480 ImageFile._Tile("bcn", extents, offset, (n, self.pixel_format))

481 ]

482 else:

483 self.tile = [ImageFile._Tile("raw", extents, 0, rawmode or self.mode)]

484

485 def load_seek(self, pos: int) -> None:

486 pass

487

488

489class DdsRgbDecoder(ImageFile.PyDecoder):

490 _pulls_fd = True

491

492 def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:

493 assert self.fd is not None

494 bitcount, masks = self.args

495

496 # Some masks will be padded with zeros, e.g. R 0b11 G 0b1100

497 # Calculate how many zeros each mask is padded with

498 mask_offsets = []

499 # And the maximum value of each channel without the padding

500 mask_totals = []

501 for mask in masks:

502 offset = 0

503 if mask != 0:

504 while mask >> (offset + 1) << (offset + 1) == mask:

505 offset += 1

506 mask_offsets.append(offset)

507 mask_totals.append(mask >> offset)

508

509 data = bytearray()

510 bytecount = bitcount // 8

511 dest_length = self.state.xsize * self.state.ysize * len(masks)

512 while len(data) < dest_length:

513 value = int.from_bytes(self.fd.read(bytecount), "little")

514 for i, mask in enumerate(masks):

515 masked_value = value & mask

516 # Remove the zero padding, and scale it to 8 bits

517 data += o8(

518 int(((masked_value >> mask_offsets[i]) / mask_totals[i]) * 255)

519 )

520 self.set_as_raw(data)

521 return -1, 0

522

523

524def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:

525 if im.mode not in ("RGB", "RGBA", "L", "LA"):

526 msg = f"cannot write mode {im.mode} as DDS"

527 raise OSError(msg)

528

529 flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT

530 bitcount = len(im.getbands()) * 8

531 pixel_format = im.encoderinfo.get("pixel_format")

532 args: tuple[int] | str

533 if pixel_format:

534 codec_name = "bcn"

535 flags |= DDSD.LINEARSIZE

536 pitch = (im.width + 3) * 4

537 rgba_mask = [0, 0, 0, 0]

538 pixel_flags = DDPF.FOURCC

539 if pixel_format == "DXT1":

540 fourcc = D3DFMT.DXT1

541 args = (1,)

542 elif pixel_format == "DXT3":

543 fourcc = D3DFMT.DXT3

544 args = (2,)

545 elif pixel_format == "DXT5":

546 fourcc = D3DFMT.DXT5

547 args = (3,)

548 else:

549 fourcc = D3DFMT.DX10

550 if pixel_format == "BC2":

551 args = (2,)

552 dxgi_format = DXGI_FORMAT.BC2_TYPELESS

553 elif pixel_format == "BC3":

554 args = (3,)

555 dxgi_format = DXGI_FORMAT.BC3_TYPELESS

556 elif pixel_format == "BC5":

557 args = (5,)

558 dxgi_format = DXGI_FORMAT.BC5_TYPELESS

559 if im.mode != "RGB":

560 msg = "only RGB mode can be written as BC5"

561 raise OSError(msg)

562 else:

563 msg = f"cannot write pixel format {pixel_format}"

564 raise OSError(msg)

565 else:

566 codec_name = "raw"

567 flags |= DDSD.PITCH

568 pitch = (im.width * bitcount + 7) // 8

569

570 alpha = im.mode[-1] == "A"

571 if im.mode[0] == "L":

572 pixel_flags = DDPF.LUMINANCE

573 args = im.mode

574 if alpha:

575 rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]

576 else:

577 rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]

578 else:

579 pixel_flags = DDPF.RGB

580 args = im.mode[::-1]

581 rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]

582

583 if alpha:

584 r, g, b, a = im.split()

585 im = Image.merge("RGBA", (a, r, g, b))

586 if alpha:

587 pixel_flags |= DDPF.ALPHAPIXELS

588 rgba_mask.append(0xFF000000 if alpha else 0)

589

590 fourcc = D3DFMT.UNKNOWN

591 fp.write(

592 o32(DDS_MAGIC)

593 + struct.pack(

594 "<7I",

595 124, # header size

596 flags, # flags

597 im.height,

598 im.width,

599 pitch,

600 0, # depth

601 0, # mipmaps

602 )

603 + struct.pack("11I", *((0,) * 11)) # reserved

604 # pfsize, pfflags, fourcc, bitcount

605 + struct.pack("<4I", 32, pixel_flags, fourcc, bitcount)

606 + struct.pack("<4I", *rgba_mask) # dwRGBABitMask

607 + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)

608 )

609 if fourcc == D3DFMT.DX10:

610 fp.write(

611 # dxgi_format, 2D resource, misc, array size, straight alpha

612 struct.pack("<5I", dxgi_format, 3, 0, 0, 1)

613 )

614 ImageFile._save(im, fp, [ImageFile._Tile(codec_name, (0, 0) + im.size, 0, args)])

615

616

617def _accept(prefix: bytes) -> bool:

618 return prefix.startswith(b"DDS ")

619

620

621Image.register_open(DdsImageFile.format, DdsImageFile, _accept)

622Image.register_decoder("dds_rgb", DdsRgbDecoder)

623Image.register_save(DdsImageFile.format, _save)

624Image.register_extension(DdsImageFile.format, ".dds")