Initial checkin of the compositor_model_bench tool, which simulates the GPU demands of Chromium's...

gpu/tools/compositor_model_bench/render_tree.cc

+// Copyright (c) 2011 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.
+
+#include "gpu/tools/compositor_model_bench/render_tree.h"
+
+#include <sstream>
+#include <vector>
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+
+#include "gpu/tools/compositor_model_bench/shaders.h"
+
+using base::JSONReader;
+using base::JSONWriter;
+using base::Value;
+using file_util::ReadFileToString;
+using std::string;
+using std::vector;
+
+GLenum TextureFormatFromString(std::string format) {
+  if (format == "RGBA")
+    return GL_RGBA;
+  if (format == "RGB")
+    return GL_RGB;
+  if (format == "LUMINANCE")
+    return GL_LUMINANCE;
+  return GL_INVALID_ENUM;
+}
+
+const char* TextureFormatName(GLenum format) {
+  switch (format) {
+    case GL_RGBA:
+      return "RGBA";
+    case GL_RGB:
+      return "RGB";
+    case GL_LUMINANCE:
+      return "LUMINANCE";
+    default:
+      return "(unknown format)";
+  }
+}
+
+int FormatBytesPerPixel(GLenum format) {
+  switch (format) {
+    case GL_RGBA:
+      return 4;
+    case GL_RGB:
+      return 3;
+    case GL_LUMINANCE:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+void RenderNode::Accept(RenderNodeVisitor* v) {
+  v->BeginVisitRenderNode(this);
+  v->EndVisitRenderNode(this);
+}
+
+void ContentLayerNode::Accept(RenderNodeVisitor* v) {
+  v->BeginVisitContentLayerNode(this);
+  typedef vector<RenderNode*>::iterator node_itr;
+  for (node_itr i = children.begin(); i != children.end(); ++i) {
+    (*i)->Accept(v);
+  }
+  v->EndVisitContentLayerNode(this);
+}
+
+void CCNode::Accept(RenderNodeVisitor* v) {
+  v->BeginVisitCCNode(this);
+  v->EndVisitCCNode(this);
+}
+
+RenderNode* InterpretNode(DictionaryValue* node);
+
+std::string ValueTypeAsString(Value::Type type) {
+  switch (type) {
+    case Value::TYPE_NULL:
+      return "NULL";
+    case Value::TYPE_BOOLEAN:
+      return "BOOLEAN";
+    case Value::TYPE_INTEGER:
+      return "INTEGER";
+    case Value::TYPE_DOUBLE:
+      return "DOUBLE";
+    case Value::TYPE_STRING:
+      return "STRING";
+    case Value::TYPE_BINARY:
+      return "BINARY";
+    case Value::TYPE_DICTIONARY:
+      return "DICTIONARY";
+    case Value::TYPE_LIST:
+      return "LIST";
+    default:
+      return "(UNKNOWN TYPE)";
+  }
+}
+
+// Makes sure that the key exists and has the type we expect.
+bool VerifyDictionaryEntry(DictionaryValue* node,
+                           const std::string& key,
+                           Value::Type type) {
+  if (!node->HasKey(key)) {
+    LOG(ERROR) << "Missing value for key: " << key;
+    return false;
+  }
+
+  Value* child;
+  node->Get(key, &child);
+  if (!child->IsType(type)) {
+    LOG(ERROR) << key << " did not have the expected type "
+      "(expected " << ValueTypeAsString(type) << ")";
+    return false;
+  }
+
+  return true;
+}
+
+// Makes sure that the list entry has the type we expect.
+bool VerifyListEntry(ListValue* l,
+                     int idx,
+                     Value::Type type,
+                     const char* listName = 0) {
+  // Assume the idx is valid (since we'll be able to generate a better
+  // error message for this elsewhere.)
+  Value* el;
+  l->Get(idx, &el);
+  if (!el->IsType(type)) {
+    LOG(ERROR) << (listName ? listName : "List") << "element " << idx <<
+      " did not have the expected type (expected " <<
+      ValueTypeAsString(type) << ")\n";
+    return false;
+  }
+
+  return true;
+}
+
+bool InterpretCommonContents(DictionaryValue* node, RenderNode* c) {
+  if (!VerifyDictionaryEntry(node, "layerID", Value::TYPE_INTEGER) ||
+      !VerifyDictionaryEntry(node, "width", Value::TYPE_INTEGER) ||
+      !VerifyDictionaryEntry(node, "height", Value::TYPE_INTEGER) ||
+      !VerifyDictionaryEntry(node, "drawsContent", Value::TYPE_BOOLEAN) ||
+      !VerifyDictionaryEntry(node, "targetSurfaceID", Value::TYPE_INTEGER) ||
+      !VerifyDictionaryEntry(node, "transform", Value::TYPE_LIST)
+    ) {
+    return false;
+  }
+
+  node->GetInteger("layerID", &c->layerID);
+  node->GetInteger("width", &c->width);
+  node->GetInteger("height", &c->height);
+  node->GetBoolean("drawsContent", &c->drawsContent);
+  node->GetInteger("targetSurfaceID", &c->targetSurface);
+  ListValue* transform;
+  node->GetList("transform", &transform);
+  if (transform->GetSize() != 16) {
+    LOG(ERROR) << "4x4 transform matrix did not have 16 elements";
+    return false;
+  }
+  for (int i = 0; i < 16; ++i) {
+    if (!VerifyListEntry(transform, i, Value::TYPE_DOUBLE, "Transform"))
+      return false;
+    double el;
+    transform->GetDouble(i, &el);
+    c->transform[i] = el;
+  }
+  if (node->HasKey("tiles")) {
+    if (!VerifyDictionaryEntry(node, "tiles", Value::TYPE_DICTIONARY))
+      return false;
+    DictionaryValue* tiles_dict;
+    node->GetDictionary("tiles", &tiles_dict);
+    if (!VerifyDictionaryEntry(tiles_dict, "dim", Value::TYPE_LIST))
+      return false;
+    ListValue* dim;
+    tiles_dict->GetList("dim", &dim);
+    if (!VerifyListEntry(dim, 0, Value::TYPE_INTEGER, "Tile dimension") ||
+        !VerifyListEntry(dim, 1, Value::TYPE_INTEGER, "Tile dimension")) {
+      return false;
+    }
+    dim->GetInteger(0, &c->tile_width);
+    dim->GetInteger(1, &c->tile_height);
+
+    if (!VerifyDictionaryEntry(tiles_dict, "info", Value::TYPE_LIST))
+      return false;
+    ListValue* tiles;
+    tiles_dict->GetList("info", &tiles);
+    for (unsigned int i = 0; i < tiles->GetSize(); ++i) {
+      if (!VerifyListEntry(tiles, i, Value::TYPE_DICTIONARY, "Tile info"))
+        return false;
+      DictionaryValue* tdict;
+      tiles->GetDictionary(i, &tdict);
+
+      if (!VerifyDictionaryEntry(tdict, "x", Value::TYPE_INTEGER) ||
+          !VerifyDictionaryEntry(tdict, "y", Value::TYPE_INTEGER)) {
+        return false;
+      }
+      Tile t;
+      tdict->GetInteger("x", &t.x);
+      tdict->GetInteger("y", &t.y);
+      if (tdict->HasKey("texID")) {
+        if (!VerifyDictionaryEntry(tdict, "texID", Value::TYPE_INTEGER))
+          return false;
+        tdict->GetInteger("texID", &t.texID);
+      } else {
+        t.texID = -1;
+      }
+      c->tiles.push_back(t);
+    }
+  }
+  return true;
+}
+
+bool InterpretCCData(DictionaryValue* node, CCNode* c) {
+  if (!VerifyDictionaryEntry(node, "vertex_shader", Value::TYPE_STRING) ||
+      !VerifyDictionaryEntry(node, "fragment_shader", Value::TYPE_STRING) ||
+      !VerifyDictionaryEntry(node, "textures", Value::TYPE_LIST)
+    ) {

[piman, 2011/08/26 02:24:16]

nit: the ')' (and the '{' with it) should be on the previous line.

+    return false;
+  }
+  string vertex_shader_name, fragment_shader_name;
+  node->GetString("vertex_shader", &vertex_shader_name);
+  node->GetString("fragment_shader", &fragment_shader_name);
+
+  c->vertex_shader = ShaderIDFromString(vertex_shader_name);
+  c->fragment_shader = ShaderIDFromString(fragment_shader_name);
+  ListValue* textures;
+  node->GetList("textures", &textures);
+  for (unsigned int i = 0; i < textures->GetSize(); ++i) {
+    if (!VerifyListEntry(textures, i, Value::TYPE_DICTIONARY, "Tex list"))
+      return false;
+    DictionaryValue* tex;
+    textures->GetDictionary(i, &tex);
+
+    if (!VerifyDictionaryEntry(tex, "texID", Value::TYPE_INTEGER) ||
+        !VerifyDictionaryEntry(tex, "height", Value::TYPE_INTEGER) ||
+        !VerifyDictionaryEntry(tex, "width", Value::TYPE_INTEGER) ||
+        !VerifyDictionaryEntry(tex, "format", Value::TYPE_STRING)
+      ) {

[piman, 2011/08/26 02:24:16]

nit: the ')' (and the '{' with it) should be on the previous line.

+      return false;
+    }
+    Texture t;
+    tex->GetInteger("texID", &t.texID);
+    tex->GetInteger("height", &t.height);
+    tex->GetInteger("width", &t.width);
+
+    string formatName;
+    tex->GetString("format", &formatName);
+    t.format = TextureFormatFromString(formatName);
+    if (t.format == GL_INVALID_ENUM) {
+      LOG(ERROR) << "Unrecognized texture format in layer " << c->layerID <<
+        " (format: " << formatName << ")\n"
+        "The layer had " << textures->GetSize() << " children.";
+      return false;
+    }
+
+    c->textures.push_back(t);
+  }
+
+  if (c->vertex_shader == SHADER_UNRECOGNIZED) {
+    LOG(ERROR) << "Unrecognized vertex shader name, layer " << c->layerID <<
+      " (shader: " << vertex_shader_name << ")";
+    return false;
+  }
+
+  if (c->fragment_shader == SHADER_UNRECOGNIZED) {
+    LOG(ERROR) << "Unrecognized fragment shader name, layer " << c->layerID <<
+      " (shader: " << fragment_shader_name << ")";
+    return false;
+  }
+
+  return true;
+}
+
+RenderNode* InterpretContentLayer(DictionaryValue* node) {
+  ContentLayerNode* n = new ContentLayerNode;
+  if (!InterpretCommonContents(node, n))
+    return NULL;
+
+  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING) ||
+      !VerifyDictionaryEntry(node, "skipsDraw", Value::TYPE_BOOLEAN) ||
+      !VerifyDictionaryEntry(node, "children", Value::TYPE_LIST)
+    ) {

[piman, 2011/08/26 02:24:16]

nit: the ')' (and the '{' with it) should be on the previous line.

+    return false;
+  }
+
+  string type;
+  node->GetString("type", &type);
+  DCHECK_EQ(type, "ContentLayer");
+  node->GetBoolean("skipsDraw", &n->skipsDraw);
+
+  ListValue* children;
+  node->GetList("children", &children);
+  for (unsigned int i = 0; i < children->GetSize(); ++i) {
+    DictionaryValue* childNode;
+    children->GetDictionary(i, &childNode);
+    RenderNode* child = InterpretNode(childNode);
+    if (child)
+      n->children.push_back(child);
+  }
+
+  return n;
+}
+
+RenderNode* InterpretCanvasLayer(DictionaryValue* node) {
+  CCNode* n = new CCNode;
+  if (!InterpretCommonContents(node, n))
+    return NULL;
+
+  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING)) {
+    return NULL;
+  }
+
+  string type;
+  node->GetString("type", &type);
+  assert(type == "CanvasLayer");
+
+  if (!InterpretCCData(node, n))
+    return NULL;
+
+  return n;
+}
+
+RenderNode* InterpretVideoLayer(DictionaryValue* node) {
+  CCNode* n = new CCNode;
+  if (!InterpretCommonContents(node, n))
+    return NULL;
+
+  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING)) {
+    return NULL;
+  }
+
+  string type;
+  node->GetString("type", &type);
+  assert(type == "VideoLayer");
+
+  if (!InterpretCCData(node, n))
+    return NULL;
+
+  return n;
+}
+
+RenderNode* InterpretImageLayer(DictionaryValue* node) {
+  CCNode* n = new CCNode;
+  if (!InterpretCommonContents(node, n))
+    return NULL;
+
+  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING)) {
+    return NULL;
+  }
+
+  string type;
+  node->GetString("type", &type);
+  assert(type == "ImageLayer");
+
+  if (!InterpretCCData(node, n))
+    return NULL;
+
+  return n;
+}
+
+RenderNode* InterpretNode(DictionaryValue* node) {
+  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING)) {
+    return NULL;
+  }
+
+  string type;
+  node->GetString("type", &type);
+  if (type == "ContentLayer")
+    return InterpretContentLayer(node);
+  if (type == "CanvasLayer")
+    return InterpretCanvasLayer(node);
+  if (type == "VideoLayer")
+    return InterpretVideoLayer(node);
+  if (type == "ImageLayer")
+    return InterpretImageLayer(node);
+
+
+  string outjson;
+  JSONWriter::Write(node, true, &outjson);
+  LOG(ERROR) << "Unrecognized node type! JSON:\n\n"
+    "-----------------------\n" <<

[piman, 2011/08/26 02:24:16]

nit: indent (4 spaces)

+    outjson <<
+    "-----------------------";
+
+  return NULL;
+}
+
+RenderNode* BuildRenderTreeFromFile(const FilePath& path) {
+  LOG(INFO) << "Reading " << path.LossyDisplayName();
+  string contents;
+  if (!ReadFileToString(path, &contents))
+    return NULL;
+
+  scoped_ptr<Value> root;
+  int error_code = 0;
+  string error_message;
+  root.reset(JSONReader::ReadAndReturnError(contents,
+            true,
+            &error_code,
+            &error_message));
+  if (!root.get()) {
+    LOG(ERROR) << "Failed to parse JSON file " << path.LossyDisplayName() <<
+      "\n(" << error_message << ")";

[piman, 2011/08/26 02:24:16]

nit: 4 spaces

+    return NULL;
+  }
+
+  if (root->IsType(Value::TYPE_DICTIONARY)) {
+    DictionaryValue* v = static_cast<DictionaryValue*>(root.get());
+    RenderNode* tree = InterpretContentLayer(v);
+    return tree;
+  } else {
+    LOG(ERROR) << path.LossyDisplayName() <<
+      " doesn not encode a JSON dictionary.";

[piman, 2011/08/26 02:24:16]

nit: 4 spaces

+    return NULL;
+  }
+}
+