Home | History | Annotate | Download | only in compositor_model_bench 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/tools/compositor_model_bench/render_tree.h"
      6 
      7 #include <sstream>
      8 #include <vector>
      9 
     10 #include "base/files/file_path.h"
     11 #include "base/files/file_util.h"
     12 #include "base/json/json_reader.h"
     13 #include "base/json/json_writer.h"
     14 #include "base/logging.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/values.h"
     17 
     18 #include "gpu/tools/compositor_model_bench/shaders.h"
     19 
     20 using base::JSONReader;
     21 using base::JSONWriter;
     22 using base::ReadFileToString;
     23 using std::string;
     24 using std::vector;
     25 
     26 GLenum TextureFormatFromString(std::string format) {
     27   if (format == "RGBA")
     28     return GL_RGBA;
     29   if (format == "RGB")
     30     return GL_RGB;
     31   if (format == "LUMINANCE")
     32     return GL_LUMINANCE;
     33   return GL_INVALID_ENUM;
     34 }
     35 
     36 const char* TextureFormatName(GLenum format) {
     37   switch (format) {
     38     case GL_RGBA:
     39       return "RGBA";
     40     case GL_RGB:
     41       return "RGB";
     42     case GL_LUMINANCE:
     43       return "LUMINANCE";
     44     default:
     45       return "(unknown format)";
     46   }
     47 }
     48 
     49 int FormatBytesPerPixel(GLenum format) {
     50   switch (format) {
     51     case GL_RGBA:
     52       return 4;
     53     case GL_RGB:
     54       return 3;
     55     case GL_LUMINANCE:
     56       return 1;
     57     default:
     58       return 0;
     59   }
     60 }
     61 
     62 RenderNode::RenderNode() {
     63 }
     64 
     65 RenderNode::~RenderNode() {
     66 }
     67 
     68 void RenderNode::Accept(RenderNodeVisitor* v) {
     69   v->BeginVisitRenderNode(this);
     70   v->EndVisitRenderNode(this);
     71 }
     72 
     73 ContentLayerNode::ContentLayerNode() {
     74 }
     75 
     76 ContentLayerNode::~ContentLayerNode() {
     77 }
     78 
     79 void ContentLayerNode::Accept(RenderNodeVisitor* v) {
     80   v->BeginVisitContentLayerNode(this);
     81   typedef vector<RenderNode*>::iterator node_itr;
     82   for (node_itr i = children_.begin(); i != children_.end(); ++i) {
     83     (*i)->Accept(v);
     84   }
     85   v->EndVisitContentLayerNode(this);
     86 }
     87 
     88 CCNode::CCNode() {
     89 }
     90 
     91 CCNode::~CCNode() {
     92 }
     93 
     94 void CCNode::Accept(RenderNodeVisitor* v) {
     95   v->BeginVisitCCNode(this);
     96   v->EndVisitCCNode(this);
     97 }
     98 
     99 RenderNodeVisitor::~RenderNodeVisitor() {
    100 }
    101 
    102 void RenderNodeVisitor::BeginVisitContentLayerNode(ContentLayerNode* v) {
    103   this->BeginVisitRenderNode(v);
    104 }
    105 
    106 void RenderNodeVisitor::BeginVisitCCNode(CCNode* v) {
    107   this->BeginVisitRenderNode(v);
    108 }
    109 
    110 void RenderNodeVisitor::EndVisitRenderNode(RenderNode* v) {
    111 }
    112 
    113 void RenderNodeVisitor::EndVisitContentLayerNode(ContentLayerNode* v) {
    114   this->EndVisitRenderNode(v);
    115 }
    116 
    117 void RenderNodeVisitor::EndVisitCCNode(CCNode* v) {
    118   this->EndVisitRenderNode(v);
    119 }
    120 
    121 RenderNode* InterpretNode(base::DictionaryValue* node);
    122 
    123 std::string ValueTypeAsString(base::Value::Type type) {
    124   switch (type) {
    125     case base::Value::TYPE_NULL:
    126       return "NULL";
    127     case base::Value::TYPE_BOOLEAN:
    128       return "BOOLEAN";
    129     case base::Value::TYPE_INTEGER:
    130       return "INTEGER";
    131     case base::Value::TYPE_DOUBLE:
    132       return "DOUBLE";
    133     case base::Value::TYPE_STRING:
    134       return "STRING";
    135     case base::Value::TYPE_BINARY:
    136       return "BINARY";
    137     case base::Value::TYPE_DICTIONARY:
    138       return "DICTIONARY";
    139     case base::Value::TYPE_LIST:
    140       return "LIST";
    141     default:
    142       return "(UNKNOWN TYPE)";
    143   }
    144 }
    145 
    146 // Makes sure that the key exists and has the type we expect.
    147 bool VerifyDictionaryEntry(base::DictionaryValue* node,
    148                            const std::string& key,
    149                            base::Value::Type type) {
    150   if (!node->HasKey(key)) {
    151     LOG(ERROR) << "Missing value for key: " << key;
    152     return false;
    153   }
    154 
    155   base::Value* child;
    156   node->Get(key, &child);
    157   if (!child->IsType(type)) {
    158     LOG(ERROR) << key << " did not have the expected type "
    159       "(expected " << ValueTypeAsString(type) << ")";
    160     return false;
    161   }
    162 
    163   return true;
    164 }
    165 
    166 // Makes sure that the list entry has the type we expect.
    167 bool VerifyListEntry(base::ListValue* l,
    168                      int idx,
    169                      base::Value::Type type,
    170                      const char* listName = 0) {
    171   // Assume the idx is valid (since we'll be able to generate a better
    172   // error message for this elsewhere.)
    173   base::Value* el;
    174   l->Get(idx, &el);
    175   if (!el->IsType(type)) {
    176     LOG(ERROR) << (listName ? listName : "List") << "element " << idx <<
    177       " did not have the expected type (expected " <<
    178       ValueTypeAsString(type) << ")\n";
    179     return false;
    180   }
    181 
    182   return true;
    183 }
    184 
    185 bool InterpretCommonContents(base::DictionaryValue* node, RenderNode* c) {
    186   if (!VerifyDictionaryEntry(node, "layerID", base::Value::TYPE_INTEGER) ||
    187       !VerifyDictionaryEntry(node, "width", base::Value::TYPE_INTEGER) ||
    188       !VerifyDictionaryEntry(node, "height", base::Value::TYPE_INTEGER) ||
    189       !VerifyDictionaryEntry(node, "drawsContent", base::Value::TYPE_BOOLEAN) ||
    190       !VerifyDictionaryEntry(node, "targetSurfaceID",
    191                              base::Value::TYPE_INTEGER) ||
    192       !VerifyDictionaryEntry(node, "transform", base::Value::TYPE_LIST)
    193     ) {
    194     return false;
    195   }
    196 
    197   int layerID;
    198   node->GetInteger("layerID", &layerID);
    199   c->set_layerID(layerID);
    200   int width;
    201   node->GetInteger("width", &width);
    202   c->set_width(width);
    203   int height;
    204   node->GetInteger("height", &height);
    205   c->set_height(height);
    206   bool drawsContent;
    207   node->GetBoolean("drawsContent", &drawsContent);
    208   c->set_drawsContent(drawsContent);
    209   int targetSurface;
    210   node->GetInteger("targetSurfaceID", &targetSurface);
    211   c->set_targetSurface(targetSurface);
    212 
    213   base::ListValue* transform;
    214   node->GetList("transform", &transform);
    215   if (transform->GetSize() != 16) {
    216     LOG(ERROR) << "4x4 transform matrix did not have 16 elements";
    217     return false;
    218   }
    219   float transform_mat[16];
    220   for (int i = 0; i < 16; ++i) {
    221     if (!VerifyListEntry(transform, i, base::Value::TYPE_DOUBLE, "Transform"))
    222       return false;
    223     double el;
    224     transform->GetDouble(i, &el);
    225     transform_mat[i] = el;
    226   }
    227   c->set_transform(transform_mat);
    228 
    229   if (node->HasKey("tiles")) {
    230     if (!VerifyDictionaryEntry(node, "tiles", base::Value::TYPE_DICTIONARY))
    231       return false;
    232     base::DictionaryValue* tiles_dict;
    233     node->GetDictionary("tiles", &tiles_dict);
    234     if (!VerifyDictionaryEntry(tiles_dict, "dim", base::Value::TYPE_LIST))
    235       return false;
    236     base::ListValue* dim;
    237     tiles_dict->GetList("dim", &dim);
    238     if (!VerifyListEntry(dim, 0, base::Value::TYPE_INTEGER, "Tile dimension") ||
    239         !VerifyListEntry(dim, 1, base::Value::TYPE_INTEGER, "Tile dimension")) {
    240       return false;
    241     }
    242     int tile_width;
    243     dim->GetInteger(0, &tile_width);
    244     c->set_tile_width(tile_width);
    245     int tile_height;
    246     dim->GetInteger(1, &tile_height);
    247     c->set_tile_height(tile_height);
    248 
    249     if (!VerifyDictionaryEntry(tiles_dict, "info", base::Value::TYPE_LIST))
    250       return false;
    251     base::ListValue* tiles;
    252     tiles_dict->GetList("info", &tiles);
    253     for (unsigned int i = 0; i < tiles->GetSize(); ++i) {
    254       if (!VerifyListEntry(tiles, i, base::Value::TYPE_DICTIONARY, "Tile info"))
    255         return false;
    256       base::DictionaryValue* tdict;
    257       tiles->GetDictionary(i, &tdict);
    258 
    259       if (!VerifyDictionaryEntry(tdict, "x", base::Value::TYPE_INTEGER) ||
    260           !VerifyDictionaryEntry(tdict, "y", base::Value::TYPE_INTEGER)) {
    261         return false;
    262       }
    263       Tile t;
    264       tdict->GetInteger("x", &t.x);
    265       tdict->GetInteger("y", &t.y);
    266       if (tdict->HasKey("texID")) {
    267         if (!VerifyDictionaryEntry(tdict, "texID", base::Value::TYPE_INTEGER))
    268           return false;
    269         tdict->GetInteger("texID", &t.texID);
    270       } else {
    271         t.texID = -1;
    272       }
    273       c->add_tile(t);
    274     }
    275   }
    276   return true;
    277 }
    278 
    279 bool InterpretCCData(base::DictionaryValue* node, CCNode* c) {
    280   if (!VerifyDictionaryEntry(node, "vertex_shader", base::Value::TYPE_STRING) ||
    281       !VerifyDictionaryEntry(node, "fragment_shader",
    282                              base::Value::TYPE_STRING) ||
    283       !VerifyDictionaryEntry(node, "textures", base::Value::TYPE_LIST)) {
    284     return false;
    285   }
    286   string vertex_shader_name, fragment_shader_name;
    287   node->GetString("vertex_shader", &vertex_shader_name);
    288   node->GetString("fragment_shader", &fragment_shader_name);
    289 
    290   c->set_vertex_shader(ShaderIDFromString(vertex_shader_name));
    291   c->set_fragment_shader(ShaderIDFromString(fragment_shader_name));
    292   base::ListValue* textures;
    293   node->GetList("textures", &textures);
    294   for (unsigned int i = 0; i < textures->GetSize(); ++i) {
    295     if (!VerifyListEntry(textures, i, base::Value::TYPE_DICTIONARY, "Tex list"))
    296       return false;
    297     base::DictionaryValue* tex;
    298     textures->GetDictionary(i, &tex);
    299 
    300     if (!VerifyDictionaryEntry(tex, "texID", base::Value::TYPE_INTEGER) ||
    301         !VerifyDictionaryEntry(tex, "height", base::Value::TYPE_INTEGER) ||
    302         !VerifyDictionaryEntry(tex, "width", base::Value::TYPE_INTEGER) ||
    303         !VerifyDictionaryEntry(tex, "format", base::Value::TYPE_STRING)) {
    304       return false;
    305     }
    306     Texture t;
    307     tex->GetInteger("texID", &t.texID);
    308     tex->GetInteger("height", &t.height);
    309     tex->GetInteger("width", &t.width);
    310 
    311     string formatName;
    312     tex->GetString("format", &formatName);
    313     t.format = TextureFormatFromString(formatName);
    314     if (t.format == GL_INVALID_ENUM) {
    315       LOG(ERROR) << "Unrecognized texture format in layer " << c->layerID() <<
    316         " (format: " << formatName << ")\n"
    317         "The layer had " << textures->GetSize() << " children.";
    318       return false;
    319     }
    320 
    321     c->add_texture(t);
    322   }
    323 
    324   if (c->vertex_shader() == SHADER_UNRECOGNIZED) {
    325     LOG(ERROR) << "Unrecognized vertex shader name, layer " << c->layerID() <<
    326       " (shader: " << vertex_shader_name << ")";
    327     return false;
    328   }
    329 
    330   if (c->fragment_shader() == SHADER_UNRECOGNIZED) {
    331     LOG(ERROR) << "Unrecognized fragment shader name, layer " << c->layerID() <<
    332       " (shader: " << fragment_shader_name << ")";
    333     return false;
    334   }
    335 
    336   return true;
    337 }
    338 
    339 RenderNode* InterpretContentLayer(base::DictionaryValue* node) {
    340   ContentLayerNode* n = new ContentLayerNode;
    341   if (!InterpretCommonContents(node, n))
    342     return NULL;
    343 
    344   if (!VerifyDictionaryEntry(node, "type", base::Value::TYPE_STRING) ||
    345       !VerifyDictionaryEntry(node, "skipsDraw", base::Value::TYPE_BOOLEAN) ||
    346       !VerifyDictionaryEntry(node, "children", base::Value::TYPE_LIST)) {
    347     return NULL;
    348   }
    349 
    350   string type;
    351   node->GetString("type", &type);
    352   DCHECK_EQ(type, "ContentLayer");
    353   bool skipsDraw;
    354   node->GetBoolean("skipsDraw", &skipsDraw);
    355   n->set_skipsDraw(skipsDraw);
    356 
    357   base::ListValue* children;
    358   node->GetList("children", &children);
    359   for (unsigned int i = 0; i < children->GetSize(); ++i) {
    360     base::DictionaryValue* childNode;
    361     children->GetDictionary(i, &childNode);
    362     RenderNode* child = InterpretNode(childNode);
    363     if (child)
    364       n->add_child(child);
    365   }
    366 
    367   return n;
    368 }
    369 
    370 RenderNode* InterpretCanvasLayer(base::DictionaryValue* node) {
    371   CCNode* n = new CCNode;
    372   if (!InterpretCommonContents(node, n))
    373     return NULL;
    374 
    375   if (!VerifyDictionaryEntry(node, "type", base::Value::TYPE_STRING)) {
    376     return NULL;
    377   }
    378 
    379   string type;
    380   node->GetString("type", &type);
    381   assert(type == "CanvasLayer");
    382 
    383   if (!InterpretCCData(node, n))
    384     return NULL;
    385 
    386   return n;
    387 }
    388 
    389 RenderNode* InterpretVideoLayer(base::DictionaryValue* node) {
    390   CCNode* n = new CCNode;
    391   if (!InterpretCommonContents(node, n))
    392     return NULL;
    393 
    394   if (!VerifyDictionaryEntry(node, "type", base::Value::TYPE_STRING)) {
    395     return NULL;
    396   }
    397 
    398   string type;
    399   node->GetString("type", &type);
    400   assert(type == "VideoLayer");
    401 
    402   if (!InterpretCCData(node, n))
    403     return NULL;
    404 
    405   return n;
    406 }
    407 
    408 RenderNode* InterpretImageLayer(base::DictionaryValue* node) {
    409   CCNode* n = new CCNode;
    410   if (!InterpretCommonContents(node, n))
    411     return NULL;
    412 
    413   if (!VerifyDictionaryEntry(node, "type", base::Value::TYPE_STRING)) {
    414     return NULL;
    415   }
    416 
    417   string type;
    418   node->GetString("type", &type);
    419   assert(type == "ImageLayer");
    420 
    421   if (!InterpretCCData(node, n))
    422     return NULL;
    423 
    424   return n;
    425 }
    426 
    427 RenderNode* InterpretNode(base::DictionaryValue* node) {
    428   if (!VerifyDictionaryEntry(node, "type", base::Value::TYPE_STRING)) {
    429     return NULL;
    430   }
    431 
    432   string type;
    433   node->GetString("type", &type);
    434   if (type == "ContentLayer")
    435     return InterpretContentLayer(node);
    436   if (type == "CanvasLayer")
    437     return InterpretCanvasLayer(node);
    438   if (type == "VideoLayer")
    439     return InterpretVideoLayer(node);
    440   if (type == "ImageLayer")
    441     return InterpretImageLayer(node);
    442 
    443 
    444   string outjson;
    445   JSONWriter::WriteWithOptions(node, base::JSONWriter::OPTIONS_PRETTY_PRINT,
    446                                &outjson);
    447   LOG(ERROR) << "Unrecognized node type! JSON:\n\n"
    448       "-----------------------\n" <<
    449       outjson <<
    450       "-----------------------";
    451 
    452   return NULL;
    453 }
    454 
    455 RenderNode* BuildRenderTreeFromFile(const base::FilePath& path) {
    456   LOG(INFO) << "Reading " << path.LossyDisplayName();
    457   string contents;
    458   if (!ReadFileToString(path, &contents))
    459     return NULL;
    460 
    461   scoped_ptr<base::Value> root;
    462   int error_code = 0;
    463   string error_message;
    464   root.reset(JSONReader::ReadAndReturnError(contents,
    465             base::JSON_ALLOW_TRAILING_COMMAS,
    466             &error_code,
    467             &error_message));
    468   if (!root.get()) {
    469     LOG(ERROR) << "Failed to parse JSON file " << path.LossyDisplayName() <<
    470         "\n(" << error_message << ")";
    471     return NULL;
    472   }
    473 
    474   if (root->IsType(base::Value::TYPE_DICTIONARY)) {
    475     base::DictionaryValue* v = static_cast<base::DictionaryValue*>(root.get());
    476     RenderNode* tree = InterpretContentLayer(v);
    477     return tree;
    478   } else {
    479     LOG(ERROR) << path.LossyDisplayName() <<
    480         " doesn not encode a JSON dictionary.";
    481     return NULL;
    482   }
    483 }
    484 
    485