1 2''' 3/************************************************************************** 4 * 5 * Copyright 2009 VMware, Inc. 6 * All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the 10 * "Software"), to deal in the Software without restriction, including 11 * without limitation the rights to use, copy, modify, merge, publish, 12 * distribute, sub license, and/or sell copies of the Software, and to 13 * permit persons to whom the Software is furnished to do so, subject to 14 * the following conditions: 15 * 16 * The above copyright notice and this permission notice (including the 17 * next paragraph) shall be included in all copies or substantial portions 18 * of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 27 * 28 **************************************************************************/ 29''' 30 31 32from __future__ import division 33 34 35VOID, UNSIGNED, SIGNED, FIXED, FLOAT = range(5) 36 37SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_0, SWIZZLE_1, SWIZZLE_NONE, = range(7) 38 39PLAIN = 'plain' 40 41RGB = 'rgb' 42SRGB = 'srgb' 43YUV = 'yuv' 44ZS = 'zs' 45 46 47def is_pot(x): 48 return (x & (x - 1)) == 0 49 50 51VERY_LARGE = 99999999999999999999999 52 53 54class Channel: 55 '''Describe the channel of a color channel.''' 56 57 def __init__(self, type, norm, pure, size, name = ''): 58 self.type = type 59 self.norm = norm 60 self.pure = pure 61 self.size = size 62 self.sign = type in (SIGNED, FIXED, FLOAT) 63 self.name = name 64 65 def __str__(self): 66 s = str(self.type) 67 if self.norm: 68 s += 'n' 69 if self.pure: 70 s += 'p' 71 s += str(self.size) 72 return s 73 74 def __eq__(self, other): 75 if other is None: 76 return False 77 78 return self.type == other.type and self.norm == other.norm and self.pure == other.pure and self.size == other.size 79 80 def __ne__(self, other): 81 return not self == other 82 83 def max(self): 84 '''Maximum representable number.''' 85 if self.type == FLOAT: 86 return VERY_LARGE 87 if self.type == FIXED: 88 return (1 << (self.size // 2)) - 1 89 if self.norm: 90 return 1 91 if self.type == UNSIGNED: 92 return (1 << self.size) - 1 93 if self.type == SIGNED: 94 return (1 << (self.size - 1)) - 1 95 assert False 96 97 def min(self): 98 '''Minimum representable number.''' 99 if self.type == FLOAT: 100 return -VERY_LARGE 101 if self.type == FIXED: 102 return -(1 << (self.size // 2)) 103 if self.type == UNSIGNED: 104 return 0 105 if self.norm: 106 return -1 107 if self.type == SIGNED: 108 return -(1 << (self.size - 1)) 109 assert False 110 111 112class Format: 113 '''Describe a pixel format.''' 114 115 def __init__(self, name, layout, block_width, block_height, le_channels, le_swizzles, be_channels, be_swizzles, colorspace): 116 self.name = name 117 self.layout = layout 118 self.block_width = block_width 119 self.block_height = block_height 120 self.le_channels = le_channels 121 self.le_swizzles = le_swizzles 122 self.be_channels = be_channels 123 self.be_swizzles = be_swizzles 124 self.name = name 125 self.colorspace = colorspace 126 127 def __str__(self): 128 return self.name 129 130 def short_name(self): 131 '''Make up a short norm for a format, suitable to be used as suffix in 132 function names.''' 133 134 name = self.name 135 if name.startswith('PIPE_FORMAT_'): 136 name = name[len('PIPE_FORMAT_'):] 137 name = name.lower() 138 return name 139 140 def block_size(self): 141 size = 0 142 for channel in self.le_channels: 143 size += channel.size 144 return size 145 146 def nr_channels(self): 147 nr_channels = 0 148 for channel in self.le_channels: 149 if channel.size: 150 nr_channels += 1 151 return nr_channels 152 153 def array_element(self): 154 if self.layout != PLAIN: 155 return None 156 ref_channel = self.le_channels[0] 157 if ref_channel.type == VOID: 158 ref_channel = self.le_channels[1] 159 for channel in self.le_channels: 160 if channel.size and (channel.size != ref_channel.size or channel.size % 8): 161 return None 162 if channel.type != VOID: 163 if channel.type != ref_channel.type: 164 return None 165 if channel.norm != ref_channel.norm: 166 return None 167 if channel.pure != ref_channel.pure: 168 return None 169 return ref_channel 170 171 def is_array(self): 172 return self.array_element() != None 173 174 def is_mixed(self): 175 if self.layout != PLAIN: 176 return False 177 ref_channel = self.le_channels[0] 178 if ref_channel.type == VOID: 179 ref_channel = self.le_channels[1] 180 for channel in self.le_channels[1:]: 181 if channel.type != VOID: 182 if channel.type != ref_channel.type: 183 return True 184 if channel.norm != ref_channel.norm: 185 return True 186 if channel.pure != ref_channel.pure: 187 return True 188 return False 189 190 def is_pot(self): 191 return is_pot(self.block_size()) 192 193 def is_int(self): 194 if self.layout != PLAIN: 195 return False 196 for channel in self.le_channels: 197 if channel.type not in (VOID, UNSIGNED, SIGNED): 198 return False 199 return True 200 201 def is_float(self): 202 if self.layout != PLAIN: 203 return False 204 for channel in self.le_channels: 205 if channel.type not in (VOID, FLOAT): 206 return False 207 return True 208 209 def is_bitmask(self): 210 if self.layout != PLAIN: 211 return False 212 if self.block_size() not in (8, 16, 32): 213 return False 214 for channel in self.le_channels: 215 if channel.type not in (VOID, UNSIGNED, SIGNED): 216 return False 217 return True 218 219 def is_pure_color(self): 220 if self.layout != PLAIN or self.colorspace == ZS: 221 return False 222 pures = [channel.pure 223 for channel in self.le_channels 224 if channel.type != VOID] 225 for x in pures: 226 assert x == pures[0] 227 return pures[0] 228 229 def channel_type(self): 230 types = [channel.type 231 for channel in self.le_channels 232 if channel.type != VOID] 233 for x in types: 234 assert x == types[0] 235 return types[0] 236 237 def is_pure_signed(self): 238 return self.is_pure_color() and self.channel_type() == SIGNED 239 240 def is_pure_unsigned(self): 241 return self.is_pure_color() and self.channel_type() == UNSIGNED 242 243 def has_channel(self, id): 244 return self.le_swizzles[id] != SWIZZLE_NONE 245 246 def has_depth(self): 247 return self.colorspace == ZS and self.has_channel(0) 248 249 def has_stencil(self): 250 return self.colorspace == ZS and self.has_channel(1) 251 252 def stride(self): 253 return self.block_size()/8 254 255 256_type_parse_map = { 257 '': VOID, 258 'x': VOID, 259 'u': UNSIGNED, 260 's': SIGNED, 261 'h': FIXED, 262 'f': FLOAT, 263} 264 265_swizzle_parse_map = { 266 'x': SWIZZLE_X, 267 'y': SWIZZLE_Y, 268 'z': SWIZZLE_Z, 269 'w': SWIZZLE_W, 270 '0': SWIZZLE_0, 271 '1': SWIZZLE_1, 272 '_': SWIZZLE_NONE, 273} 274 275def _parse_channels(fields, layout, colorspace, swizzles): 276 if layout == PLAIN: 277 names = ['']*4 278 if colorspace in (RGB, SRGB): 279 for i in range(4): 280 swizzle = swizzles[i] 281 if swizzle < 4: 282 names[swizzle] += 'rgba'[i] 283 elif colorspace == ZS: 284 for i in range(4): 285 swizzle = swizzles[i] 286 if swizzle < 4: 287 names[swizzle] += 'zs'[i] 288 else: 289 assert False 290 for i in range(4): 291 if names[i] == '': 292 names[i] = 'x' 293 else: 294 names = ['x', 'y', 'z', 'w'] 295 296 channels = [] 297 for i in range(0, 4): 298 field = fields[i] 299 if field: 300 type = _type_parse_map[field[0]] 301 if field[1] == 'n': 302 norm = True 303 pure = False 304 size = int(field[2:]) 305 elif field[1] == 'p': 306 pure = True 307 norm = False 308 size = int(field[2:]) 309 else: 310 norm = False 311 pure = False 312 size = int(field[1:]) 313 else: 314 type = VOID 315 norm = False 316 pure = False 317 size = 0 318 channel = Channel(type, norm, pure, size, names[i]) 319 channels.append(channel) 320 321 return channels 322 323def parse(filename): 324 '''Parse the format description in CSV format in terms of the 325 Channel and Format classes above.''' 326 327 stream = open(filename) 328 formats = [] 329 for line in stream: 330 try: 331 comment = line.index('#') 332 except ValueError: 333 pass 334 else: 335 line = line[:comment] 336 line = line.strip() 337 if not line: 338 continue 339 340 fields = [field.strip() for field in line.split(',')] 341 if len (fields) == 10: 342 fields += fields[4:9] 343 assert len (fields) == 15 344 345 name = fields[0] 346 layout = fields[1] 347 block_width, block_height = map(int, fields[2:4]) 348 colorspace = fields[9] 349 350 le_swizzles = [_swizzle_parse_map[swizzle] for swizzle in fields[8]] 351 le_channels = _parse_channels(fields[4:8], layout, colorspace, le_swizzles) 352 353 be_swizzles = [_swizzle_parse_map[swizzle] for swizzle in fields[14]] 354 be_channels = _parse_channels(fields[10:14], layout, colorspace, be_swizzles) 355 356 le_shift = 0 357 for channel in le_channels: 358 channel.shift = le_shift 359 le_shift += channel.size 360 361 be_shift = 0 362 for channel in be_channels[3::-1]: 363 channel.shift = be_shift 364 be_shift += channel.size 365 366 assert le_shift == be_shift 367 for i in range(4): 368 assert (le_swizzles[i] != SWIZZLE_NONE) == (be_swizzles[i] != SWIZZLE_NONE) 369 370 format = Format(name, layout, block_width, block_height, le_channels, le_swizzles, be_channels, be_swizzles, colorspace) 371 formats.append(format) 372 return formats 373 374