← Back to branch summary

~3v1n0/compiz/ctrl+alt+kp0-clash-fix-0.9.10

« back to all changes in this revision

Viewing changes to plugins/imgjpeg/src/imgjpeg.cpp

img* plugins code cleanup:

Always bail out of function ASAP, do not calculate stuff you might not need.
Declare variables outside of loops so they won't be re-declared in each loop.
Use prefix instead of postfix increments.
Declaration and assignment of variables in one line.
Merged if condition checks.
Added and removed brackets.
Added and removed newlines, if appropriate.
Minor code structure improvements, declare variables when you need them, not
much earlier.
Fixed indentation.

Approved by PS Jenkins bot, Sam Spilsbury.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/imgjpeg/src/imgjpeg.cpp
31
31
           CompSize      &size,
32
32
           int           alpha)
33
33
{
34
 
    int  h, w;
35
 
    char *dest;
36
34
    int  height = size.height ();
37
 
    int  width = size.width ();
 
35
    int  width  = size.width ();
 
36
    char *dest  = (char *) malloc ((unsigned)(height * width * 4));
38
37
 
39
 
    dest = (char *) malloc ((unsigned)(height * width * 4));
40
38
    if (!dest)
41
39
        return false;
42
40
 
43
41
    data = dest;
 
42
    int pos;
44
43
 
45
 
    for (h = 0; h < height; h++)
46
 
        for (w = 0; w < width; w++)
 
44
    for (int h = 0; h < height; ++h)
 
45
    {
 
46
        for (int w = 0; w < width; ++w)
47
47
        {
48
 
            int pos = h * width + w;
 
48
            pos = h * width + w;
49
49
#if __BYTE_ORDER == __BIG_ENDIAN
50
50
            dest[(pos * 4) + 3] = source[(pos * 3) + 2];    /* blue */
51
51
            dest[(pos * 4) + 2] = source[(pos * 3) + 1];    /* green */
58
58
            dest[(pos * 4) + 3] = alpha;
59
59
#endif
60
60
        }
 
61
    }
61
62
 
62
63
    return true;
63
64
}
68
69
           CompSize      &size,
69
70
           int           stride)
70
71
{
71
 
    int     h, w;
72
72
    int     height = size.height ();
73
 
    int     width = size.width ();
74
 
    int     ps = stride / width;        /* pixel size */
 
73
    int     width  = size.width ();
75
74
    JSAMPLE *d;
76
75
 
77
76
    d = (JSAMPLE *) malloc ((unsigned)height * (unsigned)width * 3 *
81
80
 
82
81
    *dest = d;
83
82
 
84
 
    for (h = 0; h < height; h++)
85
 
        for (w = 0; w < width; w++)
 
83
    int ps = stride / width;    /* pixel size */
 
84
    int pos;
 
85
 
 
86
    for (int h = 0; h < height; ++h)
 
87
    {
 
88
        for (int w = 0; w < width; ++w)
86
89
        {
87
 
            int pos = h * width + w;
 
90
            pos = h * width + w;
88
91
#if __BYTE_ORDER == __BIG_ENDIAN
89
92
            d[(pos * 3) + 0] = source[(pos * ps) + 3];  /* red */
90
93
            d[(pos * 3) + 1] = source[(pos * ps) + 2];  /* green */
95
98
            d[(pos * 3) + 2] = source[(pos * ps) + 2];  /* blue */
96
99
#endif
97
100
        }
 
101
    }
98
102
 
99
103
    return true;
100
104
}
119
123
                      CompSize &size,
120
124
                      void     *&data)
121
125
{
 
126
    if (!file)
 
127
        return false;
 
128
 
122
129
    struct jpeg_decompress_struct cinfo;
123
130
    struct jpegErrorMgr           jerr;
124
 
    JSAMPLE                       *buf;
125
 
    JSAMPROW                      *rows;
126
 
    bool                          result;
127
 
 
128
 
    if (!file)
129
 
        return false;
130
131
 
131
132
    cinfo.err = jpeg_std_error (&jerr.pub);
132
133
    jerr.pub.error_exit = jpegErrorExit;
151
152
    size.setHeight ((int)cinfo.output_height);
152
153
    size.setWidth ((int)cinfo.output_width);
153
154
 
154
 
    buf = (JSAMPLE *) calloc (cinfo.output_height * cinfo.output_width *
155
 
                              (unsigned)cinfo.output_components,
156
 
                              sizeof (JSAMPLE));
 
155
    JSAMPLE *buf = (JSAMPLE *) calloc (cinfo.output_height * cinfo.output_width *
 
156
                                       (unsigned)cinfo.output_components,
 
157
                                       sizeof (JSAMPLE));
 
158
 
157
159
    if (!buf)
158
160
    {
159
161
        jpeg_finish_decompress (&cinfo);
161
163
        return false;
162
164
    }
163
165
 
164
 
    rows = (JSAMPROW *) malloc (cinfo.output_height * sizeof (JSAMPROW));
 
166
    JSAMPROW *rows = (JSAMPROW *) malloc (cinfo.output_height * sizeof (JSAMPROW));
 
167
 
165
168
    if (!rows)
166
169
    {
167
170
        free (buf);
170
173
        return false;
171
174
    }
172
175
 
173
 
    for (unsigned int i = 0; i < cinfo.output_height; i++)
 
176
    for (unsigned int i = 0; i < cinfo.output_height; ++i)
174
177
        rows[i] = &buf[i * cinfo.output_width *
175
 
                       (unsigned)cinfo.output_components];
 
178
                  (unsigned)cinfo.output_components];
176
179
 
177
180
    while (cinfo.output_scanline < cinfo.output_height)
178
181
        jpeg_read_scanlines (&cinfo, &rows[cinfo.output_scanline],
182
185
    jpeg_destroy_decompress (&cinfo);
183
186
 
184
187
    /* convert the rgb data into BGRA format */
185
 
    result = rgbToBGRA (buf, data, size, 255);
 
188
    bool result = rgbToBGRA (buf, data, size, 255);
186
189
 
187
190
    free (rows);
188
191
    free (buf);
 
192
 
189
193
    return result;
190
194
}
191
195
 
220
224
 
221
225
    while (cinfo.next_scanline < cinfo.image_height)
222
226
    {
223
 
        row_pointer[0] =
224
 
            &data[(cinfo.image_height - cinfo.next_scanline - 1) *
225
 
                  (unsigned) size.width () * 3];
 
227
        row_pointer[0] = &data[(cinfo.image_height - cinfo.next_scanline - 1) *
 
228
                         (unsigned) size.width () * 3];
 
229
 
226
230
        jpeg_write_scanlines (&cinfo, row_pointer, 1);
227
231
    }
228
232
 
250
254
JpegScreen::imageToFile (CompString &path,
251
255
                         CompString &format,
252
256
                         CompSize   &size,
253
 
                         int       stride,
254
 
                         void      *data)
 
257
                         int        stride,
 
258
                         void       *data)
255
259
{
256
 
    bool       status = false;
 
260
    bool       status   = false;
257
261
    CompString fileName = fileNameWithExtension (path);
258
262
 
259
263
    if (format == "jpeg" || format == "jpg" ||
260
264
        !(status = screen->imageToFile (path, format, size, stride, data)))
261
265
    {
262
 
        FILE *file;
263
 
        file = fopen (fileName.c_str (), "wb");
264
 
        if (file)
 
266
        FILE *file = fopen (fileName.c_str (), "wb");
 
267
 
 
268
        if (file)
265
269
        {
266
270
            status = writeJPEG ((unsigned char *) data, file, size, stride);
267
271
            fclose (file);
277
281
                         int        &stride,
278
282
                         void       *&data)
279
283
{
280
 
    bool       status = false;
281
 
    FILE       *file;
 
284
    bool       status   = false;
282
285
    CompString fileName = fileNameWithExtension (name);
 
286
    FILE       *file    = fopen (fileName.c_str (), "rb");
283
287
 
284
 
    file = fopen (fileName.c_str (), "rb");
285
288
    if (file)
286
289
    {
287
290
        status = readJPEG (file, size, data);