diff --git a/Makefile.common b/Makefile.common
index 688221c736..69b585701c 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -844,13 +844,14 @@ endif
 
 ifeq ($(HAVE_VIDEO_LAYOUT), 1)
    DEFINES += -DHAVE_VIDEO_LAYOUT
-   OBJ += gfx/video_layout.o \
-      gfx/video_layout/view.o \
-      gfx/video_layout/element.o \
-      gfx/video_layout/component.o \
-      gfx/video_layout/internal.o \
-      gfx/video_layout/scope.o \
-      gfx/video_layout/load.o
+   OBJ += \
+			 gfx/video_layout.o \
+			 gfx/video_layout/view.o \
+			 gfx/video_layout/element.o \
+			 gfx/video_layout/component.o \
+			 gfx/video_layout/internal.o \
+			 gfx/video_layout/scope.o \
+			 gfx/video_layout/load.o
 endif
 
 ifeq ($(HAVE_STB_FONT), 1)
diff --git a/gfx/video_layout/component.c b/gfx/video_layout/component.c
index b2d83b8ee1..713aeda34b 100644
--- a/gfx/video_layout/component.c
+++ b/gfx/video_layout/component.c
@@ -13,51 +13,51 @@ void component_init(component_t *comp, comp_type_t type)
 
    switch (comp->type)
    {
-   case VIDEO_LAYOUT_C_UNKNOWN:
-      break;
-   case VIDEO_LAYOUT_C_SCREEN:
-      comp->attr.screen.index = 0;
-      break;
-   case VIDEO_LAYOUT_C_RECT:
-      break;
-   case VIDEO_LAYOUT_C_DISK:
-      break;
-   case VIDEO_LAYOUT_C_IMAGE:
-      comp->attr.image.file = NULL;
-      comp->attr.image.alpha_file = NULL;
-      comp->attr.image.image_idx = 0;
-      comp->attr.image.alpha_idx = 0;
-      comp->attr.image.loaded = false;
-      break;
-   case VIDEO_LAYOUT_C_TEXT:
-      comp->attr.text.string = NULL;
-      comp->attr.text.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
-      break;
-   case VIDEO_LAYOUT_C_COUNTER:
-      comp->attr.counter.digits = 2;
-      comp->attr.counter.max_state = 999;
-      comp->attr.counter.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_X1:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H5:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H8:
-      break;
-   case VIDEO_LAYOUT_C_LED_7:
-      break;
-   case VIDEO_LAYOUT_C_LED_8_GTS1:
-      break;
-   case VIDEO_LAYOUT_C_LED_14:
-      break;
-   case VIDEO_LAYOUT_C_LED_14_SC:
-      break;
-   case VIDEO_LAYOUT_C_LED_16:
-      break;
-   case VIDEO_LAYOUT_C_LED_16_SC:
-      break;
-   case VIDEO_LAYOUT_C_REEL:
-      break;
+      case VIDEO_LAYOUT_C_UNKNOWN:
+         break;
+      case VIDEO_LAYOUT_C_SCREEN:
+         comp->attr.screen.index = 0;
+         break;
+      case VIDEO_LAYOUT_C_RECT:
+         break;
+      case VIDEO_LAYOUT_C_DISK:
+         break;
+      case VIDEO_LAYOUT_C_IMAGE:
+         comp->attr.image.file = NULL;
+         comp->attr.image.alpha_file = NULL;
+         comp->attr.image.image_idx = 0;
+         comp->attr.image.alpha_idx = 0;
+         comp->attr.image.loaded = false;
+         break;
+      case VIDEO_LAYOUT_C_TEXT:
+         comp->attr.text.string = NULL;
+         comp->attr.text.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
+         break;
+      case VIDEO_LAYOUT_C_COUNTER:
+         comp->attr.counter.digits = 2;
+         comp->attr.counter.max_state = 999;
+         comp->attr.counter.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_X1:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H5:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H8:
+         break;
+      case VIDEO_LAYOUT_C_LED_7:
+         break;
+      case VIDEO_LAYOUT_C_LED_8_GTS1:
+         break;
+      case VIDEO_LAYOUT_C_LED_14:
+         break;
+      case VIDEO_LAYOUT_C_LED_14_SC:
+         break;
+      case VIDEO_LAYOUT_C_LED_16:
+         break;
+      case VIDEO_LAYOUT_C_LED_16_SC:
+         break;
+      case VIDEO_LAYOUT_C_REEL:
+         break;
    }
 }
 
@@ -72,51 +72,51 @@ void component_copy(component_t *comp, const component_t *src)
 
    switch (comp->type)
    {
-   case VIDEO_LAYOUT_C_UNKNOWN:
-      break;
-   case VIDEO_LAYOUT_C_SCREEN:
-      comp->attr.screen.index = src->attr.screen.index;
-      break;
-   case VIDEO_LAYOUT_C_RECT:
-      break;
-   case VIDEO_LAYOUT_C_DISK:
-      break;
-   case VIDEO_LAYOUT_C_IMAGE:
-      comp->attr.image.file = init_string(src->attr.image.file);
-      comp->attr.image.alpha_file = init_string(src->attr.image.alpha_file);
-      comp->attr.image.image_idx = src->attr.image.image_idx;
-      comp->attr.image.alpha_idx = src->attr.image.alpha_idx;
-      comp->attr.image.loaded = src->attr.image.loaded;
-      break;
-   case VIDEO_LAYOUT_C_TEXT:
-      comp->attr.text.string = init_string(src->attr.text.string);
-      comp->attr.text.align = src->attr.text.align;
-      break;
-   case VIDEO_LAYOUT_C_COUNTER:
-      comp->attr.counter.digits = src->attr.counter.digits;
-      comp->attr.counter.max_state = src->attr.counter.max_state;
-      comp->attr.counter.align = src->attr.counter.align;
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_X1:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H5:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H8:
-      break;
-   case VIDEO_LAYOUT_C_LED_7:
-      break;
-   case VIDEO_LAYOUT_C_LED_8_GTS1:
-      break;
-   case VIDEO_LAYOUT_C_LED_14:
-      break;
-   case VIDEO_LAYOUT_C_LED_14_SC:
-      break;
-   case VIDEO_LAYOUT_C_LED_16:
-      break;
-   case VIDEO_LAYOUT_C_LED_16_SC:
-      break;
-   case VIDEO_LAYOUT_C_REEL:
-      break;
+      case VIDEO_LAYOUT_C_UNKNOWN:
+         break;
+      case VIDEO_LAYOUT_C_SCREEN:
+         comp->attr.screen.index = src->attr.screen.index;
+         break;
+      case VIDEO_LAYOUT_C_RECT:
+         break;
+      case VIDEO_LAYOUT_C_DISK:
+         break;
+      case VIDEO_LAYOUT_C_IMAGE:
+         comp->attr.image.file = init_string(src->attr.image.file);
+         comp->attr.image.alpha_file = init_string(src->attr.image.alpha_file);
+         comp->attr.image.image_idx = src->attr.image.image_idx;
+         comp->attr.image.alpha_idx = src->attr.image.alpha_idx;
+         comp->attr.image.loaded = src->attr.image.loaded;
+         break;
+      case VIDEO_LAYOUT_C_TEXT:
+         comp->attr.text.string = init_string(src->attr.text.string);
+         comp->attr.text.align = src->attr.text.align;
+         break;
+      case VIDEO_LAYOUT_C_COUNTER:
+         comp->attr.counter.digits = src->attr.counter.digits;
+         comp->attr.counter.max_state = src->attr.counter.max_state;
+         comp->attr.counter.align = src->attr.counter.align;
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_X1:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H5:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H8:
+         break;
+      case VIDEO_LAYOUT_C_LED_7:
+         break;
+      case VIDEO_LAYOUT_C_LED_8_GTS1:
+         break;
+      case VIDEO_LAYOUT_C_LED_14:
+         break;
+      case VIDEO_LAYOUT_C_LED_14_SC:
+         break;
+      case VIDEO_LAYOUT_C_LED_16:
+         break;
+      case VIDEO_LAYOUT_C_LED_16_SC:
+         break;
+      case VIDEO_LAYOUT_C_REEL:
+         break;
    }
 }
 
@@ -124,42 +124,42 @@ void component_deinit(component_t *comp)
 {
    switch (comp->type)
    {
-   case VIDEO_LAYOUT_C_UNKNOWN:
-      break;
-   case VIDEO_LAYOUT_C_SCREEN:
-      break;
-   case VIDEO_LAYOUT_C_RECT:
-      break;
-   case VIDEO_LAYOUT_C_DISK:
-      break;
-   case VIDEO_LAYOUT_C_IMAGE:
-      free(comp->attr.image.file);
-      free(comp->attr.image.alpha_file);
-      break;
-   case VIDEO_LAYOUT_C_TEXT:
-      free(comp->attr.text.string);
-      break;
-   case VIDEO_LAYOUT_C_COUNTER:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_X1:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H5:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H8:
-      break;
-   case VIDEO_LAYOUT_C_LED_7:
-      break;
-   case VIDEO_LAYOUT_C_LED_8_GTS1:
-      break;
-   case VIDEO_LAYOUT_C_LED_14:
-      break;
-   case VIDEO_LAYOUT_C_LED_14_SC:
-      break;
-   case VIDEO_LAYOUT_C_LED_16:
-      break;
-   case VIDEO_LAYOUT_C_LED_16_SC:
-      break;
-   case VIDEO_LAYOUT_C_REEL:
-      break;
+      case VIDEO_LAYOUT_C_UNKNOWN:
+         break;
+      case VIDEO_LAYOUT_C_SCREEN:
+         break;
+      case VIDEO_LAYOUT_C_RECT:
+         break;
+      case VIDEO_LAYOUT_C_DISK:
+         break;
+      case VIDEO_LAYOUT_C_IMAGE:
+         free(comp->attr.image.file);
+         free(comp->attr.image.alpha_file);
+         break;
+      case VIDEO_LAYOUT_C_TEXT:
+         free(comp->attr.text.string);
+         break;
+      case VIDEO_LAYOUT_C_COUNTER:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_X1:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H5:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H8:
+         break;
+      case VIDEO_LAYOUT_C_LED_7:
+         break;
+      case VIDEO_LAYOUT_C_LED_8_GTS1:
+         break;
+      case VIDEO_LAYOUT_C_LED_14:
+         break;
+      case VIDEO_LAYOUT_C_LED_14_SC:
+         break;
+      case VIDEO_LAYOUT_C_LED_16:
+         break;
+      case VIDEO_LAYOUT_C_LED_16_SC:
+         break;
+      case VIDEO_LAYOUT_C_REEL:
+         break;
    }
 }
diff --git a/gfx/video_layout/component.h b/gfx/video_layout/component.h
index a6797964a7..cc00fcaca4 100644
--- a/gfx/video_layout/component.h
+++ b/gfx/video_layout/component.h
@@ -23,8 +23,7 @@ typedef enum comp_type
    VIDEO_LAYOUT_C_LED_16,
    VIDEO_LAYOUT_C_LED_16_SC,
    VIDEO_LAYOUT_C_REEL
-}
-comp_type_t;
+} comp_type_t;
 
 union comp_attr
 {
@@ -43,8 +42,7 @@ typedef struct component
    video_layout_color_t       color;
    int                        enabled_state;
    union comp_attr            attr;
-}
-component_t;
+} component_t;
 
 void component_init   (component_t *comp, comp_type_t type);
 void component_copy   (component_t *comp, const component_t *src);
diff --git a/gfx/video_layout/component_attr.h b/gfx/video_layout/component_attr.h
index 703e093ce6..398a8177d7 100644
--- a/gfx/video_layout/component_attr.h
+++ b/gfx/video_layout/component_attr.h
@@ -4,8 +4,7 @@
 typedef struct c_attr_screen
 {
    int index;
-}
-c_attr_screen_t;
+} c_attr_screen_t;
 
 typedef struct c_attr_image
 {
@@ -14,22 +13,19 @@ typedef struct c_attr_image
    int   image_idx;
    int   alpha_idx;
    bool  loaded;
-}
-c_attr_image_t;
+} c_attr_image_t;
 
 typedef struct c_attr_text
 {
    char               *string;
    video_layout_text_align_t align;
-}
-c_attr_text_t;
+} c_attr_text_t;
 
 typedef struct c_attr_counter
 {
    int                 digits;
    int                 max_state;
    video_layout_text_align_t align;
-}
-c_attr_counter_t;
+} c_attr_counter_t;
 
 #endif
diff --git a/gfx/video_layout/element.c b/gfx/video_layout/element.c
index 929309a078..b907ffb75c 100644
--- a/gfx/video_layout/element.c
+++ b/gfx/video_layout/element.c
@@ -15,7 +15,7 @@ void element_init(element_t *elem, const char *name, int components_count)
    elem->render_bounds = make_bounds_unit();
 
    elem->components = (component_t*)(components_count > 0 ?
-      calloc(components_count, sizeof(component_t)) : NULL);
+         calloc(components_count, sizeof(component_t)) : NULL);
    elem->components_count = components_count;
 }
 
@@ -30,7 +30,7 @@ void element_copy(element_t *elem, const element_t *src)
    elem->render_bounds = src->render_bounds;
 
    elem->components = (component_t*)(src->components_count > 0 ?
-      calloc(src->components_count, sizeof(component_t)) : NULL);
+         calloc(src->components_count, sizeof(component_t)) : NULL);
 
    for (i = 0; i < src->components_count; ++i)
       component_copy(&elem->components[i], &src->components[i]);
@@ -40,7 +40,7 @@ void element_copy(element_t *elem, const element_t *src)
 
 void element_deinit(element_t *elem)
 {
-   int i;
+   unsigned i;
 
    for (i = 0; i < elem->components_count; ++i)
       component_deinit(&elem->components[i]);
@@ -51,12 +51,11 @@ void element_deinit(element_t *elem)
 
 void element_apply_orientation(element_t *elem, video_layout_orientation_t orientation)
 {
-   int i;
+   unsigned i;
 
    for (i = 0; i < elem->components_count; ++i)
    {
-      component_t *comp;
-      comp = &elem->components[i];
+      component_t *comp = &elem->components[i];
       comp->orientation ^= orientation;
 
       if (orientation & VIDEO_LAYOUT_SWAP_XY)
diff --git a/gfx/video_layout/element.h b/gfx/video_layout/element.h
index 52e12940cb..1cd18eea78 100644
--- a/gfx/video_layout/element.h
+++ b/gfx/video_layout/element.h
@@ -1,5 +1,6 @@
 #ifndef VIDEO_LAYOUT_ELEMENT_H
 #define VIDEO_LAYOUT_ELEMENT_H
+
 #include "internal.h"
 #include "component.h"
 
@@ -17,8 +18,7 @@ typedef struct element
 
    component_t     *components;
    int              components_count;
-}
-element_t;
+} element_t;
 
 void element_init              (element_t *elem, const char *name, int components_count);
 void element_copy              (element_t *elem, const element_t *src);
diff --git a/gfx/video_layout/internal.c b/gfx/video_layout/internal.c
index b54bc36550..1babdf1bbf 100644
--- a/gfx/video_layout/internal.c
+++ b/gfx/video_layout/internal.c
@@ -66,9 +66,7 @@ int get_int(const char *str)
 
 float get_dec(const char *str)
 {
-   float res;
-
-   res = 0.0f;
+   float res = 0.0f;
    sscanf(str, "%f", &res);
 
    return res;
@@ -152,12 +150,16 @@ video_layout_bounds_t make_bounds_unit(void)
    return bounds;
 }
 
-video_layout_bounds_t bounds_union(const video_layout_bounds_t *a, const video_layout_bounds_t *b)
+video_layout_bounds_t bounds_union(
+      const video_layout_bounds_t *a,
+      const video_layout_bounds_t *b)
 {
    video_layout_bounds_t bounds;
 
-   if (!bounds_valid(a)) return *b;
-   if (!bounds_valid(b)) return *a;
+   if (!bounds_valid(a))
+      return *b;
+   if (!bounds_valid(b))
+      return *a;
 
    bounds.x = MIN(a->x, b->x);
    bounds.y = MIN(a->y, b->y);
@@ -167,7 +169,9 @@ video_layout_bounds_t bounds_union(const video_layout_bounds_t *a, const video_l
    return bounds;
 }
 
-void bounds_scale(video_layout_bounds_t *dst, const video_layout_bounds_t *dim)
+void bounds_scale(
+      video_layout_bounds_t *dst,
+      const video_layout_bounds_t *dim)
 {
    dst->x *= dim->w;
    dst->y *= dim->h;
diff --git a/gfx/video_layout/load.c b/gfx/video_layout/load.c
index ccbe24689c..86f26aa011 100644
--- a/gfx/video_layout/load.c
+++ b/gfx/video_layout/load.c
@@ -52,10 +52,8 @@ static const char *const video_layout_internal_screen_params[] =
 
 static int child_count(rxml_node_t *node)
 {
-   int res;
    rxml_node_t *child;
-
-   res = 0;
+   int res = 0;
 
    for (child = node->children; child; child = child->next)
       ++res;
@@ -102,10 +100,8 @@ static void init_screen_params(scope_t *scope, int screen_index)
 
 static video_layout_bounds_t parse_bounds(scope_t *scope, rxml_node_t *node)
 {
-   video_layout_bounds_t bounds;
    const char *prop;
-
-   bounds = make_bounds_unit();
+   video_layout_bounds_t bounds = make_bounds_unit();
 
    if ((prop = scope_eval(scope, rxml_node_attrib(node, "x"))))       bounds.x = get_dec(prop);
    if ((prop = scope_eval(scope, rxml_node_attrib(node, "y"))))       bounds.y = get_dec(prop);
@@ -122,10 +118,8 @@ static video_layout_bounds_t parse_bounds(scope_t *scope, rxml_node_t *node)
 
 static video_layout_color_t parse_color(scope_t *scope, rxml_node_t *node)
 {
-   video_layout_color_t color;
    const char *prop;
-
-   color = make_color_white();
+   video_layout_color_t color = make_color_white();
 
    if ((prop = scope_eval(scope, rxml_node_attrib(node, "red"))))    color.r = get_dec(prop);
    if ((prop = scope_eval(scope, rxml_node_attrib(node, "green"))))  color.g = get_dec(prop);
@@ -137,10 +131,8 @@ static video_layout_color_t parse_color(scope_t *scope, rxml_node_t *node)
 
 static video_layout_orientation_t parse_orientation(scope_t *scope, rxml_node_t *node)
 {
-   video_layout_orientation_t result;
    const char *prop;
-
-   result = VIDEO_LAYOUT_ROT0;
+   video_layout_orientation_t result = VIDEO_LAYOUT_ROT0;
 
    if ((prop = scope_eval(scope, rxml_node_attrib(node, "rotate"))))
    {
@@ -223,14 +215,11 @@ static bool load_param(scope_t *scope, rxml_node_t *node, bool can_repeat)
 
 static bool load_component(scope_t *scope, component_t *comp, rxml_node_t *node)
 {
-   comp_type_t type;
-   bool result;
    const char *state;
    const char *attr;
    rxml_node_t *n;
-
-   type = comp_type_from_str(node->name);
-   result = true;
+   comp_type_t type = comp_type_from_str(node->name);
+   bool      result = true;
 
    if (type == VIDEO_LAYOUT_C_UNKNOWN)
    {
@@ -254,72 +243,72 @@ static bool load_component(scope_t *scope, component_t *comp, rxml_node_t *node)
 
    switch (comp->type)
    {
-   case VIDEO_LAYOUT_C_UNKNOWN:
-      break;
-   case VIDEO_LAYOUT_C_SCREEN:
-      break;
-   case VIDEO_LAYOUT_C_RECT:
-      break;
-   case VIDEO_LAYOUT_C_DISK:
-      break;
-   case VIDEO_LAYOUT_C_IMAGE:
-      {
-         if (!(attr = rxml_node_attrib(node, "file")))
+      case VIDEO_LAYOUT_C_UNKNOWN:
+         break;
+      case VIDEO_LAYOUT_C_SCREEN:
+         break;
+      case VIDEO_LAYOUT_C_RECT:
+         break;
+      case VIDEO_LAYOUT_C_DISK:
+         break;
+      case VIDEO_LAYOUT_C_IMAGE:
          {
-            RARCH_LOG("video_layout: invalid component <%s />, missing 'file' attribute\n", node->name);
-            result = false;
-         }
-         set_string(&comp->attr.image.file, scope_eval(scope, attr));
+            if (!(attr = rxml_node_attrib(node, "file")))
+            {
+               RARCH_LOG("video_layout: invalid component <%s />, missing 'file' attribute\n", node->name);
+               result = false;
+            }
+            set_string(&comp->attr.image.file, scope_eval(scope, attr));
 
-         if ((attr = rxml_node_attrib(node, "alphafile")))
-            set_string(&comp->attr.image.alpha_file, scope_eval(scope, attr));
-      }
-      break;
-   case VIDEO_LAYOUT_C_TEXT:
-      {
-         if (!(attr = rxml_node_attrib(node, "string")))
+            if ((attr = rxml_node_attrib(node, "alphafile")))
+               set_string(&comp->attr.image.alpha_file, scope_eval(scope, attr));
+         }
+         break;
+      case VIDEO_LAYOUT_C_TEXT:
          {
-            RARCH_LOG("video_layout: invalid component <%s />, missing 'string' attribute\n", node->name);
-            result = false;
+            if (!(attr = rxml_node_attrib(node, "string")))
+            {
+               RARCH_LOG("video_layout: invalid component <%s />, missing 'string' attribute\n", node->name);
+               result = false;
+            }
+            set_string(&comp->attr.text.string, scope_eval(scope, attr));
+
+            if ((attr = rxml_node_attrib(node, "align")))
+               comp->attr.text.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
          }
-         set_string(&comp->attr.text.string, scope_eval(scope, attr));
+         break;
+      case VIDEO_LAYOUT_C_COUNTER:
+         {
+            if ((attr = rxml_node_attrib(node, "digits")))
+               comp->attr.counter.digits = get_int(scope_eval(scope, attr));
 
-         if ((attr = rxml_node_attrib(node, "align")))
-            comp->attr.text.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
-      }
-      break;
-   case VIDEO_LAYOUT_C_COUNTER:
-      {
-         if ((attr = rxml_node_attrib(node, "digits")))
-            comp->attr.counter.digits = get_int(scope_eval(scope, attr));
+            if ((attr = rxml_node_attrib(node, "maxstate")))
+               comp->attr.counter.max_state = get_int(scope_eval(scope, attr));
 
-         if ((attr = rxml_node_attrib(node, "maxstate")))
-            comp->attr.counter.max_state = get_int(scope_eval(scope, attr));
-
-         if ((attr = rxml_node_attrib(node, "align")))
-            comp->attr.counter.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
-      }
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_X1:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H5:
-      break;
-   case VIDEO_LAYOUT_C_DOTMATRIX_H8:
-      break;
-   case VIDEO_LAYOUT_C_LED_7:
-      break;
-   case VIDEO_LAYOUT_C_LED_8_GTS1:
-      break;
-   case VIDEO_LAYOUT_C_LED_14:
-      break;
-   case VIDEO_LAYOUT_C_LED_14_SC:
-      break;
-   case VIDEO_LAYOUT_C_LED_16:
-      break;
-   case VIDEO_LAYOUT_C_LED_16_SC:
-      break;
-   case VIDEO_LAYOUT_C_REEL:
-      break;
+            if ((attr = rxml_node_attrib(node, "align")))
+               comp->attr.counter.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
+         }
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_X1:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H5:
+         break;
+      case VIDEO_LAYOUT_C_DOTMATRIX_H8:
+         break;
+      case VIDEO_LAYOUT_C_LED_7:
+         break;
+      case VIDEO_LAYOUT_C_LED_8_GTS1:
+         break;
+      case VIDEO_LAYOUT_C_LED_14:
+         break;
+      case VIDEO_LAYOUT_C_LED_14_SC:
+         break;
+      case VIDEO_LAYOUT_C_LED_16:
+         break;
+      case VIDEO_LAYOUT_C_LED_16_SC:
+         break;
+      case VIDEO_LAYOUT_C_REEL:
+         break;
    }
 
    return result;
@@ -329,13 +318,11 @@ static bool load_element(scope_t *scope, rxml_node_t *node)
 {
    const char *name;
    const char *state;
-   bool result;
    int i;
    element_t *elem;
    rxml_node_t *n;
    video_layout_bounds_t dim;
-
-   result = true;
+   bool result = true;
 
    if (!(name = rxml_node_attrib(node, "name")))
    {
@@ -394,10 +381,8 @@ static bool load_element(scope_t *scope, rxml_node_t *node)
 
 static bool load_screen(scope_t *scope, element_t *elem, rxml_node_t *node)
 {
-   const char *index;
    component_t *comp;
-
-   index = rxml_node_attrib(node, "index");
+   const char *index = rxml_node_attrib(node, "index");
 
    element_init(elem, NULL, 1);
    comp = &elem->components[0];
@@ -412,10 +397,8 @@ static bool load_screen(scope_t *scope, element_t *elem, rxml_node_t *node)
 static void merge_group(scope_t *scope, view_t *view, view_t *group,
    bool has_bounds, video_layout_bounds_t n_bounds, video_layout_orientation_t n_orient, video_layout_color_t n_color)
 {
-   bool constrain;
    int i, j, k;
-
-   constrain = bounds_valid(&n_bounds);
+   bool constrain = bounds_valid(&n_bounds);
 
    for (i = 0; i < group->layers_count; ++i)
    {
@@ -471,7 +454,7 @@ static bool load_view(scope_t *scope, view_t *view, rxml_node_t *node, bool is_n
       view_init(view, scope_eval(scope, name));
    }
 
-   result = true;
+   result     = true;
    has_bounds = false;
 
    for (n = node->children; n; n = n->next)
@@ -660,10 +643,8 @@ static bool load_group(scope_t *scope, rxml_node_t *node)
 
 static bool load_top_level(scope_t *scope, int *view_count, rxml_node_t *root)
 {
-   bool result;
    rxml_node_t *node;
-
-   result = true;
+   bool result = true;
    *view_count = 0;
 
    for (node = root->children; node; node = node->next)
@@ -695,12 +676,9 @@ static bool load_top_level(scope_t *scope, int *view_count, rxml_node_t *root)
 
 static bool load_views(scope_t *scope, view_array_t *view_array, rxml_node_t *root)
 {
-   bool result;
-   int i;
    rxml_node_t *node;
-
-   result = true;
-   i = 0;
+   bool result = true;
+   int i = 0;
 
    for (node = root->children; node; node = node->next)
    {
@@ -730,14 +708,12 @@ static bool load_views(scope_t *scope, view_array_t *view_array, rxml_node_t *ro
 bool load(view_array_t *view_array, rxml_document_t *doc)
 {
    bool result;
-   rxml_node_t *root;
    scope_t scope;
    int view_count;
-
-   root = rxml_root_node(doc);
+   rxml_node_t *root = rxml_root_node(doc);
 
    if (strcmp(root->name, "mamelayout") ||
-      strcmp(rxml_node_attrib(root, "version"), "2"))
+         strcmp(rxml_node_attrib(root, "version"), "2"))
    {
       RARCH_LOG("video_layout: invalid MAME Layout file\n");
       return false;
diff --git a/gfx/video_layout/scope.c b/gfx/video_layout/scope.c
index 0117114922..949dff38f5 100644
--- a/gfx/video_layout/scope.c
+++ b/gfx/video_layout/scope.c
@@ -38,15 +38,12 @@ static void param_deinit(param_t *param)
 
 static param_t *param_find(scope_t *scope, const char *name, int level)
 {
-   param_t *param;
-   param = scope->param;
+   param_t *param = scope->param;
 
    while (param && param->level >= level)
    {
       if (strcmp(param->name, name) == 0)
-      {
          return param;
-      }
       param = param->prev;
    }
 
@@ -55,15 +52,13 @@ static param_t *param_find(scope_t *scope, const char *name, int level)
 
 void scope_init(scope_t *scope)
 {
-   scope->level = 0;
+   scope->level          = 0;
 
-   scope->param = NULL;
-
-   scope->elements = NULL;
+   scope->param          = NULL;
+   scope->elements       = NULL;
    scope->elements_count = 0;
-
-   scope->groups = NULL;
-   scope->groups_count = 0;
+   scope->groups         = NULL;
+   scope->groups_count   = 0;
 }
 
 void scope_deinit(scope_t *scope)
@@ -114,7 +109,10 @@ void scope_repeat(scope_t *scope)
 {
    param_t *param;
 
-   for (param = scope->param; param && param->level >= scope->level; param = param->prev)
+   for (
+         param = scope->param;
+         param && param->level >= scope->level;
+         param = param->prev)
    {
       generator_t *gen;
       if ((gen = param->generator))
@@ -149,12 +147,9 @@ void scope_repeat(scope_t *scope)
 
 void scope_param(scope_t *scope, const char *name, const char *value)
 {
-   char *eval_name;
-   char *eval_value;
    param_t *param;
-
-   eval_name = init_string(scope_eval(scope, name));
-   eval_value = init_string(scope_eval(scope, value));
+   char *eval_name = init_string(scope_eval(scope, name));
+   char *eval_value = init_string(scope_eval(scope, value));
 
    if ((param = param_find(scope, eval_name, scope->level)))
    {
@@ -177,13 +172,11 @@ void scope_param(scope_t *scope, const char *name, const char *value)
 
 void scope_generator(scope_t *scope, const char *name, const char *start, const char *increment, const char *lshift, const char *rshift)
 {
-   char *e_name;
    char *e_val;
    char *e_inc;
    generator_t *gen;
    param_t *param;
-
-   e_name = init_string(scope_eval(scope, name));
+   char *e_name = init_string(scope_eval(scope, name));
 
    if (param_find(scope, e_name, scope->level))
    {
@@ -234,7 +227,6 @@ const char *scope_eval(scope_t *scope, const char *src)
 {
    const char* next;
    bool in_var;
-
    char tmp[SCOPE_BUFFER_SIZE];
 
    if (!src)
diff --git a/gfx/video_layout/scope.h b/gfx/video_layout/scope.h
index 44df38d95b..e8f6932fac 100644
--- a/gfx/video_layout/scope.h
+++ b/gfx/video_layout/scope.h
@@ -21,8 +21,7 @@ typedef struct scope
    int        groups_count;
 
    char       eval[SCOPE_BUFFER_SIZE];
-}
-scope_t;
+} scope_t;
 
 void        scope_init         (scope_t *scope);
 void        scope_deinit       (scope_t *scope);
diff --git a/gfx/video_layout/types.h b/gfx/video_layout/types.h
index b5af0729e3..3319be6212 100644
--- a/gfx/video_layout/types.h
+++ b/gfx/video_layout/types.h
@@ -1,7 +1,9 @@
 #ifndef VIDEO_LAYOUT_TYPES_H
 #define VIDEO_LAYOUT_TYPES_H
 
-typedef unsigned char video_layout_orientation_t;
+#include <stdint.h>
+
+typedef uint8_t video_layout_orientation_t;
 
 #define VIDEO_LAYOUT_FLIP_X  1
 #define VIDEO_LAYOUT_FLIP_Y  2
@@ -14,19 +16,17 @@ typedef unsigned char video_layout_orientation_t;
 
 typedef enum video_layout_blend
 {
-   VIDEO_LAYOUT_BLEND_ALPHA,
+   VIDEO_LAYOUT_BLEND_ALPHA = 0,
    VIDEO_LAYOUT_BLEND_ADD,
    VIDEO_LAYOUT_BLEND_MOD
-}
-video_layout_blend_t;
+} video_layout_blend_t;
 
 typedef enum video_layout_text_align
 {
-   VIDEO_LAYOUT_TEXT_ALIGN_CENTER,
+   VIDEO_LAYOUT_TEXT_ALIGN_CENTER = 0,
    VIDEO_LAYOUT_TEXT_ALIGN_LEFT,
    VIDEO_LAYOUT_TEXT_ALIGN_RIGHT
-}
-video_layout_text_align_t;
+} video_layout_text_align_t;
 
 typedef struct video_layout_color
 {
@@ -34,8 +34,7 @@ typedef struct video_layout_color
    float g;
    float b;
    float a;
-}
-video_layout_color_t;
+} video_layout_color_t;
 
 typedef struct video_layout_bounds
 {
@@ -43,7 +42,6 @@ typedef struct video_layout_bounds
    float y;
    float w;
    float h;
-}
-video_layout_bounds_t;
+} video_layout_bounds_t;
 
 #endif
diff --git a/gfx/video_layout/view.c b/gfx/video_layout/view.c
index 95faaf3c8d..2b77887170 100644
--- a/gfx/video_layout/view.c
+++ b/gfx/video_layout/view.c
@@ -26,7 +26,8 @@ element_t *layer_add_element(layer_t *layer)
 {
    element_t *elem;
 
-   vec_size((void**)&layer->elements, sizeof(element_t), ++layer->elements_count);
+   vec_size((void**)&layer->elements,
+         sizeof(element_t), ++layer->elements_count);
 
    elem = &layer->elements[layer->elements_count - 1];
    element_init(elem, NULL, 0);
@@ -36,12 +37,12 @@ element_t *layer_add_element(layer_t *layer)
 
 void view_init(view_t *view, const char *name)
 {
-   view->name = init_string(name);
-   view->bounds = make_bounds();
+   view->name          = init_string(name);
+   view->bounds        = make_bounds();
    view->render_bounds = make_bounds_unit();
-   view->layers = NULL;
-   view->layers_count = 0;
-   view->screens = NULL;
+   view->layers        = NULL;
+   view->layers_count  = 0;
+   view->screens       = NULL;
    view->screens_count = 0;
 }
 
@@ -197,9 +198,8 @@ void view_normalize(view_t *view)
 
 void view_count_screens(view_t *view)
 {
-   int idx, i, j, k;
-
-   idx = -1;
+   int i, j, k;
+   int idx = -1;
 
    for (i = 0; i < view->layers_count; ++i)
    {
diff --git a/gfx/video_layout/view.h b/gfx/video_layout/view.h
index 39820c072e..7b3708d25c 100644
--- a/gfx/video_layout/view.h
+++ b/gfx/video_layout/view.h
@@ -11,8 +11,7 @@ typedef struct layer
 
    element_t            *elements;
    int                   elements_count;
-}
-layer_t;
+} layer_t;
 
 typedef struct view
 {
@@ -25,15 +24,13 @@ typedef struct view
 
    video_layout_bounds_t *screens;
    int                    screens_count;
-}
-view_t;
+} view_t;
 
 typedef struct view_array
 {
    view_t *views;
    int     views_count;
-}
-view_array_t;
+} view_array_t;
 
 void       layer_init         (layer_t *layer, const char *name);
 void       layer_deinit       (layer_t *layer);
diff --git a/qb/config.params.sh b/qb/config.params.sh
index 8c6d4ef10c..62c86bfeef 100644
--- a/qb/config.params.sh
+++ b/qb/config.params.sh
@@ -28,7 +28,7 @@ HAVE_BUILTINMBEDTLS=auto   # Bake in the mbedtls library
 C89_BUILTINMBEDTLS=no
 CXX_BUILTINMBEDTLS=no
 HAVE_OVERLAY=yes           # Overlay support
-HAVE_VIDEO_LAYOUT=no       # Layout support
+HAVE_VIDEO_LAYOUT=yes      # Layout support
 HAVE_DYNAMIC=yes           # Dynamic loading of libretro library
 HAVE_SDL=auto              # SDL support
 C89_SDL=no