Add framebuffer object related commands to command buffer.

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 1999 matching lines @@
     'decoder_func': 'DoGetVertexAttribiv',
     'expectation': False,
     'client_test': False,
   },
   'GetVertexAttribPointerv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLuint>'],
     'client_test': False,
   },
+  'InvalidateFramebuffer': {
+    'type': 'PUTn',
+    'count': 1,
+    'client_test': False,
+    'unit_test': False,
+    'unsafe': True,
+  },
+  'InvalidateSubFramebuffer': {
+    'type': 'PUTn',
+    'count': 1,
+    'client_test': False,
+    'unit_test': False,
+    'unsafe': True,
+  },
   'IsBuffer': {
     'type': 'Is',
     'decoder_func': 'DoIsBuffer',
     'expectation': False,
   },
   'IsEnabled': {
     'type': 'Is',
     'decoder_func': 'DoIsEnabled',
     'impl_func': False,
     'expectation': False,
@@ skipping 96 matching lines @@
   },
   'RenderbufferStorageMultisampleEXT': {
     'cmd_comment':
         '// GL_EXT_multisampled_render_to_texture\n',
     'decoder_func': 'DoRenderbufferStorageMultisampleEXT',
     'gl_test_func': 'glRenderbufferStorageMultisampleEXT',
     'expectation': False,
     'unit_test': False,
     'extension_flag': 'multisampled_render_to_texture',
   },
+  'ReadBuffer': {
+    'unsafe': True,
+  },
   'ReadPixels': {
     'cmd_comment':
         '// ReadPixels has the result separated from the pixel buffer so that\n'
         '// it is easier to specify the result going to some specific place\n'
         '// that exactly fits the rectangle of pixels.\n',
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'impl_func': False,
     'client_test': False,
     'cmd_args':
@@ skipping 996 matching lines @@
     func.WriteHandlerImplementation(file)
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Writes the service implementation for an immediate version of command."""
     self.WriteServiceHandlerFunctionHeader(func, file)
     self.WriteHandlerExtensionCheck(func, file)
     self.WriteHandlerDeferReadWrite(func, file);
-    last_arg = func.GetLastOriginalArg()
-    all_but_last_arg = func.GetOriginalArgs()[:-1]
-    for arg in all_but_last_arg:
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        self.WriteGetDataSizeCode(func, file)
       arg.WriteGetCode(file)
-    self.WriteGetDataSizeCode(func, file)
-    last_arg.WriteGetCode(file)
     func.WriteHandlerValidation(file)
     func.WriteHandlerImplementation(file)
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteBucketServiceImplementation(self, func, file):
     """Writes the service implementation for a bucket version of command."""
     self.WriteServiceHandlerFunctionHeader(func, file)
     self.WriteHandlerExtensionCheck(func, file)
@@ skipping 2402 matching lines @@
     cmds::%(name)sImmediate cmd;
     %(type)s data[%(count_param)d][%(count)d];
   };
 
   Cmds expected;
   for (int ii = 0; ii < %(count_param)d; ++ii) {
     for (int jj = 0; jj < %(count)d; ++jj) {
       data[ii][jj] = static_cast<%(type)s>(ii * %(count)d + jj);
     }
   }
-  expected.cmd.Init(%(cmd_args)s, &data[0][0]);
-  gl_->%(name)s(%(args)s, &data[0][0]);
+  expected.cmd.Init(%(cmd_args)s);
+  gl_->%(name)s(%(args)s);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
-    cmd_arg_strings = [
-      arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()[0:-2]
-    ]
+    cmd_arg_strings = []
+    for arg in func.GetCmdArgs():
+      if arg.name.endswith("_shm_id"):
+        cmd_arg_strings.append("&data[0][0]")
+      elif arg.name.endswith("_shm_offset"):
+        continue
+      else:
+        cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func))
     gl_arg_strings = []
     count_param = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
-      valid_value = arg.GetValidClientSideArg(func)
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        valid_value = "&data[0][0]"

[Ken Russell (switch to Gerrit), 2014/12/04 01:42:56]

These changes seem really over-specialized, and scattered throughout this file.
Is there any way to encapsulate them better?

+      else:
+        valid_value = arg.GetValidClientSideArg(func)
       gl_arg_strings.append(valid_value)
       if arg.name == "count":
         count_param = int(valid_value)
     file.Write(code % {
           'name': func.name,
           'type': self.GetArrayType(func),
           'count': self.GetArrayCount(func),
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
           'count_param': count_param,
         })
 
     # Test constants for invalid values, as they are not tested by the
     # service.
     constants = [
       arg for arg in func.GetOriginalArgs()[0:-1] if arg.IsConstant()
     ]
     if not constants:
       return
 
     code = """
 TEST_F(GLES2ImplementationTest, %(name)sInvalidConstantArg%(invalid_index)d) {
   %(type)s data[%(count_param)d][%(count)d] = {{0}};
   for (int ii = 0; ii < %(count_param)d; ++ii) {
     for (int jj = 0; jj < %(count)d; ++jj) {
       data[ii][jj] = static_cast<%(type)s>(ii * %(count)d + jj);
     }
   }
-  gl_->%(name)s(%(args)s, &data[0][0]);
+  gl_->%(name)s(%(args)s);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(%(gl_error)s, CheckError());
 }
 """
     for invalid_arg in constants:
       gl_arg_strings = []
       invalid = invalid_arg.GetInvalidArg(func)
-      for arg in func.GetOriginalArgs()[0:-1]:
+      for arg in func.GetOriginalArgs():
         if arg is invalid_arg:
           gl_arg_strings.append(invalid[0])
+        elif arg.IsPointer():
+          gl_arg_strings.append("&data[0][0]")
         else:
           valid_value = arg.GetValidClientSideArg(func)
           gl_arg_strings.append(valid_value)
           if arg.name == "count":
             count_param = int(valid_value)
 
       file.Write(code % {
         'name': func.name,
         'invalid_index': func.GetOriginalArgs().index(invalid_arg),
         'type': self.GetArrayType(func),
@@ skipping 22 matching lines @@
   def WriteImmediateCmdSetHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  void SetHeader(GLsizei count) {\n")
     file.Write(
         "    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdInit(self, func, file):
     """Overrriden from TypeHandler."""
-    last_arg = func.GetLastOriginalArg()
-    file.Write("  void Init(%s, %s _%s) {\n" %
-               (func.MakeTypedCmdArgString("_"),
-                last_arg.type, last_arg.name))
+    file.Write("  void Init(%s) {\n" %
+               func.MakeTypedInitString("_"))
     file.Write("    SetHeader(_count);\n")
     args = func.GetCmdArgs()
     for arg in args:
       file.Write("    %s = _%s;\n" % (arg.name, arg.name))
     file.Write("    memcpy(ImmediateDataAddress(this),\n")
-    file.Write("           _%s, ComputeDataSize(_count));\n" % last_arg.name)
+    pointer_arg = None
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        pointer_arg = arg
+        break
+    file.Write("           _%s, ComputeDataSize(_count));\n" % pointer_arg.name)
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSet(self, func, file):
     """Overrriden from TypeHandler."""
-    last_arg = func.GetLastOriginalArg()
-    copy_args = func.MakeCmdArgString("_", False)
-    file.Write("  void* Set(void* cmd%s, %s _%s) {\n" %
-               (func.MakeTypedCmdArgString("_", True),
-                last_arg.type, last_arg.name))
-    file.Write("    static_cast<ValueType*>(cmd)->Init(%s, _%s);\n" %
-               (copy_args, last_arg.name))
+    file.Write("  void* Set(void* cmd%s) {\n" %
+               func.MakeTypedInitString("_", True))
+    file.Write("    static_cast<ValueType*>(cmd)->Init(%s);\n" %
+               func.MakeInitString("_"))
     file.Write("    const uint32_t size = ComputeSize(_count);\n")
     file.Write("    return NextImmediateCmdAddressTotalSize<ValueType>("
                "cmd, size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  void %(name)s(%(typed_args)s) {
     const uint32_t size = gles2::cmds::%(name)s::ComputeSize(count);
     gles2::cmds::%(name)s* c =
         GetImmediateCmdSpaceTotalSize<gles2::cmds::%(name)s>(size);
     if (c) {
       c->Init(%(args)s);
     }
   }
 
 """
     file.Write(code % {
           "name": func.name,
           "typed_args": func.MakeTypedInitString(""),
           "args": func.MakeInitString("")
         })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.GetCmdArgs()
+    args = func.GetOriginalArgs()
     count_param = 0
     for arg in args:
       if arg.name == "count":
         count_param = int(arg.GetValidClientSideCmdArg(func))
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  const int kSomeBaseValueToTestWith = 51;\n")
     file.Write("  static %s data[] = {\n" % self.GetArrayType(func))
     for v in range(0, self.GetArrayCount(func) * count_param):
       file.Write("    static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" %
                  (self.GetArrayType(func), v))
     file.Write("  };\n")
     file.Write("  cmds::%s& cmd = *GetBufferAs<cmds::%s>();\n" %
                (func.name, func.name))
     file.Write("  const GLsizei kNumElements = %d;\n" % count_param)
     file.Write("  const size_t kExpectedCmdSize =\n")
     file.Write("      sizeof(cmd) + kNumElements * sizeof(%s) * %d;\n" %
                (self.GetArrayType(func), self.GetArrayCount(func)))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     for value, arg in enumerate(args):
-      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 1))
-    file.Write(",\n      data);\n")
+      if arg.IsPointer():
+        file.Write(",\n      data")
+      elif arg.type == "GLboolean":
+        continue
+      else:
+        file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 1))
+    file.Write(");\n")
     file.Write("  EXPECT_EQ(static_cast<uint32_t>(cmds::%s::kCmdId),\n" %
                func.name)
     file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);\n")
     for value, arg in enumerate(args):
+      if arg.IsPointer() or arg.type == "GLboolean":
+        continue
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value + 1, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
@@ skipping 1229 matching lines @@
       self.args_for_cmds = self.original_args[:]
 
     self.return_type = info['return_type']
     if self.return_type != 'void':
       self.return_arg = CreateArg(info['return_type'] + " result")
     else:
       self.return_arg = None
 
     self.num_pointer_args = sum(
       [1 for arg in self.args_for_cmds if arg.IsPointer()])
+    if self.num_pointer_args > 0:
+      for arg in reversed(self.original_args):
+        if arg.IsPointer():
+          self.last_original_pointer_arg = arg
+          break
+    else:
+      self.last_original_pointer_arg = None
     self.info = info
     self.type_handler = self.type_handlers[info['type']]
     self.can_auto_generate = (self.num_pointer_args == 0 and
                               info['return_type'] == "void")
     self.InitFunction()
 
   def ParseArgs(self, arg_string):
     """Parses a function arg string."""
     args = []
     parts = arg_string.split(',')
@@ skipping 1885 matching lines @@
   Format(gen.generated_cpp_filenames)
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))