diff --git a/gfx/drivers_shader/shader_gl_cg.c b/gfx/drivers_shader/shader_gl_cg.c
index 6f4d24440b..d9e6315dd7 100644
--- a/gfx/drivers_shader/shader_gl_cg.c
+++ b/gfx/drivers_shader/shader_gl_cg.c
@@ -68,7 +68,7 @@ struct cg_fbo_params
    CGparameter coord;
 };
 
-struct shader_program_cg_data
+struct shader_program_cg
 {
    CGprogram vprg;
    CGprogram fprg;
@@ -109,22 +109,22 @@ typedef struct cg_shader_data
 
    CGprofile cgVProf;
    CGprofile cgFProf;
-   struct shader_program_cg_data prg[GFX_MAX_SHADERS];
+   struct shader_program_cg prg[GFX_MAX_SHADERS];
    GLuint lut_textures[GFX_MAX_TEXTURES];
    state_tracker_t *state_tracker;
    CGcontext cgCtx;
 } cg_shader_data_t;
 
-struct uniform_cg_data
+struct uniform_cg
 {
    CGparameter loc;
 };
 
-#define gl_cg_set_coord_array(param, cg_data, ptr, len) \
+#define gl_cg_set_coord_array(param, cg, ptr, len) \
 { \
    cgGLSetParameterPointer(param, len, GL_FLOAT, 0, ptr); \
    cgGLEnableClientState(param); \
-   cg_data->attribs.elems[cg_data->attribs.index++] = param; \
+   cg->attribs.elems[cg->attribs.index++] = param; \
 }
 
 #define cg_gl_set_texture_parameter(param, texture) \
@@ -143,7 +143,7 @@ static void gl_cg_set_uniform_parameter(
       void *uniform_data)
 {
    CGparameter location;
-   cg_shader_data_t *cg_data        = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg        = (cg_shader_data_t*)data;
 
    if (!param || !param->enabled)
       return;
@@ -156,11 +156,11 @@ static void gl_cg_set_uniform_parameter(
       switch (param->lookup.type)
       {
          case SHADER_PROGRAM_VERTEX:
-            prog = cg_data->prg[param->lookup.idx].vprg;
+            prog = cg->prg[param->lookup.idx].vprg;
             break;
          case SHADER_PROGRAM_FRAGMENT:
          default:
-            prog = cg_data->prg[param->lookup.idx].fprg;
+            prog = cg->prg[param->lookup.idx].fprg;
             break;
       }
 
@@ -170,7 +170,7 @@ static void gl_cg_set_uniform_parameter(
    }
    else
    {
-      struct uniform_cg_data *cg_param = (struct uniform_cg_data*)uniform_data;
+      struct uniform_cg *cg_param = (struct uniform_cg*)uniform_data;
       location = cg_param->loc;
    }
 
@@ -236,23 +236,23 @@ static void cg_error_handler(CGcontext ctx, CGerror error, void *data)
 static void gl_cg_reset_attrib(void *data)
 {
    unsigned i;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
    /* Add sanity check that we did not overflow. */
-   retro_assert(cg_data->attribs.index <= ARRAY_SIZE(cg_data->attribs.elems));
+   retro_assert(cg->attribs.index <= ARRAY_SIZE(cg->attribs.elems));
 
-   for (i = 0; i < cg_data->attribs.index; i++)
-      cgGLDisableClientState(cg_data->attribs.elems[i]);
-   cg_data->attribs.index = 0;
+   for (i = 0; i < cg->attribs.index; i++)
+      cgGLDisableClientState(cg->attribs.elems[i]);
+   cg->attribs.index = 0;
 }
 
 static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
-   if (!cg_data || !cg_data->prg[cg_data->active_idx].mvp)
+   cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
+   if (!cg || !cg->prg[cg->active_idx].mvp)
       goto fallback;
 
-   cgGLSetMatrixParameterfc(cg_data->prg[cg_data->active_idx].mvp, mat->data);
+   cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
    return true;
 
 fallback:
@@ -262,22 +262,22 @@ fallback:
 
 static bool gl_cg_set_coords(void *handle_data, void *shader_data, const struct gfx_coords *coords)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
 
-   if (!cg_data || !coords)
+   if (!cg || !coords)
       goto fallback;
 
-   if (cg_data->prg[cg_data->active_idx].vertex)
-      gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].vertex, cg_data, coords->vertex, 2);
+   if (cg->prg[cg->active_idx].vertex)
+      gl_cg_set_coord_array(cg->prg[cg->active_idx].vertex, cg, coords->vertex, 2);
 
-   if (cg_data->prg[cg_data->active_idx].tex)
-      gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].tex, cg_data, coords->tex_coord, 2);
+   if (cg->prg[cg->active_idx].tex)
+      gl_cg_set_coord_array(cg->prg[cg->active_idx].tex, cg, coords->tex_coord, 2);
 
-   if (cg_data->prg[cg_data->active_idx].lut_tex)
-      gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].lut_tex, cg_data, coords->lut_tex_coord, 2);
+   if (cg->prg[cg->active_idx].lut_tex)
+      gl_cg_set_coord_array(cg->prg[cg->active_idx].lut_tex, cg, coords->lut_tex_coord, 2);
 
-   if (cg_data->prg[cg_data->active_idx].color)
-      gl_cg_set_coord_array(cg_data->prg[cg_data->active_idx].color, cg_data, coords->color, 4);
+   if (cg->prg[cg->active_idx].color)
+      gl_cg_set_coord_array(cg->prg[cg->active_idx].color, cg, coords->color, 4);
 
    return true;
 
@@ -287,12 +287,12 @@ fallback:
 }
 
 static void gl_cg_set_texture_info(
-      cg_shader_data_t *cg_data, 
+      cg_shader_data_t *cg, 
       const struct cg_fbo_params *params,
       const struct gfx_tex_info *info)
 {
    unsigned i;
-   struct uniform_cg_data uniform_data[4];
+   struct uniform_cg uniform_data[4];
    struct uniform_info uniform_params[4] = {0};
    CGparameter param                     = params->tex;
 
@@ -327,10 +327,10 @@ static void gl_cg_set_texture_info(
    uniform_data[3].loc             = params->tex_size_f;
 
    for (i = 0; i < 4; i++)
-      gl_cg_set_uniform_parameter(cg_data, &uniform_params[i], &uniform_data[i]);
+      gl_cg_set_uniform_parameter(cg, &uniform_params[i], &uniform_data[i]);
 
    if (params->coord)
-      gl_cg_set_coord_array(params->coord, cg_data, info->coord, 2);
+      gl_cg_set_coord_array(params->coord, cg, info->coord, 2);
 }
 
 static void gl_cg_set_params(void *data, void *shader_data,
@@ -345,18 +345,18 @@ static void gl_cg_set_params(void *data, void *shader_data,
       unsigned fbo_info_cnt)
 {
    unsigned i;
-   struct uniform_cg_data uniform_data[10];
+   struct uniform_cg uniform_data[10];
    struct uniform_info uniform_params[10] = {0};
    unsigned uniform_count                   = 0;
    const struct gfx_tex_info *info          = (const struct gfx_tex_info*)_info;
    const struct gfx_tex_info *prev_info     = (const struct gfx_tex_info*)_prev_info;
    const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info;
    const struct gfx_tex_info *fbo_info      = (const struct gfx_tex_info*)_fbo_info;
-   cg_shader_data_t *cg_data                = (cg_shader_data_t*)shader_data;
+   cg_shader_data_t *cg                = (cg_shader_data_t*)shader_data;
 
-   if (!cg_data || (cg_data->active_idx == 0))
+   if (!cg || (cg->active_idx == 0))
          return;
-   if (cg_data->active_idx == VIDEO_SHADER_STOCK_BLEND)
+   if (cg->active_idx == VIDEO_SHADER_STOCK_BLEND)
       return;
 
    /* Set frame. */
@@ -365,60 +365,60 @@ static void gl_cg_set_params(void *data, void *shader_data,
    uniform_params[0].type          = UNIFORM_2F;
    uniform_params[0].result.f.v0   = width;
    uniform_params[0].result.f.v1   = height;
-   uniform_data[0].loc             = cg_data->prg[cg_data->active_idx].vid_size_f;
+   uniform_data[0].loc             = cg->prg[cg->active_idx].vid_size_f;
    
    uniform_params[1].location      = 1;
    uniform_params[1].enabled       = true;
    uniform_params[1].type          = UNIFORM_2F;
    uniform_params[1].result.f.v0   = tex_width;
    uniform_params[1].result.f.v1   = tex_height;
-   uniform_data[1].loc             = cg_data->prg[cg_data->active_idx].tex_size_f;
+   uniform_data[1].loc             = cg->prg[cg->active_idx].tex_size_f;
 
    uniform_params[2].location      = 2;
    uniform_params[2].enabled       = true;
    uniform_params[2].type          = UNIFORM_2F;
    uniform_params[2].result.f.v0   = out_width;
    uniform_params[2].result.f.v1   = out_height;
-   uniform_data[2].loc             = cg_data->prg[cg_data->active_idx].out_size_f;
+   uniform_data[2].loc             = cg->prg[cg->active_idx].out_size_f;
 
    uniform_params[3].location      = 3;
    uniform_params[3].enabled       = true;
    uniform_params[3].type          = UNIFORM_1F;
    uniform_params[3].result.f.v0   = state_manager_frame_is_reversed() ? -1.0 : 1.0;
-   uniform_data[3].loc             = cg_data->prg[cg_data->active_idx].frame_dir_f;
+   uniform_data[3].loc             = cg->prg[cg->active_idx].frame_dir_f;
 
    uniform_params[4].location      = 4;
    uniform_params[4].enabled       = true;
    uniform_params[4].type          = UNIFORM_2F;
    uniform_params[4].result.f.v0   = width;
    uniform_params[4].result.f.v1   = height;
-   uniform_data[4].loc             = cg_data->prg[cg_data->active_idx].vid_size_v;
+   uniform_data[4].loc             = cg->prg[cg->active_idx].vid_size_v;
 
    uniform_params[5].location      = 5;
    uniform_params[5].enabled       = true;
    uniform_params[5].type          = UNIFORM_2F;
    uniform_params[5].result.f.v0   = tex_width;
    uniform_params[5].result.f.v1   = tex_height;
-   uniform_data[5].loc             = cg_data->prg[cg_data->active_idx].tex_size_v;
+   uniform_data[5].loc             = cg->prg[cg->active_idx].tex_size_v;
 
    uniform_params[6].location      = 6;
    uniform_params[6].enabled       = true;
    uniform_params[6].type          = UNIFORM_2F;
    uniform_params[6].result.f.v0   = out_width;
    uniform_params[6].result.f.v1   = out_height;
-   uniform_data[6].loc             = cg_data->prg[cg_data->active_idx].out_size_v;
+   uniform_data[6].loc             = cg->prg[cg->active_idx].out_size_v;
 
    uniform_params[7].location      = 7;
    uniform_params[7].enabled       = true;
    uniform_params[7].type          = UNIFORM_1F;
    uniform_params[7].result.f.v0   = state_manager_frame_is_reversed() ? -1.0 : 1.0;
-   uniform_data[7].loc             = cg_data->prg[cg_data->active_idx].frame_dir_v;
+   uniform_data[7].loc             = cg->prg[cg->active_idx].frame_dir_v;
 
    uniform_count += 8;
 
-   if (cg_data->prg[cg_data->active_idx].frame_cnt_f || cg_data->prg[cg_data->active_idx].frame_cnt_v)
+   if (cg->prg[cg->active_idx].frame_cnt_f || cg->prg[cg->active_idx].frame_cnt_v)
    {
-      unsigned modulo = cg_data->shader->pass[cg_data->active_idx - 1].frame_count_mod;
+      unsigned modulo = cg->shader->pass[cg->active_idx - 1].frame_count_mod;
       if (modulo)
          frame_count %= modulo;
 
@@ -426,51 +426,51 @@ static void gl_cg_set_params(void *data, void *shader_data,
       uniform_params[8].enabled       = true;
       uniform_params[8].type          = UNIFORM_1F;
       uniform_params[8].result.f.v0   = (float)frame_count;
-      uniform_data[8].loc             = cg_data->prg[cg_data->active_idx].frame_cnt_f;
+      uniform_data[8].loc             = cg->prg[cg->active_idx].frame_cnt_f;
 
       uniform_params[9].location      = 9;
       uniform_params[9].enabled       = true;
       uniform_params[9].type          = UNIFORM_1F;
       uniform_params[9].result.f.v0   = (float)frame_count;
-      uniform_data[9].loc             = cg_data->prg[cg_data->active_idx].frame_cnt_v;
+      uniform_data[9].loc             = cg->prg[cg->active_idx].frame_cnt_v;
 
       uniform_count += 2;
    }
 
    for (i = 0; i < uniform_count; i++)
-      gl_cg_set_uniform_parameter(cg_data, &uniform_params[i], &uniform_data[i]);
+      gl_cg_set_uniform_parameter(cg, &uniform_params[i], &uniform_data[i]);
 
    /* Set orig texture. */
-   gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].orig, info);
+   gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].orig, info);
 
    /* Set feedback texture. */
-   gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].feedback, feedback_info);
+   gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].feedback, feedback_info);
 
    /* Set previous textures. */
    for (i = 0; i < PREV_TEXTURES; i++)
-      gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]);
+      gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].prev[i], &prev_info[i]);
 
    /* Set lookup textures. */
-   for (i = 0; i < cg_data->shader->luts; i++)
+   for (i = 0; i < cg->shader->luts; i++)
    {
       CGparameter fparam = cgGetNamedParameter(
-            cg_data->prg[cg_data->active_idx].fprg, cg_data->shader->lut[i].id);
-      CGparameter vparam = cgGetNamedParameter(cg_data->prg[cg_data->active_idx].vprg,
-		  cg_data->shader->lut[i].id);
+            cg->prg[cg->active_idx].fprg, cg->shader->lut[i].id);
+      CGparameter vparam = cgGetNamedParameter(cg->prg[cg->active_idx].vprg,
+		  cg->shader->lut[i].id);
 
-      cg_gl_set_texture_parameter(fparam, cg_data->lut_textures[i]);
-      cg_gl_set_texture_parameter(vparam, cg_data->lut_textures[i]);
+      cg_gl_set_texture_parameter(fparam, cg->lut_textures[i]);
+      cg_gl_set_texture_parameter(vparam, cg->lut_textures[i]);
    }
 
    /* Set FBO textures. */
-   if (cg_data->active_idx)
+   if (cg->active_idx)
    {
       for (i = 0; i < fbo_info_cnt; i++)
-         gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]);
+         gl_cg_set_texture_info(cg, &cg->prg[cg->active_idx].fbo[i], &fbo_info[i]);
    }
 
    /* #pragma parameters. */
-   for (i = 0; i < cg_data->shader->num_parameters; i++)
+   for (i = 0; i < cg->shader->num_parameters; i++)
    {
       unsigned j;
 
@@ -480,25 +480,25 @@ static void gl_cg_set_params(void *data, void *shader_data,
       for (j = 0; j < 2; j++)
       {
          uniform_params[j].lookup.enable = true;
-         uniform_params[j].lookup.idx    = cg_data->active_idx;
-         uniform_params[j].lookup.ident  = cg_data->shader->parameters[i].id;
+         uniform_params[j].lookup.idx    = cg->active_idx;
+         uniform_params[j].lookup.ident  = cg->shader->parameters[i].id;
          uniform_params[j].location      = j;
          uniform_params[j].enabled       = true;
          uniform_params[j].type          = UNIFORM_1F;
-         uniform_params[j].result.f.v0   = cg_data->shader->parameters[i].current;
-         gl_cg_set_uniform_parameter(cg_data, &uniform_params[j], NULL);
+         uniform_params[j].result.f.v0   = cg->shader->parameters[i].current;
+         gl_cg_set_uniform_parameter(cg, &uniform_params[j], NULL);
       }
    }
 
    /* Set state parameters. */
-   if (cg_data->state_tracker)
+   if (cg->state_tracker)
    {
       /* Only query uniforms in first pass. */
       static struct state_tracker_uniform tracker_info[GFX_MAX_VARIABLES];
       static unsigned cnt = 0;
 
-      if (cg_data->active_idx == 1)
-         cnt = state_tracker_get_uniform(cg_data->state_tracker, tracker_info,
+      if (cg->active_idx == 1)
+         cnt = state_tracker_get_uniform(cg->state_tracker, tracker_info,
                GFX_MAX_VARIABLES, frame_count);
 
       for (i = 0; i < cnt; i++)
@@ -511,13 +511,13 @@ static void gl_cg_set_params(void *data, void *shader_data,
          for (j = 0; j < 2; j++)
          {
             uniform_params[j].lookup.enable = true;
-            uniform_params[j].lookup.idx    = cg_data->active_idx;
+            uniform_params[j].lookup.idx    = cg->active_idx;
             uniform_params[j].lookup.ident  = tracker_info[i].id;
             uniform_params[j].location      = j;
             uniform_params[j].enabled       = true;
             uniform_params[j].type          = UNIFORM_1F;
             uniform_params[j].result.f.v0   = tracker_info[i].value;
-            gl_cg_set_uniform_parameter(cg_data, &uniform_params[j], NULL);
+            gl_cg_set_uniform_parameter(cg, &uniform_params[j], NULL);
          }
       }
    }
@@ -526,81 +526,81 @@ static void gl_cg_set_params(void *data, void *shader_data,
 static void gl_cg_deinit_progs(void *data)
 {
    unsigned i;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   if (!cg_data)
+   if (!cg)
       return;
 
    RARCH_LOG("CG: Destroying programs.\n");
-   cgGLUnbindProgram(cg_data->cgFProf);
-   cgGLUnbindProgram(cg_data->cgVProf);
+   cgGLUnbindProgram(cg->cgFProf);
+   cgGLUnbindProgram(cg->cgVProf);
 
    /* Programs may alias [0]. */
    for (i = 1; i < GFX_MAX_SHADERS; i++)
    {
-      if (cg_data->prg[i].fprg && cg_data->prg[i].fprg != cg_data->prg[0].fprg)
-         cgDestroyProgram(cg_data->prg[i].fprg);
-      if (cg_data->prg[i].vprg && cg_data->prg[i].vprg != cg_data->prg[0].vprg)
-         cgDestroyProgram(cg_data->prg[i].vprg);
+      if (cg->prg[i].fprg && cg->prg[i].fprg != cg->prg[0].fprg)
+         cgDestroyProgram(cg->prg[i].fprg);
+      if (cg->prg[i].vprg && cg->prg[i].vprg != cg->prg[0].vprg)
+         cgDestroyProgram(cg->prg[i].vprg);
    }
 
-   if (cg_data->prg[0].fprg)
-      cgDestroyProgram(cg_data->prg[0].fprg);
-   if (cg_data->prg[0].vprg)
-      cgDestroyProgram(cg_data->prg[0].vprg);
+   if (cg->prg[0].fprg)
+      cgDestroyProgram(cg->prg[0].fprg);
+   if (cg->prg[0].vprg)
+      cgDestroyProgram(cg->prg[0].vprg);
 
-   memset(cg_data->prg, 0, sizeof(cg_data->prg));
+   memset(cg->prg, 0, sizeof(cg->prg));
 }
 
 static void gl_cg_destroy_resources(void *data)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!cg_data)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!cg)
       return;
 
    gl_cg_reset_attrib(data);
 
    gl_cg_deinit_progs(data);
 
-   if (cg_data->shader && cg_data->shader->luts)
+   if (cg->shader && cg->shader->luts)
    {
-      glDeleteTextures(cg_data->shader->luts, cg_data->lut_textures);
-      memset(cg_data->lut_textures, 0, sizeof(cg_data->lut_textures));
+      glDeleteTextures(cg->shader->luts, cg->lut_textures);
+      memset(cg->lut_textures, 0, sizeof(cg->lut_textures));
    }
 
-   if (cg_data->state_tracker)
+   if (cg->state_tracker)
    {
-      state_tracker_free(cg_data->state_tracker);
-      cg_data->state_tracker = NULL;
+      state_tracker_free(cg->state_tracker);
+      cg->state_tracker = NULL;
    }
 
-   free(cg_data->shader);
-   cg_data->shader = NULL;
+   free(cg->shader);
+   cg->shader = NULL;
 }
 
 /* Final deinit. */
 static void gl_cg_deinit_context_state(void *data)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (cg_data->cgCtx)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (cg->cgCtx)
    {
       RARCH_LOG("CG: Destroying context.\n");
-      cgDestroyContext(cg_data->cgCtx);
+      cgDestroyContext(cg->cgCtx);
    }
-   cg_data->cgCtx = NULL;
+   cg->cgCtx = NULL;
 }
 
 /* Full deinit. */
 static void gl_cg_deinit(void *data)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!cg_data)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!cg)
       return;
 
-   gl_cg_destroy_resources(cg_data);
-   gl_cg_deinit_context_state(cg_data);
+   gl_cg_destroy_resources(cg);
+   gl_cg_deinit_context_state(cg);
 
-   free(cg_data);
+   free(cg);
 }
 
 static bool gl_cg_compile_program(
@@ -615,29 +615,29 @@ static bool gl_cg_compile_program(
    char *listing_f  = NULL;
    char *listing_v  = NULL;
    unsigned i, argc = 0;
-   struct shader_program_cg_data *program = (struct shader_program_cg_data*)program_data;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   struct shader_program_cg *program = (struct shader_program_cg*)program_data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
    if (!program)
-      program = &cg_data->prg[idx];
+      program = &cg->prg[idx];
 
    argv[argc++] = "-DPARAMETER_UNIFORM";
    for (i = 0; i < GFX_MAX_SHADERS; i++)
    {
-      if (*(cg_data->alias_define[i]))
-         argv[argc++] = cg_data->alias_define[i];
+      if (*(cg->alias_define[i]))
+         argv[argc++] = cg->alias_define[i];
    }
    argv[argc] = NULL;
 
    if (program_info->is_file)
       program->fprg = cgCreateProgramFromFile(
-            cg_data->cgCtx, CG_SOURCE,
-            program_info->combined, cg_data->cgFProf, "main_fragment", argv);
+            cg->cgCtx, CG_SOURCE,
+            program_info->combined, cg->cgFProf, "main_fragment", argv);
    else
-      program->fprg = cgCreateProgram(cg_data->cgCtx, CG_SOURCE,
-            program_info->combined, cg_data->cgFProf, "main_fragment", argv);
+      program->fprg = cgCreateProgram(cg->cgCtx, CG_SOURCE,
+            program_info->combined, cg->cgFProf, "main_fragment", argv);
 
-   list = cgGetLastListing(cg_data->cgCtx);
+   list = cgGetLastListing(cg->cgCtx);
 
    if (list)
       listing_f = strdup(list);
@@ -646,13 +646,13 @@ static bool gl_cg_compile_program(
 
    if (program_info->is_file)
       program->vprg = cgCreateProgramFromFile(
-            cg_data->cgCtx, CG_SOURCE,
-            program_info->combined, cg_data->cgVProf, "main_vertex", argv);
+            cg->cgCtx, CG_SOURCE,
+            program_info->combined, cg->cgVProf, "main_vertex", argv);
    else
-      program->vprg = cgCreateProgram(cg_data->cgCtx, CG_SOURCE,
-            program_info->combined, cg_data->cgVProf, "main_vertex", argv);
+      program->vprg = cgCreateProgram(cg->cgCtx, CG_SOURCE,
+            program_info->combined, cg->cgVProf, "main_vertex", argv);
 
-   list = cgGetLastListing(cg_data->cgCtx);
+   list = cgGetLastListing(cg->cgCtx);
 
    if (list)
       listing_v = strdup(list);
@@ -680,9 +680,9 @@ end:
 
 static void gl_cg_set_program_base_attrib(void *data, unsigned i)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
    CGparameter         param = cgGetFirstParameter(
-         cg_data->prg[i].vprg, CG_PROGRAM);
+         cg->prg[i].vprg, CG_PROGRAM);
 
    for (; param; param = cgGetNextParameter(param))
    {
@@ -704,40 +704,40 @@ static void gl_cg_set_program_base_attrib(void *data, unsigned i)
       {
          case SEMANTIC_TEXCOORD:
          case SEMANTIC_TEXCOORD0:
-            cg_data->prg[i].tex     = param;
+            cg->prg[i].tex     = param;
             break;
          case SEMANTIC_COLOR:
          case SEMANTIC_COLOR0:
-            cg_data->prg[i].color   = param;
+            cg->prg[i].color   = param;
             break;
          case SEMANTIC_POSITION:
-            cg_data->prg[i].vertex  = param;
+            cg->prg[i].vertex  = param;
             break;
          case SEMANTIC_TEXCOORD1:
-            cg_data->prg[i].lut_tex = param;
+            cg->prg[i].lut_tex = param;
             break;
       }
    }
 
-   if (!cg_data->prg[i].tex)
-      cg_data->prg[i].tex     = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.tex_coord");
-   if (!cg_data->prg[i].color)
-      cg_data->prg[i].color   = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.color");
-   if (!cg_data->prg[i].vertex)
-      cg_data->prg[i].vertex  = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.vertex_coord");
-   if (!cg_data->prg[i].lut_tex)
-      cg_data->prg[i].lut_tex = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.lut_tex_coord");
+   if (!cg->prg[i].tex)
+      cg->prg[i].tex     = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord");
+   if (!cg->prg[i].color)
+      cg->prg[i].color   = cgGetNamedParameter(cg->prg[i].vprg, "IN.color");
+   if (!cg->prg[i].vertex)
+      cg->prg[i].vertex  = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord");
+   if (!cg->prg[i].lut_tex)
+      cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord");
 }
 
 static bool gl_cg_load_stock(void *data)
 {
    struct shader_program_info program_info;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
    program_info.combined = stock_cg_gl_program;
    program_info.is_file  = false;
 
-   if (!gl_cg_compile_program(data, 0, &cg_data->prg[0], &program_info))
+   if (!gl_cg_compile_program(data, 0, &cg->prg[0], &program_info))
       goto error;
 
    gl_cg_set_program_base_attrib(data, 0);
@@ -751,16 +751,16 @@ error:
 
 static bool gl_cg_load_plain(void *data, const char *path)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!gl_cg_load_stock(cg_data))
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!gl_cg_load_stock(cg))
       return false;
 
-   cg_data->shader = (struct video_shader*)
-      calloc(1, sizeof(*cg_data->shader));
-   if (!cg_data->shader)
+   cg->shader = (struct video_shader*)
+      calloc(1, sizeof(*cg->shader));
+   if (!cg->shader)
       return false;
 
-   cg_data->shader->passes = 1;
+   cg->shader->passes = 1;
 
    if (path)
    {
@@ -770,18 +770,18 @@ static bool gl_cg_load_plain(void *data, const char *path)
       program_info.is_file  = true;
 
       RARCH_LOG("Loading Cg file: %s\n", path);
-      strlcpy(cg_data->shader->pass[0].source.path, path,
-            sizeof(cg_data->shader->pass[0].source.path));
-      if (!gl_cg_compile_program(data, 1, &cg_data->prg[1], &program_info))
+      strlcpy(cg->shader->pass[0].source.path, path,
+            sizeof(cg->shader->pass[0].source.path));
+      if (!gl_cg_compile_program(data, 1, &cg->prg[1], &program_info))
          return false;
    }
    else
    {
       RARCH_LOG("Loading stock Cg file.\n");
-      cg_data->prg[1] = cg_data->prg[0];
+      cg->prg[1] = cg->prg[0];
    }
 
-   video_shader_resolve_parameters(NULL, cg_data->shader);
+   video_shader_resolve_parameters(NULL, cg->shader);
    return true;
 }
 
@@ -790,16 +790,16 @@ static bool gl_cg_load_imports(void *data)
    unsigned i;
    retro_ctx_memory_info_t mem_info;
    struct state_tracker_info tracker_info = {0};
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   if (!cg_data->shader->variables)
+   if (!cg->shader->variables)
       return true;
 
-   for (i = 0; i < cg_data->shader->variables; i++)
+   for (i = 0; i < cg->shader->variables; i++)
    {
       unsigned memtype;
 
-      switch (cg_data->shader->variable[i].ram_type)
+      switch (cg->shader->variable[i].ram_type)
       {
          case RARCH_STATE_WRAM:
             memtype = RETRO_MEMORY_SYSTEM_RAM;
@@ -814,7 +814,7 @@ static bool gl_cg_load_imports(void *data)
       core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info);
 
       if ((memtype != -1u) && 
-            (cg_data->shader->variable[i].addr >= mem_info.size))
+            (cg->shader->variable[i].addr >= mem_info.size))
       {
          RARCH_ERR("Address out of bounds.\n");
          return false;
@@ -828,22 +828,22 @@ static bool gl_cg_load_imports(void *data)
    core_ctl(CORE_CTL_RETRO_GET_MEMORY, &mem_info);
 
    tracker_info.wram      = (uint8_t*)mem_info.data;
-   tracker_info.info      = cg_data->shader->variable;
-   tracker_info.info_elem = cg_data->shader->variables;
+   tracker_info.info      = cg->shader->variable;
+   tracker_info.info_elem = cg->shader->variables;
 
 #ifdef HAVE_PYTHON
-   if (*cg_data->shader->script_path)
+   if (*cg->shader->script_path)
    {
-      tracker_info.script = cg_data->shader->script_path;
+      tracker_info.script = cg->shader->script_path;
       tracker_info.script_is_file = true;
    }
 
    tracker_info.script_class = 
-      *cg_data->shader->script_class ? cg_data->shader->script_class : NULL;
+      *cg->shader->script_class ? cg->shader->script_class : NULL;
 #endif
 
-   cg_data->state_tracker = state_tracker_init(&tracker_info);
-   if (!cg_data->state_tracker)
+   cg->state_tracker = state_tracker_init(&tracker_info);
+   if (!cg->state_tracker)
       RARCH_WARN("Failed to initialize state tracker.\n");
 
    return true;
@@ -852,15 +852,15 @@ static bool gl_cg_load_imports(void *data)
 static bool gl_cg_load_shader(void *data, unsigned i)
 {
    struct shader_program_info program_info;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   program_info.combined = cg_data->shader->pass[i].source.path;
+   program_info.combined = cg->shader->pass[i].source.path;
    program_info.is_file  = true;
 
    RARCH_LOG("Loading Cg shader: \"%s\".\n",
-         cg_data->shader->pass[i].source.path);
+         cg->shader->pass[i].source.path);
 
-   if (!gl_cg_compile_program(data, i + 1, &cg_data->prg[i + 1],&program_info))
+   if (!gl_cg_compile_program(data, i + 1, &cg->prg[i + 1],&program_info))
       return false;
 
    return true;
@@ -870,9 +870,9 @@ static bool gl_cg_load_preset(void *data, const char *path)
 {
    unsigned i;
    config_file_t *conf = NULL;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   if (!gl_cg_load_stock(cg_data))
+   if (!gl_cg_load_stock(cg))
       return false;
 
    RARCH_LOG("Loading Cg meta-shader: %s\n", path);
@@ -883,54 +883,54 @@ static bool gl_cg_load_preset(void *data, const char *path)
       return false;
    }
 
-   cg_data->shader = (struct video_shader*)calloc(1, sizeof(*cg_data->shader));
-   if (!cg_data->shader)
+   cg->shader = (struct video_shader*)calloc(1, sizeof(*cg->shader));
+   if (!cg->shader)
    {
       config_file_free(conf);
       return false;
    }
 
-   if (!video_shader_read_conf_cgp(conf, cg_data->shader))
+   if (!video_shader_read_conf_cgp(conf, cg->shader))
    {
       RARCH_ERR("Failed to parse CGP file.\n");
       config_file_free(conf);
       return false;
    }
 
-   video_shader_resolve_relative(cg_data->shader, path);
-   video_shader_resolve_parameters(conf, cg_data->shader);
+   video_shader_resolve_relative(cg->shader, path);
+   video_shader_resolve_parameters(conf, cg->shader);
    config_file_free(conf);
 
-   if (cg_data->shader->passes > GFX_MAX_SHADERS - 3)
+   if (cg->shader->passes > GFX_MAX_SHADERS - 3)
    {
       RARCH_WARN("Too many shaders ... Capping shader amount to %d.\n",
             GFX_MAX_SHADERS - 3);
-      cg_data->shader->passes = GFX_MAX_SHADERS - 3;
+      cg->shader->passes = GFX_MAX_SHADERS - 3;
    }
 
-   for (i = 0; i < cg_data->shader->passes; i++)
-      if (*cg_data->shader->pass[i].alias)
-         snprintf(cg_data->alias_define[i],
-               sizeof(cg_data->alias_define[i]),
+   for (i = 0; i < cg->shader->passes; i++)
+      if (*cg->shader->pass[i].alias)
+         snprintf(cg->alias_define[i],
+               sizeof(cg->alias_define[i]),
                "-D%s_ALIAS",
-               cg_data->shader->pass[i].alias);
+               cg->shader->pass[i].alias);
 
-   for (i = 0; i < cg_data->shader->passes; i++)
+   for (i = 0; i < cg->shader->passes; i++)
    {
-      if (!gl_cg_load_shader(cg_data, i))
+      if (!gl_cg_load_shader(cg, i))
       {
          RARCH_ERR("Failed to load shaders ...\n");
          return false;
       }
    }
 
-   if (!gl_load_luts(cg_data->shader, cg_data->lut_textures))
+   if (!gl_load_luts(cg->shader, cg->lut_textures))
    {
       RARCH_ERR("Failed to load lookup textures ...\n");
       return false;
    }
 
-   if (!gl_cg_load_imports(cg_data))
+   if (!gl_cg_load_imports(cg))
    {
       RARCH_ERR("Failed to load imports ...\n");
       return false;
@@ -940,7 +940,7 @@ static bool gl_cg_load_preset(void *data, const char *path)
 }
 
 static void gl_cg_set_pass_attrib(
-      struct shader_program_cg_data *program,
+      struct shader_program_cg *program,
       struct cg_fbo_params *fbo,
       const char *attr)
 {
@@ -976,50 +976,50 @@ static INLINE void gl_cg_set_shaders(CGprogram frag, CGprogram vert)
 static void gl_cg_set_program_attributes(void *data, unsigned i)
 {
    unsigned j;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   if (!cg_data)
+   if (!cg)
       return;
 
-   gl_cg_set_shaders(cg_data->prg[i].fprg, cg_data->prg[i].vprg);
+   gl_cg_set_shaders(cg->prg[i].fprg, cg->prg[i].vprg);
 
-   gl_cg_set_program_base_attrib(cg_data, i);
+   gl_cg_set_program_base_attrib(cg, i);
 
-   cg_data->prg[i].vid_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.video_size");
-   cg_data->prg[i].tex_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.texture_size");
-   cg_data->prg[i].out_size_f = cgGetNamedParameter (cg_data->prg[i].fprg, "IN.output_size");
-   cg_data->prg[i].frame_cnt_f = cgGetNamedParameter(cg_data->prg[i].fprg, "IN.frame_count");
-   cg_data->prg[i].frame_dir_f = cgGetNamedParameter(cg_data->prg[i].fprg, "IN.frame_direction");
-   cg_data->prg[i].vid_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.video_size");
-   cg_data->prg[i].tex_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.texture_size");
-   cg_data->prg[i].out_size_v = cgGetNamedParameter (cg_data->prg[i].vprg, "IN.output_size");
-   cg_data->prg[i].frame_cnt_v = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.frame_count");
-   cg_data->prg[i].frame_dir_v = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.frame_direction");
+   cg->prg[i].vid_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.video_size");
+   cg->prg[i].tex_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.texture_size");
+   cg->prg[i].out_size_f = cgGetNamedParameter (cg->prg[i].fprg, "IN.output_size");
+   cg->prg[i].frame_cnt_f = cgGetNamedParameter(cg->prg[i].fprg, "IN.frame_count");
+   cg->prg[i].frame_dir_f = cgGetNamedParameter(cg->prg[i].fprg, "IN.frame_direction");
+   cg->prg[i].vid_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.video_size");
+   cg->prg[i].tex_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.texture_size");
+   cg->prg[i].out_size_v = cgGetNamedParameter (cg->prg[i].vprg, "IN.output_size");
+   cg->prg[i].frame_cnt_v = cgGetNamedParameter(cg->prg[i].vprg, "IN.frame_count");
+   cg->prg[i].frame_dir_v = cgGetNamedParameter(cg->prg[i].vprg, "IN.frame_direction");
 
-   cg_data->prg[i].mvp                 = cgGetNamedParameter(cg_data->prg[i].vprg, "modelViewProj");
-   if (!cg_data->prg[i].mvp)
-      cg_data->prg[i].mvp              = cgGetNamedParameter(cg_data->prg[i].vprg, "IN.mvp_matrix");
+   cg->prg[i].mvp                 = cgGetNamedParameter(cg->prg[i].vprg, "modelViewProj");
+   if (!cg->prg[i].mvp)
+      cg->prg[i].mvp              = cgGetNamedParameter(cg->prg[i].vprg, "IN.mvp_matrix");
 
-   cg_data->prg[i].orig.tex            = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.texture");
-   cg_data->prg[i].orig.vid_size_v     = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.video_size");
-   cg_data->prg[i].orig.vid_size_f     = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.video_size");
-   cg_data->prg[i].orig.tex_size_v     = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.texture_size");
-   cg_data->prg[i].orig.tex_size_f     = cgGetNamedParameter(cg_data->prg[i].fprg, "ORIG.texture_size");
-   cg_data->prg[i].orig.coord          = cgGetNamedParameter(cg_data->prg[i].vprg, "ORIG.tex_coord");
+   cg->prg[i].orig.tex            = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.texture");
+   cg->prg[i].orig.vid_size_v     = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.video_size");
+   cg->prg[i].orig.vid_size_f     = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.video_size");
+   cg->prg[i].orig.tex_size_v     = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.texture_size");
+   cg->prg[i].orig.tex_size_f     = cgGetNamedParameter(cg->prg[i].fprg, "ORIG.texture_size");
+   cg->prg[i].orig.coord          = cgGetNamedParameter(cg->prg[i].vprg, "ORIG.tex_coord");
 
-   cg_data->prg[i].feedback.tex        = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.texture");
-   cg_data->prg[i].feedback.vid_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.video_size");
-   cg_data->prg[i].feedback.vid_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.video_size");
-   cg_data->prg[i].feedback.tex_size_v = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.texture_size");
-   cg_data->prg[i].feedback.tex_size_f = cgGetNamedParameter(cg_data->prg[i].fprg, "FEEDBACK.texture_size");
-   cg_data->prg[i].feedback.coord      = cgGetNamedParameter(cg_data->prg[i].vprg, "FEEDBACK.tex_coord");
+   cg->prg[i].feedback.tex        = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.texture");
+   cg->prg[i].feedback.vid_size_v = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.video_size");
+   cg->prg[i].feedback.vid_size_f = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.video_size");
+   cg->prg[i].feedback.tex_size_v = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.texture_size");
+   cg->prg[i].feedback.tex_size_f = cgGetNamedParameter(cg->prg[i].fprg, "FEEDBACK.texture_size");
+   cg->prg[i].feedback.coord      = cgGetNamedParameter(cg->prg[i].vprg, "FEEDBACK.tex_coord");
 
    if (i > 1)
    {
       char pass_str[64] = {0};
 
       snprintf(pass_str, sizeof(pass_str), "PASSPREV%u", i);
-      gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].orig, pass_str);
+      gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].orig, pass_str);
    }
 
    for (j = 0; j < PREV_TEXTURES; j++)
@@ -1047,20 +1047,20 @@ static void gl_cg_set_program_attributes(void *data, unsigned i)
       snprintf(attr_buf_coord,    sizeof(attr_buf_coord),
             "%s.tex_coord", prev_names[j]);
 
-      cg_data->prg[i].prev[j].tex = cgGetNamedParameter(cg_data->prg[i].fprg,
+      cg->prg[i].prev[j].tex = cgGetNamedParameter(cg->prg[i].fprg,
             attr_buf_tex);
 
-      cg_data->prg[i].prev[j].vid_size_v = 
-         cgGetNamedParameter(cg_data->prg[i].vprg, attr_buf_vid_size);
-      cg_data->prg[i].prev[j].vid_size_f = 
-         cgGetNamedParameter(cg_data->prg[i].fprg, attr_buf_vid_size);
+      cg->prg[i].prev[j].vid_size_v = 
+         cgGetNamedParameter(cg->prg[i].vprg, attr_buf_vid_size);
+      cg->prg[i].prev[j].vid_size_f = 
+         cgGetNamedParameter(cg->prg[i].fprg, attr_buf_vid_size);
 
-      cg_data->prg[i].prev[j].tex_size_v = 
-         cgGetNamedParameter(cg_data->prg[i].vprg, attr_buf_tex_size);
-      cg_data->prg[i].prev[j].tex_size_f = 
-         cgGetNamedParameter(cg_data->prg[i].fprg, attr_buf_tex_size);
+      cg->prg[i].prev[j].tex_size_v = 
+         cgGetNamedParameter(cg->prg[i].vprg, attr_buf_tex_size);
+      cg->prg[i].prev[j].tex_size_f = 
+         cgGetNamedParameter(cg->prg[i].fprg, attr_buf_tex_size);
 
-      cg_data->prg[i].prev[j].coord = cgGetNamedParameter(cg_data->prg[i].vprg,
+      cg->prg[i].prev[j].coord = cgGetNamedParameter(cg->prg[i].vprg,
             attr_buf_coord);
    }
 
@@ -1069,13 +1069,13 @@ static void gl_cg_set_program_attributes(void *data, unsigned i)
       char pass_str[64] = {0};
 
       snprintf(pass_str, sizeof(pass_str), "PASS%u", j + 1);
-      gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j], pass_str);
+      gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j], pass_str);
       snprintf(pass_str, sizeof(pass_str), "PASSPREV%u", i - (j + 1));
-      gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j], pass_str);
+      gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j], pass_str);
 
-      if (*cg_data->shader->pass[j].alias)
-         gl_cg_set_pass_attrib(&cg_data->prg[i], &cg_data->prg[i].fbo[j],
-               cg_data->shader->pass[j].alias);
+      if (*cg->shader->pass[j].alias)
+         gl_cg_set_pass_attrib(&cg->prg[i], &cg->prg[i].fbo[j],
+               cg->shader->pass[j].alias);
    }
 }
 
@@ -1083,19 +1083,19 @@ static void *gl_cg_init(void *data, const char *path)
 {
    unsigned i;
    struct shader_program_info shader_prog_info;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)
+   cg_shader_data_t *cg = (cg_shader_data_t*)
       calloc(1, sizeof(cg_shader_data_t));
 
-   if (!cg_data)
+   if (!cg)
       return NULL;
 
 #ifdef HAVE_CG_RUNTIME_COMPILER
    cgRTCgcInit();
 #endif
 
-   cg_data->cgCtx = cgCreateContext();
+   cg->cgCtx = cgCreateContext();
 
-   if (!cg_data->cgCtx)
+   if (!cg->cgCtx)
    {
       RARCH_ERR("Failed to create Cg context.\n");
       goto error;
@@ -1106,113 +1106,113 @@ static void *gl_cg_init(void *data, const char *path)
    cgSetErrorHandler(cg_error_handler, NULL);
 #endif
 
-   cg_data->cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT);
-   cg_data->cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX);
+   cg->cgFProf = cgGLGetLatestProfile(CG_GL_FRAGMENT);
+   cg->cgVProf = cgGLGetLatestProfile(CG_GL_VERTEX);
 
    if (
-         cg_data->cgFProf == CG_PROFILE_UNKNOWN ||
-         cg_data->cgVProf == CG_PROFILE_UNKNOWN)
+         cg->cgFProf == CG_PROFILE_UNKNOWN ||
+         cg->cgVProf == CG_PROFILE_UNKNOWN)
    {
       RARCH_ERR("Invalid profile type\n");
       goto error;
    }
 
-   RARCH_LOG("[Cg]: Vertex profile: %s\n",   cgGetProfileString(cg_data->cgVProf));
-   RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cg_data->cgFProf));
-   cgGLSetOptimalOptions(cg_data->cgFProf);
-   cgGLSetOptimalOptions(cg_data->cgVProf);
-   cgGLEnableProfile(cg_data->cgFProf);
-   cgGLEnableProfile(cg_data->cgVProf);
+   RARCH_LOG("[Cg]: Vertex profile: %s\n",   cgGetProfileString(cg->cgVProf));
+   RARCH_LOG("[Cg]: Fragment profile: %s\n", cgGetProfileString(cg->cgFProf));
+   cgGLSetOptimalOptions(cg->cgFProf);
+   cgGLSetOptimalOptions(cg->cgVProf);
+   cgGLEnableProfile(cg->cgFProf);
+   cgGLEnableProfile(cg->cgVProf);
 
-   memset(cg_data->alias_define, 0, sizeof(cg_data->alias_define));
+   memset(cg->alias_define, 0, sizeof(cg->alias_define));
 
    if (path && string_is_equal(path_get_extension(path), "cgp"))
    {
-      if (!gl_cg_load_preset(cg_data, path))
+      if (!gl_cg_load_preset(cg, path))
          goto error;
    }
    else
    {
-      if (!gl_cg_load_plain(cg_data, path))
+      if (!gl_cg_load_plain(cg, path))
          goto error;
    }
 
-   cg_data->prg[0].mvp = cgGetNamedParameter(cg_data->prg[0].vprg, "IN.mvp_matrix");
+   cg->prg[0].mvp = cgGetNamedParameter(cg->prg[0].vprg, "IN.mvp_matrix");
 
-   for (i = 1; i <= cg_data->shader->passes; i++)
-      gl_cg_set_program_attributes(cg_data, i);
+   for (i = 1; i <= cg->shader->passes; i++)
+      gl_cg_set_program_attributes(cg, i);
 
    /* If we aren't using last pass non-FBO shader, 
     * this shader will be assumed to be "fixed-function".
     *
     * Just use prg[0] for that pass, which will be
     * pass-through. */
-   cg_data->prg[cg_data->shader->passes + 1] = cg_data->prg[0]; 
+   cg->prg[cg->shader->passes + 1] = cg->prg[0]; 
 
    /* No need to apply Android hack in Cg. */
-   cg_data->prg[VIDEO_SHADER_STOCK_BLEND]    = cg_data->prg[0];
+   cg->prg[VIDEO_SHADER_STOCK_BLEND]    = cg->prg[0];
 
-   gl_cg_set_shaders(cg_data->prg[1].fprg, cg_data->prg[1].vprg);
+   gl_cg_set_shaders(cg->prg[1].fprg, cg->prg[1].vprg);
 
    shader_prog_info.combined = stock_xmb_simple;
    shader_prog_info.is_file  = false;
 
    gl_cg_compile_program(
-         cg_data,
+         cg,
          VIDEO_SHADER_MENU,
-         &cg_data->prg[VIDEO_SHADER_MENU],
+         &cg->prg[VIDEO_SHADER_MENU],
          &shader_prog_info);
 
    shader_prog_info.combined = stock_xmb_simple;
 
    gl_cg_compile_program(
-         cg_data,
+         cg,
          VIDEO_SHADER_MENU_SEC,
-         &cg_data->prg[VIDEO_SHADER_MENU_SEC],
+         &cg->prg[VIDEO_SHADER_MENU_SEC],
          &shader_prog_info);
 
-   gl_cg_reset_attrib(cg_data);
+   gl_cg_reset_attrib(cg);
 
-   return cg_data;
+   return cg;
 
 error:
-   gl_cg_destroy_resources(cg_data);
-   if (!cg_data)
-      free(cg_data);
+   gl_cg_destroy_resources(cg);
+   if (!cg)
+      free(cg);
    return NULL;
 }
 
 static void gl_cg_use(void *data, void *shader_data, unsigned idx, bool set_active)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data;
-   if (cg_data && cg_data->prg[idx].vprg && cg_data->prg[idx].fprg)
+   cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
+   if (cg && cg->prg[idx].vprg && cg->prg[idx].fprg)
    {
       if (set_active)
       {
-         gl_cg_reset_attrib(cg_data);
-         cg_data->active_idx = idx;
+         gl_cg_reset_attrib(cg);
+         cg->active_idx = idx;
       }
 
-      gl_cg_set_shaders(cg_data->prg[idx].fprg, cg_data->prg[idx].vprg);
+      gl_cg_set_shaders(cg->prg[idx].fprg, cg->prg[idx].vprg);
    }
 }
 
 static unsigned gl_cg_num(void *data)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!cg_data)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!cg)
       return 0;
-   return cg_data->shader->passes;
+   return cg->shader->passes;
 }
 
 static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (cg_data && idx &&
-         (cg_data->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (cg && idx &&
+         (cg->shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
       )
    {
-      *smooth = (cg_data->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR);
+      *smooth = (cg->shader->pass[idx - 1].filter == RARCH_FILTER_LINEAR);
       return true;
    }
 
@@ -1221,17 +1221,17 @@ static bool gl_cg_filter_type(void *data, unsigned idx, bool *smooth)
 
 static enum gfx_wrap_type gl_cg_wrap_type(void *data, unsigned idx)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (cg_data && idx)
-      return cg_data->shader->pass[idx - 1].wrap;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (cg && idx)
+      return cg->shader->pass[idx - 1].wrap;
    return RARCH_WRAP_BORDER;
 }
 
 static void gl_cg_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *scale)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (cg_data && idx)
-      *scale = cg_data->shader->pass[idx - 1].fbo;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (cg && idx)
+      *scale = cg->shader->pass[idx - 1].fbo;
    else
       scale->valid = false;
 }
@@ -1240,14 +1240,14 @@ static unsigned gl_cg_get_prev_textures(void *data)
 {
    unsigned i, j;
    unsigned max_prev = 0;
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
 
-   if (!cg_data)
+   if (!cg)
       return 0;
 
-   for (i = 1; i <= cg_data->shader->passes; i++)
+   for (i = 1; i <= cg->shader->passes; i++)
       for (j = 0; j < PREV_TEXTURES; j++)
-         if (cg_data->prg[i].prev[j].tex)
+         if (cg->prg[i].prev[j].tex)
             max_prev = MAX(j + 1, max_prev);
 
    return max_prev;
@@ -1255,28 +1255,28 @@ static unsigned gl_cg_get_prev_textures(void *data)
 
 static bool gl_cg_get_feedback_pass(void *data, unsigned *pass)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!cg_data || cg_data->shader->feedback_pass < 0)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!cg || cg->shader->feedback_pass < 0)
       return false;
 
-   *pass = cg_data->shader->feedback_pass;
+   *pass = cg->shader->feedback_pass;
    return true;
 }
 
 static bool gl_cg_mipmap_input(void *data, unsigned idx)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (cg_data && idx)
-      return cg_data->shader->pass[idx - 1].mipmap;
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (cg && idx)
+      return cg->shader->pass[idx - 1].mipmap;
    return false;
 }
 
 static struct video_shader *gl_cg_get_current_shader(void *data)
 {
-   cg_shader_data_t *cg_data = (cg_shader_data_t*)data;
-   if (!cg_data)
+   cg_shader_data_t *cg = (cg_shader_data_t*)data;
+   if (!cg)
       return NULL;
-   return cg_data->shader;
+   return cg->shader;
 }
 
 const shader_backend_t gl_cg_backend = {