src/mesa/glapi/glX_XML.py

   1 #!/usr/bin/python2
   2
   3 # (C) Copyright IBM Corporation 2004, 2005
   4 # All Rights Reserved.
   5 #
   6 # Permission is hereby granted, free of charge, to any person obtaining a
   7 # copy of this software and associated documentation files (the "Software"),
   8 # to deal in the Software without restriction, including without limitation
   9 # on the rights to use, copy, modify, merge, publish, distribute, sub
  10 # license, and/or sell copies of the Software, and to permit persons to whom
  11 # the Software is furnished to do so, subject to the following conditions:
  12 #
  13 # The above copyright notice and this permission notice (including the next
  14 # paragraph) shall be included in all copies or substantial portions of the
  15 # Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  20 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  23 # IN THE SOFTWARE.
  24 #
  25 # Authors:
  26 #    Ian Romanick <idr@us.ibm.com>
  27
  28 from xml.sax import saxutils
  29 from xml.sax import make_parser
  30 from xml.sax.handler import feature_namespaces
  31
  32 import gl_XML
  33 import license
  34 import sys, getopt, string
  35
  36
  37 class glXItemFactory(gl_XML.glItemFactory):
  38         """Factory to create GLX protocol oriented objects derived from glItem."""
  39
  40         def create(self, context, name, attrs):
  41                 if name == "function":
  42                         return glXFunction(context, name, attrs)
  43                 elif name == "enum":
  44                         return glXEnum(context, name, attrs)
  45                 elif name == "param":
  46                         return glXParameter(context, name, attrs)
  47                 else:
  48                         return gl_XML.glItemFactory.create(self, context, name, attrs)
  49
  50 class glXEnumFunction:
  51         def __init__(self, name, context):
  52                 self.name = name
  53                 self.context = context
  54                 self.mode = 0
  55                 self.sig = None
  56
  57                 # "enums" is a set of lists.  The element in the set is the
  58                 # value of the enum.  The list is the list of names for that
  59                 # value.  For example, [0x8126] = {"POINT_SIZE_MIN",
  60                 # "POINT_SIZE_MIN_ARB", "POINT_SIZE_MIN_EXT",
  61                 # "POINT_SIZE_MIN_SGIS"}.
  62
  63                 self.enums = {}
  64
  65                 # "count" is indexed by count values.  Each element of count
  66                 # is a list of index to "enums" that have that number of
  67                 # associated data elements.  For example, [4] =
  68                 # {GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION,
  69                 # GL_AMBIENT_AND_DIFFUSE} (the enum names are used here,
  70                 # but the actual hexadecimal values would be in the array).
  71
  72                 self.count = {}
  73
  74
  75         def append(self, count, value, name):
  76                 if self.enums.has_key( value ):
  77                         self.enums[value].append(name)
  78                 else:
  79                         if not self.count.has_key(count):
  80                                 self.count[count] = []
  81
  82                         self.enums[value] = []
  83                         self.enums[value].append(name)
  84                         self.count[count].append(value)
  85
  86
  87         def signature( self ):
  88                 if self.sig == None:
  89                         self.sig = ""
  90                         for i in self.count:
  91                                 self.count[i].sort()
  92                                 for e in self.count[i]:
  93                                         self.sig += "%04x,%u," % (e, i)
  94
  95                 return self.sig
  96
  97
  98         def set_mode( self, mode ):
  99                 """Mark an enum-function as a 'set' function."""
 100
 101                 self.mode = mode
 102
 103
 104         def is_set( self ):
 105                 return self.mode
 106
 107
 108         def PrintUsingTable(self):
 109                 """Emit the body of the __gl*_size function using a pair
 110                 of look-up tables and a mask.  The mask is calculated such
 111                 that (e & mask) is unique for all the valid values of e for
 112                 this function.  The result of (e & mask) is used as an index
 113                 into the first look-up table.  If it matches e, then the
 114                 same entry of the second table is returned.  Otherwise zero
 115                 is returned.
 116
 117                 It seems like this should cause better code to be generated.
 118                 However, on x86 at least, the resulting .o file is about 20%
 119                 larger then the switch-statment version.  I am leaving this
 120                 code in because the results may be different on other
 121                 platforms (e.g., PowerPC or x86-64)."""
 122
 123                 return 0
 124                 count = 0
 125                 for a in self.enums:
 126                         count += 1
 127
 128                 # Determine if there is some mask M, such that M = (2^N) - 1,
 129                 # that will generate unique values for all of the enums.
 130
 131                 mask = 0
 132                 for i in [1, 2, 3, 4, 5, 6, 7, 8]:
 133                         mask = (1 << i) - 1
 134
 135                         fail = 0;
 136                         for a in self.enums:
 137                                 for b in self.enums:
 138                                         if a != b:
 139                                                 if (a & mask) == (b & mask):
 140                                                         fail = 1;
 141
 142                         if not fail:
 143                                 break;
 144                         else:
 145                                 mask = 0
 146
 147                 if (mask != 0) and (mask < (2 * count)):
 148                         masked_enums = {}
 149                         masked_count = {}
 150
 151                         for i in range(0, mask + 1):
 152                                 masked_enums[i] = "0";
 153                                 masked_count[i] = 0;
 154
 155                         for c in self.count:
 156                                 for e in self.count[c]:
 157                                         i = e & mask
 158                                         masked_enums[i] = '0x%04x /* %s */' % (e, self.enums[e][0])
 159                                         masked_count[i] = c
 160
 161
 162                         print '    static const GLushort a[%u] = {' % (mask + 1)
 163                         for e in masked_enums:
 164                                 print '        %s, ' % (masked_enums[e])
 165                         print '    };'
 166
 167                         print '    static const GLubyte b[%u] = {' % (mask + 1)
 168                         for c in masked_count:
 169                                 print '        %u, ' % (masked_count[c])
 170                         print '    };'
 171
 172                         print '    const unsigned idx = (e & 0x%02xU);' % (mask)
 173                         print ''
 174                         print '    return (e == a[idx]) ? (GLint) b[idx] : 0;'
 175                         return 1;
 176                 else:
 177                         return 0;
 178
 179         def PrintUsingSwitch(self):
 180                 """Emit the body of the __gl*_size function using a
 181                 switch-statement."""
 182
 183                 print '    switch( e ) {'
 184
 185                 for c in self.count:
 186                         for e in self.count[c]:
 187                                 first = 1
 188
 189                                 # There may be multiple enums with the same
 190                                 # value.  This happens has extensions are
 191                                 # promoted from vendor-specific or EXT to
 192                                 # ARB and to the core.  Emit the first one as
 193                                 # a case label, and emit the others as
 194                                 # commented-out case labels.
 195
 196                                 for j in self.enums[e]:
 197                                         if first:
 198                                                 print '        case %s:' % (j)
 199                                                 first = 0
 200                                         else:
 201                                                 print '/*      case %s:*/' % (j)
 202
 203                         print '            return %u;' % (c)
 204
 205                 print '        default: return 0;'
 206                 print '    }'
 207
 208
 209         def Print(self, name):
 210                 print 'INTERNAL PURE FASTCALL GLint'
 211                 print '__gl%s_size( GLenum e )' % (name)
 212                 print '{'
 213
 214                 if not self.PrintUsingTable():
 215                         self.PrintUsingSwitch()
 216
 217                 print '}'
 218                 print ''
 219
 220
 221
 222 class glXEnum(gl_XML.glEnum):
 223         def __init__(self, context, name, attrs):
 224                 gl_XML.glEnum.__init__(self, context, name, attrs)
 225
 226
 227         def startElement(self, name, attrs):
 228                 if name == "size":
 229                         [n, c, mode] = self.process_attributes(attrs)
 230
 231                         if not self.context.glx_enum_functions.has_key( n ):
 232                                 f = self.context.createEnumFunction( n )
 233                                 f.set_mode( mode )
 234                                 self.context.glx_enum_functions[ f.name ] = f
 235
 236                         self.context.glx_enum_functions[ n ].append( c, self.value, self.name )
 237                 else:
 238                         gl_XML.glEnum.startElement(self, context, name, attrs)
 239                 return
 240
 241
 242 class glXParameter(gl_XML.glParameter):
 243         def __init__(self, context, name, attrs):
 244                 self.order = 1;
 245                 gl_XML.glParameter.__init__(self, context, name, attrs);
 246
 247
 248 class glXParameterIterator:
 249         """Class to iterate over a list of glXParameters.
 250
 251         Objects of this class are returned by the parameterIterator method of
 252         the glXFunction class.  They are used to iterate over the list of
 253         parameters to the function."""
 254
 255         def __init__(self, data, skip_output, max_order):
 256                 self.data = data
 257                 self.index = 0
 258                 self.order = 0
 259                 self.skip_output = skip_output
 260                 self.max_order = max_order
 261
 262         def __iter__(self):
 263                 return self
 264
 265         def next(self):
 266                 if len( self.data ) == 0:
 267                         raise StopIteration
 268
 269                 while 1:
 270                         if self.index == len( self.data ):
 271                                 if self.order == self.max_order:
 272                                         raise StopIteration
 273                                 else:
 274                                         self.order += 1
 275                                         self.index = 0
 276
 277                         i = self.index
 278                         self.index += 1
 279
 280                         if self.data[i].order == self.order and not (self.data[i].is_output and self.skip_output):
 281                                 return self.data[i]
 282
 283
 284 class glXFunction(gl_XML.glFunction):
 285         glx_rop = 0
 286         glx_sop = 0
 287         glx_vendorpriv = 0
 288
 289         # If this is set to true, it means that GLdouble parameters should be
 290         # written to the GLX protocol packet in the order they appear in the
 291         # prototype.  This is different from the "classic" ordering.  In the
 292         # classic ordering GLdoubles are written to the protocol packet first,
 293         # followed by non-doubles.  NV_vertex_program was the first extension
 294         # to break with this tradition.
 295
 296         glx_doubles_in_order = 0
 297
 298         vectorequiv = None
 299         can_be_large = 0
 300
 301         def __init__(self, context, name, attrs):
 302                 self.vectorequiv = attrs.get('vectorequiv', None)
 303                 self.counter = None
 304                 self.output = None
 305                 self.can_be_large = 0
 306                 self.reply_always_array = 0
 307                 self.dimensions_in_reply = 0
 308                 self.img_reset = None
 309
 310                 self.server_handcode = 0
 311                 self.client_handcode = 0
 312                 self.ignore = 0
 313
 314                 gl_XML.glFunction.__init__(self, context, name, attrs)
 315                 return
 316
 317
 318         def parameterIterator(self, skip_output, max_order):
 319                 return glXParameterIterator(self.fn_parameters, skip_output, max_order)
 320
 321
 322         def startElement(self, name, attrs):
 323                 """Process elements within a function that are specific to GLX."""
 324
 325                 if name == "glx":
 326                         self.glx_rop = int(attrs.get('rop', "0"))
 327                         self.glx_sop = int(attrs.get('sop', "0"))
 328                         self.glx_vendorpriv = int(attrs.get('vendorpriv', "0"))
 329                         self.img_reset = attrs.get('img_reset', None)
 330
 331                         # The 'handcode' attribute can be one of 'true',
 332                         # 'false', 'client', or 'server'.
 333
 334                         handcode = attrs.get('handcode', "false")
 335                         if handcode == "false":
 336                                 self.server_handcode = 0
 337                                 self.client_handcode = 0
 338                         elif handcode == "true":
 339                                 self.server_handcode = 1
 340                                 self.client_handcode = 1
 341                         elif handcode == "client":
 342                                 self.server_handcode = 0
 343                                 self.client_handcode = 1
 344                         elif handcode == "server":
 345                                 self.server_handcode = 1
 346                                 self.client_handcode = 0
 347                         else:
 348                                 raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
 349
 350
 351                         if attrs.get('ignore', "false") == "true":
 352                                 self.ignore = 1
 353                         else:
 354                                 self.ignore = 0
 355
 356                         if attrs.get('large', "false") == "true":
 357                                 self.can_be_large = 1
 358                         else:
 359                                 self.can_be_large = 0
 360
 361                         if attrs.get('doubles_in_order', "false") == "true":
 362                                 self.glx_doubles_in_order = 1
 363                         else:
 364                                 self.glx_doubles_in_order = 0
 365
 366                         if attrs.get('always_array', "false") == "true":
 367                                 self.reply_always_array = 1
 368                         else:
 369                                 self.reply_always_array = 0
 370
 371                         if attrs.get('dimensions_in_reply', "false") == "true":
 372                                 self.dimensions_in_reply = 1
 373                         else:
 374                                 self.dimensions_in_reply = 0
 375                 else:
 376                         gl_XML.glFunction.startElement(self, name, attrs)
 377
 378
 379         def endElement(self, name):
 380                 if name == "function":
 381                         # Mark any function that does not have GLX protocol
 382                         # defined as "ignore".  This prevents bad things from
 383                         # happening when people add new functions to the GL
 384                         # API XML without adding any GLX section.
 385                         #
 386                         # This will also mark functions that don't have a
 387                         # dispatch offset at ignored.
 388
 389                         if (self.fn_offset == -1 and not self.fn_alias) or not (self.client_handcode or self.server_handcode or self.glx_rop or self.glx_sop or self.glx_vendorpriv or self.vectorequiv or self.fn_alias):
 390                                 #if not self.ignore:
 391                                 #       if self.fn_offset == -1:
 392                                 #               print '/* %s ignored becuase no offset assigned. */' % (self.name)
 393                                 #       else:
 394                                 #               print '/* %s ignored becuase no GLX opcode assigned. */' % (self.name)
 395
 396                                 self.ignore = 1
 397
 398                 return gl_XML.glFunction.endElement(self, name)
 399
 400
 401         def append(self, tag_name, p):
 402                 gl_XML.glFunction.append(self, tag_name, p)
 403
 404                 if p.is_variable_length_array():
 405                         p.order = 2;
 406                 elif not self.glx_doubles_in_order and p.p_type.size == 8:
 407                         p.order = 0;
 408
 409                 if p.is_counter:
 410                         self.counter = p.name
 411
 412                 if p.is_output:
 413                         self.output = p
 414
 415                 return
 416
 417
 418         def variable_length_parameter(self):
 419                 if len(self.variable_length_parameters):
 420                         return self.variable_length_parameters[0]
 421
 422                 return None
 423
 424
 425         def output_parameter(self):
 426                 for param in self.fn_parameters:
 427                         if param.is_output:
 428                                 return param
 429
 430                 return None
 431
 432
 433         def offset_of_first_parameter(self):
 434                 """Get the offset of the first parameter in the command.
 435
 436                 Gets the offset of the first function parameter in the GLX
 437                 command packet.  This byte offset is measured from the end
 438                 of the Render / RenderLarge header.  The offset for all non-
 439                 pixel commends is zero.  The offset for pixel commands depends
 440                 on the number of dimensions of the pixel data."""
 441
 442                 if self.image and not self.image.is_output:
 443                         [dim, junk, junk, junk, junk] = self.dimensions()
 444
 445                         # The base size is the size of the pixel pack info
 446                         # header used by images with the specified number
 447                         # of dimensions.
 448
 449                         if dim <=  2:
 450                                 return 20
 451                         elif dim <= 4:
 452                                 return 36
 453                         else:
 454                                 raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
 455                 else:
 456                         return 0
 457
 458
 459         def command_fixed_length(self):
 460                 """Return the length, in bytes as an integer, of the
 461                 fixed-size portion of the command."""
 462
 463                 size = self.offset_of_first_parameter()
 464
 465                 for p in gl_XML.glFunction.parameterIterator(self):
 466                         if not p.is_output and p.name != self.img_reset:
 467                                 size += p.size()
 468                                 if self.pad_after(p):
 469                                         size += 4
 470
 471                 if self.image and (self.image.img_null_flag or self.image.is_output):
 472                         size += 4
 473
 474                 return size
 475
 476
 477         def command_variable_length(self):
 478                 """Return the length, as a string, of the variable-sized
 479                 portion of the command."""
 480
 481                 size_string = ""
 482                 for p in gl_XML.glFunction.parameterIterator(self):
 483                         if (not p.is_output) and (p.size() == 0):
 484                                 size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string())
 485
 486                 return size_string
 487
 488
 489         def command_length(self):
 490                 size = self.command_fixed_length()
 491
 492                 if self.glx_rop != 0:
 493                         size += 4
 494
 495                 size = ((size + 3) & ~3)
 496                 return "%u%s" % (size, self.command_variable_length())
 497
 498
 499         def opcode_real_value(self):
 500                 """Get the true numeric value of the GLX opcode
 501
 502                 Behaves similarly to opcode_value, except for
 503                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 504                 In these cases the value for the GLX opcode field (i.e.,
 505                 16 for X_GLXVendorPrivate or 17 for
 506                 X_GLXVendorPrivateWithReply) is returned.  For other 'single'
 507                 commands, the opcode for the command (e.g., 101 for
 508                 X_GLsop_NewList) is returned."""
 509
 510                 if self.glx_vendorpriv != 0:
 511                         if self.needs_reply():
 512                                 return 17
 513                         else:
 514                                 return 16
 515                 else:
 516                         return self.opcode_value()
 517
 518         def opcode_value(self):
 519                 """Get the unique protocol opcode for the glXFunction"""
 520
 521                 if self.glx_rop != 0:
 522                         return self.glx_rop
 523                 elif self.glx_sop != 0:
 524                         return self.glx_sop
 525                 elif self.glx_vendorpriv != 0:
 526                         return self.glx_vendorpriv
 527                 else:
 528                         return -1
 529
 530         def opcode_rop_basename(self):
 531                 """Return either the name to be used for GLX protocol enum.
 532
 533                 Returns either the name of the function or the name of the
 534                 name of the equivalent vector (e.g., glVertex3fv for
 535                 glVertex3f) function."""
 536
 537                 if self.vectorequiv == None:
 538                         return self.name
 539                 else:
 540                         return self.vectorequiv
 541
 542         def opcode_name(self):
 543                 """Get the unique protocol enum name for the glXFunction"""
 544
 545                 if self.glx_rop != 0:
 546                         return "X_GLrop_%s" % (self.opcode_rop_basename())
 547                 elif self.glx_sop != 0:
 548                         return "X_GLsop_%s" % (self.name)
 549                 elif self.glx_vendorpriv != 0:
 550                         return "X_GLvop_%s" % (self.name)
 551                 else:
 552                         raise RuntimeError('Function "%s" has no opcode.' % (self.name))
 553
 554
 555         def opcode_real_name(self):
 556                 """Get the true protocol enum name for the GLX opcode
 557
 558                 Behaves similarly to opcode_name, except for
 559                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 560                 In these cases the string 'X_GLXVendorPrivate' or
 561                 'X_GLXVendorPrivateWithReply' is returned.  For other
 562                 single or render commands 'X_GLsop' or 'X_GLrop' plus the
 563                 name of the function returned."""
 564
 565                 if self.glx_vendorpriv != 0:
 566                         if self.needs_reply():
 567                                 return "X_GLXVendorPrivateWithReply"
 568                         else:
 569                                 return "X_GLXVendorPrivate"
 570                 else:
 571                         return self.opcode_name()
 572
 573
 574         def return_string(self):
 575                 if self.fn_return_type != 'void':
 576                         return "return retval;"
 577                 else:
 578                         return "return;"
 579
 580
 581         def needs_reply(self):
 582                 return self.fn_return_type != 'void' or self.output != None
 583
 584
 585         def dimensions(self):
 586                 """Determine the dimensions of an image.
 587
 588                 Returns a tuple representing the number of dimensions and the
 589                 string name of each of the dimensions of an image,  If the
 590                 function is not a pixel function, the number of dimensions
 591                 will be zero."""
 592
 593                 if not self.image:
 594                         return [0, "0", "0", "0", "0"]
 595                 else:
 596                         dim = 1
 597                         w = self.image.width
 598
 599                         if self.image.height:
 600                                 dim = 2
 601                                 h = self.image.height
 602                         else:
 603                                 h = "1"
 604
 605                         if self.image.depth:
 606                                 dim = 3
 607                                 d = self.image.depth
 608                         else:
 609                                 d = "1"
 610
 611                         if self.image.extent:
 612                                 dim = 4
 613                                 e = self.image.extent
 614                         else:
 615                                 e = "1"
 616
 617                         return [dim, w, h, d, e]
 618
 619
 620         def pad_after(self, p):
 621                 """Returns the name of the field inserted after the
 622                 specified field to pad out the command header."""
 623
 624                 if self.image and self.image.img_pad_dimensions:
 625                         if not self.image.height:
 626                                 if p.name == self.image.width:
 627                                         return "height"
 628                                 elif p.name == self.image.img_xoff:
 629                                         return "yoffset"
 630                         elif not self.image.extent:
 631                                 if p.name == self.image.depth:
 632                                         # Should this be "size4d"?
 633                                         return "extent"
 634                                 elif p.name == self.image.img_zoff:
 635                                         return "woffset"
 636                 return None
 637
 638
 639 class glXFunctionIterator(gl_XML.glFunctionIterator):
 640         """Class to iterate over a list of glXFunctions"""
 641
 642         def __init__(self, context):
 643                 self.context = context
 644                 self.keys = context.functions.keys()
 645                 self.keys.sort()
 646
 647                 for self.index in range(0, len(self.keys)):
 648                         if self.keys[ self.index ] >= 0: break
 649
 650                 return
 651
 652
 653         def next(self):
 654                 if self.index == len(self.keys):
 655                         raise StopIteration
 656
 657                 f = self.context.functions[ self.keys[ self.index ] ]
 658                 self.index += 1
 659
 660                 if f.ignore:
 661                         return self.next()
 662                 else:
 663                         return f
 664
 665
 666 class GlxProto(gl_XML.FilterGLAPISpecBase):
 667         name = "glX_proto_send.py (from Mesa)"
 668
 669         def __init__(self):
 670                 gl_XML.FilterGLAPISpecBase.__init__(self)
 671                 self.factory = glXItemFactory()
 672                 self.glx_enum_functions = {}
 673
 674
 675         def endElement(self, name):
 676                 if name == 'OpenGLAPI':
 677                         # Once all the parsing is done, we have to go back and
 678                         # fix-up some cross references between different
 679                         # functions.
 680
 681                         for k in self.functions:
 682                                 f = self.functions[k]
 683                                 if f.vectorequiv != None:
 684                                         equiv = self.find_function(f.vectorequiv)
 685                                         if equiv != None:
 686                                                 f.glx_doubles_in_order = equiv.glx_doubles_in_order
 687                                                 f.glx_rop = equiv.glx_rop
 688                                         else:
 689                                                 raise RuntimeError("Could not find the vector equiv. function %s for %s!" % (f.name, f.vectorequiv))
 690                 else:
 691                         gl_XML.FilterGLAPISpecBase.endElement(self, name)
 692                 return
 693
 694
 695         def createEnumFunction(self, n):
 696                 return glXEnumFunction(n, self)
 697
 698
 699         def functionIterator(self):
 700                 return glXFunctionIterator(self)
 701
 702
 703         def size_call(self, func):
 704                 """Create C code to calculate 'compsize'.
 705
 706                 Creates code to calculate 'compsize'.  If the function does
 707                 not need 'compsize' to be calculated, None will be
 708                 returned."""
 709
 710                 if not func.image and not func.count_parameter_list:
 711                         return None
 712
 713                 if not func.image:
 714                         parameters = string.join( func.count_parameter_list, "," )
 715                         compsize = "__gl%s_size(%s)" % (func.name, parameters)
 716                 else:
 717                         [dim, w, h, d, junk] = func.dimensions()
 718
 719                         compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, func.image.img_format, func.image.img_type, func.image.img_target)
 720                         if not func.image.img_send_null:
 721                                 compsize = '(%s != NULL) ? %s : 0' % (func.image.name, compsize)
 722
 723                 return compsize