ISO C90 fixes

src/file/SDL_rwops.c

@@ -590,6 +590,7 @@ SDL_RWFromFile(const char *file, const char *mode)
     rwops->close = windows_file_close;
     rwops->type = SDL_RWOPS_WINFILE;
 #elif defined(__VITA__)
+    {
       /* Try to open the file on the filesystem first */
       FILE *fp = fopen(file, mode);
       if (fp) {
@@ -604,6 +605,7 @@ SDL_RWFromFile(const char *file, const char *mode)
           }
       }
       SDL_SetError("Couldn't open %s", file);
+    }
 #elif HAVE_STDIO_H
     {
         #ifdef __APPLE__

src/joystick/vita/SDL_sysjoystick.c

@@ -67,10 +67,10 @@ static point c = { 128, 32767 };
 static point d = { 128, 32767 };
 
 /* simple linear interpolation between two points */
-static SDL_INLINE void lerp (point *dest, point *a, point *b, float t)
+static SDL_INLINE void lerp (point *dest, point *first, point *second, float t)
 {
-    dest->x = a->x + (b->x - a->x)*t;
+    dest->x = first->x + (second->x - first->x) * t;
-    dest->y = a->y + (b->y - a->y)*t;
+    dest->y = first->y + (second->y - first->y) * t;
 }
 
 /* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */
@@ -93,6 +93,7 @@ static int calc_bezier_y(float t)
 int VITA_JoystickInit(void)
 {
     int i;
+    SceCtrlPortInfo myPortInfo;
 
     /* Setup input */
     sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE);
@@ -106,8 +107,6 @@ int VITA_JoystickInit(void)
         analog_map[127-i] = -1 * analog_map[i+128];
     }
 
-	SceCtrlPortInfo myPortInfo;
-
     // Assume we have at least one controller, even when nothing is paired
     // This way the user can jump in, pair a controller
     // and control things immediately even if it is paired
@@ -115,10 +114,11 @@ int VITA_JoystickInit(void)
 
     SDL_numjoysticks = 1;
 
-	//How many additional paired controllers are there?
+    // How many additional paired controllers are there?
     sceCtrlGetControllerPortInfo(&myPortInfo);
-	//On Vita TV, port 0 and 1 are the same controller
+
-	//and that is the first one, so start at port 2
+    // On Vita TV, port 0 and 1 are the same controller
+    // and that is the first one, so start at port 2
     for (i=2; i<=4; i++)
     {
         if (myPortInfo.port[i]!=SCE_CTRL_TYPE_UNPAIRED)

src/render/vitagxm/SDL_render_vita_gxm.c

@@ -470,12 +470,14 @@ VITA_GXM_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const S
 static int
 VITA_GXM_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
 {
+    int color;
+    color_vertex *vertices;
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
 
     cmd->data.draw.count = count;
-    int color = data->drawstate.color;
+    color = data->drawstate.color;
 
-    color_vertex *vertices = (color_vertex *)pool_memalign(
+    vertices = (color_vertex *)pool_memalign(
             data,
             4 * count * sizeof(color_vertex), // 4 vertices * count
             sizeof(color_vertex));
@@ -532,12 +534,13 @@ static int
 VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
     const SDL_Rect * srcrect, const SDL_FRect * dstrect)
 {
-
+    texture_vertex *vertices;
+    float u0, v0, u1, v1;
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
 
     cmd->data.draw.count = 1;
 
-    texture_vertex *vertices = (texture_vertex *)pool_memalign(
+    vertices = (texture_vertex *)pool_memalign(
             data,
             4 * sizeof(texture_vertex), // 4 vertices
             sizeof(texture_vertex));
@@ -545,10 +548,10 @@ VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture
     cmd->data.draw.first = (size_t)vertices;
     cmd->data.draw.texture = texture;
 
-    const float u0 = (float)srcrect->x / (float)texture->w;
+    u0 = (float)srcrect->x / (float)texture->w;
-    const float v0 = (float)srcrect->y / (float)texture->h;
+    v0 = (float)srcrect->y / (float)texture->h;
-    const float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
+    u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
-    const float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
+    v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
 
     vertices[0].x = dstrect->x;
     vertices[0].y = dstrect->y;
@@ -582,11 +585,23 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
     const SDL_Rect * srcrect, const SDL_FRect * dstrect,
     const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
 {
+    texture_vertex *vertices;
+    float u0, v0, u1, v1;
+    float s, c;
+    float cw, sw, ch, sh;
+
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
 
+    const float centerx = center->x;
+    const float centery = center->y;
+    const float x = dstrect->x + centerx;
+    const float y = dstrect->y + centery;
+    const float width = dstrect->w - centerx;
+    const float height = dstrect->h - centery;
+
     cmd->data.draw.count = 1;
 
-    texture_vertex *vertices = (texture_vertex *)pool_memalign(
+    vertices = (texture_vertex *)pool_memalign(
             data,
             4 * sizeof(texture_vertex), // 4 vertices
             sizeof(texture_vertex));
@@ -594,10 +609,10 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
     cmd->data.draw.first = (size_t)vertices;
     cmd->data.draw.texture = texture;
 
-    float u0 = (float)srcrect->x / (float)texture->w;
+    u0 = (float)srcrect->x / (float)texture->w;
-    float v0 = (float)srcrect->y / (float)texture->h;
+    v0 = (float)srcrect->y / (float)texture->h;
-    float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
+    u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
-    float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
+    v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
 
     if (flip & SDL_FLIP_VERTICAL) {
         Swap(&v0, &v1);
@@ -607,20 +622,13 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
         Swap(&u0, &u1);
     }
 
-    const float centerx = center->x;
-    const float centery = center->y;
-    const float x = dstrect->x + centerx;
-    const float y = dstrect->y + centery;
-    const float width = dstrect->w - centerx;
-    const float height = dstrect->h - centery;
-    float s, c;
 
     MathSincos(degToRad(angle), &s, &c);
 
-    const float cw = c * width;
+    cw = c * width;
-    const float sw = s * width;
+    sw = s * width;
-    const float ch = c * height;
+    ch = c * height;
-    const float sh = s * height;
+    sh = s * height;
 
     vertices[0].x = x - cw + sh;
     vertices[0].y = y - sw - ch;
@@ -654,9 +662,11 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
 static int
 VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
 {
+    void *color_buffer;
+    float clear_color[4];
+
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
 
-    float clear_color[4];
     clear_color[0] = (cmd->data.color.r)/255.0f;
     clear_color[1] = (cmd->data.color.g)/255.0f;
     clear_color[2] = (cmd->data.color.b)/255.0f;
@@ -669,7 +679,6 @@ VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
     sceGxmSetFragmentProgram(data->gxm_context, data->clearFragmentProgram);
 
     // set the clear color
-    void *color_buffer;
     sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer);
     sceGxmSetUniformDataF(color_buffer, data->clearClearColorParam, 0, 4, clear_color);
 
@@ -726,6 +735,7 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
     SceGxmVertexProgram *vertex_program;
     SDL_bool matrix_updated = SDL_FALSE;
     SDL_bool program_updated = SDL_FALSE;
+    Uint32 texture_color;
 
     Uint8 r, g, b, a;
     r = cmd->data.draw.r;
@@ -802,7 +812,7 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
         program_updated = SDL_TRUE;
     }
 
-    Uint32 texture_color = ((a << 24) | (b << 16) | (g << 8) | r);
+    texture_color = ((a << 24) | (b << 16) | (g << 8) | r);
 
     if (program_updated || matrix_updated) {
         if (data->drawstate.fragment_program == data->textureFragmentProgram) {
@@ -811,13 +821,14 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
             sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
         } else if (data->drawstate.fragment_program == data->textureTintFragmentProgram) {
             void *vertex_wvp_buffer;
+            void *texture_tint_color_buffer;
+            float *tint_color;
             sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer);
             sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
 
-            void *texture_tint_color_buffer;
             sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer);
 
-            float *tint_color = pool_memalign(
+            tint_color = pool_memalign(
                 data,
                 4 * sizeof(float), // RGBA
                 sizeof(float)
@@ -837,9 +848,10 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
     } else {
         if (data->drawstate.fragment_program == data->textureTintFragmentProgram && data->drawstate.texture_color != texture_color) {
             void *texture_tint_color_buffer;
+            float *tint_color;
             sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer);
 
-            float *tint_color = pool_memalign(
+            tint_color = pool_memalign(
                 data,
                 4 * sizeof(float), // RGBA
                 sizeof(float)
@@ -879,8 +891,8 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
 static int
 VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
 {
-    StartDrawing(renderer);
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
+    StartDrawing(renderer);
 
     data->drawstate.target = renderer->target;
     if (!data->drawstate.target) {
@@ -963,13 +975,16 @@ VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *
 
 void read_pixels(int x, int y, size_t width, size_t height, void *data) {
     SceDisplayFrameBuf pParam;
+    int i, j;
+    Uint32 *out32;
+    Uint32 *in32;
+
     pParam.size = sizeof(SceDisplayFrameBuf);
 
     sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
 
-    int i, j;
+    out32 = (Uint32 *)data;
-    Uint32 *out32 = (Uint32 *)data;
+    in32 = (Uint32 *)pParam.base;
-    Uint32 *in32 = (Uint32 *)pParam.base;
 
     in32 += (x + y * pParam.pitch);
 
@@ -986,11 +1001,6 @@ static int
 VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
     Uint32 pixel_format, void *pixels, int pitch)
 {
-    // TODO: read from texture rendertarget. Although no-one sane should do it.
-    if (renderer->target) {
-        return SDL_Unsupported();
-    }
-
     Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
     size_t buflen;
     void *temp_pixels;
@@ -999,6 +1009,12 @@ VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
     int w, h, length, rows;
     int status;
 
+    // TODO: read from texture rendertarget. Although no-one sane should do it.
+    if (renderer->target) {
+        return SDL_Unsupported();
+    }
+
+
     temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
     buflen = rect->h * temp_pitch;
     if (buflen == 0) {
@@ -1047,14 +1063,10 @@ static void
 VITA_GXM_RenderPresent(SDL_Renderer *renderer)
 {
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
-
+    SceCommonDialogUpdateParam updateParam;
-//    sceGxmFinish(data->gxm_context);
 
     data->displayData.address = data->displayBufferData[data->backBufferIndex];
 
-
-    SceCommonDialogUpdateParam updateParam;
-
     SDL_memset(&updateParam, 0, sizeof(updateParam));
 
     updateParam.renderTarget.colorFormat    = VITA_GXM_COLOR_FORMAT;

src/render/vitagxm/SDL_render_vita_gxm_tools.c

@@ -71,8 +71,8 @@ init_orthographic_matrix(float *m, float left, float right, float bottom, float
 static void *
 patcher_host_alloc(void *user_data, unsigned int size)
 {
-    (void)user_data;
     void *mem = SDL_malloc(size);
+    (void)user_data;
     return mem;
 }
 
@@ -222,6 +222,7 @@ make_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out,
 static void
 set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
 {
+    void *vertexDefaultBuffer;
     color_vertex *vertices = (color_vertex *)pool_memalign(
         data,
         4 * sizeof(color_vertex), // 4 vertices
@@ -253,7 +254,6 @@ set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
     sceGxmSetVertexProgram(data->gxm_context, data->colorVertexProgram);
     sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram);
 
-    void *vertexDefaultBuffer;
     sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
     sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
 
@@ -324,6 +324,84 @@ gxm_init(SDL_Renderer *renderer)
 {
     unsigned int i, x, y;
     int err;
+    void *vdmRingBuffer;
+    void *vertexRingBuffer;
+    void *fragmentRingBuffer;
+    unsigned int fragmentUsseRingBufferOffset;
+    void *fragmentUsseRingBuffer;
+    unsigned int patcherVertexUsseOffset;
+    unsigned int patcherFragmentUsseOffset;
+    void *patcherBuffer;
+    void *patcherVertexUsse;
+    void *patcherFragmentUsse;
+
+    SceGxmRenderTargetParams renderTargetParams;
+    SceGxmShaderPatcherParams patcherParams;
+
+    // compute the memory footprint of the depth buffer
+    const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
+    const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
+
+    unsigned int sampleCount = alignedWidth * alignedHeight;
+    unsigned int depthStrideInSamples = alignedWidth;
+
+    // set buffer sizes for this sample
+    const unsigned int patcherBufferSize        = 64*1024;
+    const unsigned int patcherVertexUsseSize    = 64*1024;
+    const unsigned int patcherFragmentUsseSize  = 64*1024;
+
+    // Fill SceGxmBlendInfo
+    static const SceGxmBlendInfo blend_info_none = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_blend = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_add = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mod = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_SRC_COLOR,
+
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mul = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc  = SCE_GXM_BLEND_FACTOR_DST_COLOR,
+        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc  = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
+        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
 
     VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
 
@@ -343,29 +421,28 @@ gxm_init(SDL_Renderer *renderer)
     }
 
     // allocate ring buffer memory using default sizes
-    void *vdmRingBuffer = mem_gpu_alloc(
+    vdmRingBuffer = mem_gpu_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->vdmRingBufferUid);
 
-    void *vertexRingBuffer = mem_gpu_alloc(
+    vertexRingBuffer = mem_gpu_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->vertexRingBufferUid);
 
-    void *fragmentRingBuffer = mem_gpu_alloc(
+    fragmentRingBuffer = mem_gpu_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ,
         &data->fragmentRingBufferUid);
 
-    unsigned int fragmentUsseRingBufferOffset;
+    fragmentUsseRingBuffer = mem_fragment_usse_alloc(
-    void *fragmentUsseRingBuffer = mem_fragment_usse_alloc(
         SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
         &data->fragmentUsseRingBufferUid,
         &fragmentUsseRingBufferOffset);
@@ -390,7 +467,6 @@ gxm_init(SDL_Renderer *renderer)
     }
 
     // set up parameters
-    SceGxmRenderTargetParams renderTargetParams;
     SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
     renderTargetParams.flags                = 0;
     renderTargetParams.width                = VITA_GXM_SCREEN_WIDTH;
@@ -454,12 +530,6 @@ gxm_init(SDL_Renderer *renderer)
 
     }
 
-    // compute the memory footprint of the depth buffer
-    const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
-    const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
-
-    unsigned int sampleCount = alignedWidth * alignedHeight;
-    unsigned int depthStrideInSamples = alignedWidth;
 
     // allocate the depth buffer
     data->depthBufferData = mem_gpu_alloc(
@@ -500,33 +570,26 @@ gxm_init(SDL_Renderer *renderer)
         0xFF,
         0xFF);
 
-    // set buffer sizes for this sample
-    const unsigned int patcherBufferSize        = 64*1024;
-    const unsigned int patcherVertexUsseSize    = 64*1024;
-    const unsigned int patcherFragmentUsseSize  = 64*1024;
 
     // allocate memory for buffers and USSE code
-    void *patcherBuffer = mem_gpu_alloc(
+    patcherBuffer = mem_gpu_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
         patcherBufferSize,
         4,
         SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
         &data->patcherBufferUid);
 
-    unsigned int patcherVertexUsseOffset;
+    patcherVertexUsse = mem_vertex_usse_alloc(
-    void *patcherVertexUsse = mem_vertex_usse_alloc(
         patcherVertexUsseSize,
         &data->patcherVertexUsseUid,
         &patcherVertexUsseOffset);
 
-    unsigned int patcherFragmentUsseOffset;
+    patcherFragmentUsse = mem_fragment_usse_alloc(
-    void *patcherFragmentUsse = mem_fragment_usse_alloc(
         patcherFragmentUsseSize,
         &data->patcherFragmentUsseUid,
         &patcherFragmentUsseOffset);
 
     // create a shader patcher
-    SceGxmShaderPatcherParams patcherParams;
     SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams));
     patcherParams.userData                  = NULL;
     patcherParams.hostAllocCallback         = &patcher_host_alloc;
@@ -639,59 +702,8 @@ gxm_init(SDL_Renderer *renderer)
         return err;
     }
 
-    // Fill SceGxmBlendInfo
-    static const SceGxmBlendInfo blend_info_none = {
-        .colorFunc = SCE_GXM_BLEND_FUNC_NONE,
-        .alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
-        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .colorDst  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .alphaDst  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .colorMask = SCE_GXM_COLOR_MASK_ALL
-    };
-
-    static const SceGxmBlendInfo blend_info_blend = {
-        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
-        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ONE,
-        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-        .colorMask = SCE_GXM_COLOR_MASK_ALL
-    };
-
-    static const SceGxmBlendInfo blend_info_add = {
-        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .colorSrc  = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
-        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE,
-        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
-        .colorMask = SCE_GXM_COLOR_MASK_ALL
-    };
-
-    static const SceGxmBlendInfo blend_info_mod = {
-        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
-
-        .colorSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .colorDst  = SCE_GXM_BLEND_FACTOR_SRC_COLOR,
-
-        .alphaSrc  = SCE_GXM_BLEND_FACTOR_ZERO,
-        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE,
-        .colorMask = SCE_GXM_COLOR_MASK_ALL
-    };
-
-    static const SceGxmBlendInfo blend_info_mul = {
-        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
-        .colorSrc  = SCE_GXM_BLEND_FACTOR_DST_COLOR,
-        .colorDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-        .alphaSrc  = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
-        .alphaDst  = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-        .colorMask = SCE_GXM_COLOR_MASK_ALL
-    };
 
+    {
         // get attributes by name to create vertex format bindings
         const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
 
@@ -743,6 +755,7 @@ gxm_init(SDL_Renderer *renderer)
             SCE_GXM_MEMORY_ATTRIB_READ,
             &data->clearVerticesUid
         );
+    }
 
     // Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible
     // 16-bit indices in linear ascending order, so we can use this for
@@ -755,7 +768,7 @@ gxm_init(SDL_Renderer *renderer)
         &data->linearIndicesUid
     );
 
-    for (uint32_t i=0; i<=UINT16_MAX; ++i)
+    for (i = 0; i <= UINT16_MAX; ++i)
     {
         data->linearIndices[i] = i;
     }
@@ -767,6 +780,7 @@ gxm_init(SDL_Renderer *renderer)
     data->clearVertices[2].x = -1.0f;
     data->clearVertices[2].y =  3.0f;
 
+    {
         const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition");
 
         const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor");
@@ -805,6 +819,10 @@ gxm_init(SDL_Renderer *renderer)
             return err;
         }
 
+    }
+
+
+    {
         const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
         const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
 
@@ -842,6 +860,8 @@ gxm_init(SDL_Renderer *renderer)
             return err;
         }
 
+    }
+
     // Create variations of the fragment program based on blending mode
     make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none, &blend_info_none);
     make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend, &blend_info_blend);
@@ -849,6 +869,7 @@ gxm_init(SDL_Renderer *renderer)
     make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod, &blend_info_mod);
     make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul, &blend_info_mul);
 
+    {
         // Default to blend blending mode
         fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
 
@@ -856,6 +877,8 @@ gxm_init(SDL_Renderer *renderer)
         data->textureFragmentProgram = in->texture;
         data->textureTintFragmentProgram = in->textureTint;
 
+    }
+
     // find vertex uniforms by name and cache parameter information
     data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor");
     data->colorWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp");
@@ -1019,15 +1042,18 @@ gxm_texture_get_datap(const gxm_texture *texture)
 gxm_texture *
 create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget)
 {
-    format = SCE_GXM_TEXTURE_FORMAT_A8B8G8R8;
     gxm_texture *texture = SDL_malloc(sizeof(gxm_texture));
+    const int tex_size =  ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
+    void *texture_data;
+
+    format = SCE_GXM_TEXTURE_FORMAT_A8B8G8R8;
+
     if (!texture)
         return NULL;
 
-    const int tex_size =  ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
 
     /* Allocate a GPU buffer for the texture */
-    void *texture_data = mem_gpu_alloc(
+    texture_data = mem_gpu_alloc(
         SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
         tex_size,
         SCE_GXM_TEXTURE_ALIGNMENT,
@@ -1070,6 +1096,11 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
     }
 
     if (isRenderTarget) {
+        void *depthBufferData;
+        const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
+        const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
+        uint32_t sampleCount = alignedWidth*alignedHeight;
+        uint32_t depthStrideInSamples = alignedWidth;
 
         int err = sceGxmColorSurfaceInit(
             &texture->gxm_colorsurface,
@@ -1089,14 +1120,8 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
             return NULL;
         }
 
-        // create the depth/stencil surface
-        const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
-        const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
-        uint32_t sampleCount = alignedWidth*alignedHeight;
-        uint32_t depthStrideInSamples = alignedWidth;
-
         // allocate it
-        void *depthBufferData = mem_gpu_alloc(
+        depthBufferData = mem_gpu_alloc(
             SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
             4*sampleCount,
             SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
@@ -1118,6 +1143,7 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
             return NULL;
         }
 
+        {
             SceGxmRenderTarget *tgt = NULL;
 
             // set up parameters
@@ -1141,6 +1167,7 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
                 SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err);
                 return NULL;
             }
+        }
 
     }
 

src/sensor/vita/SDL_vitasensor.c

@@ -137,10 +137,10 @@ SDL_VITA_SensorOpen(SDL_Sensor *sensor, int device_index)
 static void
 SDL_VITA_SensorUpdate(SDL_Sensor *sensor)
 {
+    int err = SCE_OK;
     SceMotionSensorState motionState[SCE_MOTION_MAX_NUM_STATES];
     SDL_memset(motionState, 0, sizeof(motionState));
 
-    int err = SCE_OK;
     err = sceMotionGetSensorState(motionState, SCE_MOTION_MAX_NUM_STATES);
     if (err != SCE_OK)
     {

src/timer/vita/SDL_systimer.c

@@ -20,7 +20,7 @@
 */
 #include "../../SDL_internal.h"
 
-#ifdef SDL_TIMERS_VITA
+#ifdef SDL_TIMER_VITA
 
 #include "SDL_thread.h"
 #include "SDL_timer.h"
@@ -53,13 +53,13 @@ SDL_TicksQuit(void)
 
 Uint32 SDL_GetTicks(void)
 {
+    uint64_t now;
+    Uint32 ticks;
+
     if (!ticks_started) {
         SDL_TicksInit();
     }
 
-    uint64_t now;
-    Uint32 ticks;
-
     now = sceKernelGetProcessTimeWide();
     ticks = (now - start)/1000;
     return (ticks);
@@ -85,7 +85,7 @@ void SDL_Delay(Uint32 ms)
     sceKernelDelayThreadCB(ms * 1000);
 }
 
-#endif /* SDL_TIMERS_VITA */
+#endif /* SDL_TIMER_VITA */
 
 /* vim: ts=4 sw=4
  */

src/video/vita/SDL_vitagl.c

@@ -81,6 +81,11 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window)
     EGLint num_configs;
     int i;
 
+    const EGLint contextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+
     EGLCHK(display = eglGetDisplay(0));
 
     EGLCHK(eglInitialize(display, NULL, NULL));
@@ -122,10 +127,6 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window)
         return 0;
     }
 
-    const EGLint contextAttribs[] = {
-        EGL_CONTEXT_CLIENT_VERSION, 2,
-        EGL_NONE
-    };
 
     EGLCHK(surface = eglCreateWindowSurface(display, config, VITA_WINDOW_960X544, NULL));
 

src/video/vita/SDL_vitakeyboard.c

@@ -105,6 +105,7 @@ VITA_PollKeyboard(void)
 				}
 			}
 
+			{
 				Uint8 changed_modifiers = k_reports[numReports - 1].modifiers[0] ^ prev_modifiers;
 
 				if (changed_modifiers & 0x01) {
@@ -171,6 +172,7 @@ VITA_PollKeyboard(void)
 						SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI);
 					}
 				}
+			}
 
 			prev_modifiers = k_reports[numReports - 1].modifiers[0];
 

src/video/vita/SDL_vitatouch.c

@@ -77,13 +77,13 @@ VITA_QuitTouch(void){
 void 
 VITA_PollTouch(void)
 {
+	SDL_FingerID finger_id = 0;
+	int port;
+
 	// We skip polling touch if no window is created
 	if (Vita_Window == NULL)
 		return;
 
-	SDL_FingerID finger_id = 0;
-	int port;
-
 	memcpy(touch_old, touch, sizeof(touch_old));
 
 	for(port = 0; port < SCE_TOUCH_PORT_MAX_NUM; port++) {
@@ -97,8 +97,8 @@ VITA_PollTouch(void)
 				// for the back panel, the active touch area is used as reference
 				float x = 0;
 				float y = 0;
-				VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port);
 				float force = (touch[port].report[i].force - force_info[port].min) / force_info[port].range;
+				VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port);
 				finger_id = (SDL_FingerID) touch[port].report[i].id;
 
 				// Send an initial touch
@@ -134,8 +134,8 @@ VITA_PollTouch(void)
 				if (finger_up == 1) {
 					float x = 0;
 					float y = 0;
-					VITA_ConvertTouchXYToSDLXY(&x, &y, touch_old[port].report[i].x, touch_old[port].report[i].y, port);
 					float force = (touch_old[port].report[i].force - force_info[port].min) / force_info[port].range;
+					VITA_ConvertTouchXYToSDLXY(&x, &y, touch_old[port].report[i].x, touch_old[port].report[i].y, port);
 					finger_id = (SDL_FingerID) touch_old[port].report[i].id;
 					// Finger released from screen
 					SDL_SendTouch((SDL_TouchID)port,

src/video/vita/SDL_vitavideo.c

@@ -327,6 +327,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window)
 
     wchar_t *title = L"";
     wchar_t *text = L"";
+    SceInt32 res;
 
     SceImeDialogParam param;
     sceImeDialogParamInit(&param);
@@ -342,7 +343,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window)
     param.initialText = text;
     param.inputTextBuffer = videodata->ime_buffer;
 
-    SceInt32 res = sceImeDialogInit(&param);
+    res = sceImeDialogInit(&param);
     if (res < 0) {
         SDL_SetError("Failed to init IME dialog");
         return;
@@ -413,14 +414,15 @@ void VITA_PumpEvents(_THIS)
         // update IME status. Terminate, if finished
         SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
          if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) {
+            uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
 
             SceImeDialogResult result;
             SDL_memset(&result, 0, sizeof(SceImeDialogResult));
             sceImeDialogGetResult(&result);
 
             // Convert UTF16 to UTF8
-            uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
             utf16_to_utf8(videodata->ime_buffer, utf8_buffer);
+
             // send sdl event
             SDL_SendKeyboardText((const char*)utf8_buffer);