← Back to branch summary

~ubuntu-branches/ubuntu/natty/ntop/natty

« back to all changes in this revision

Viewing changes to gdchart0.94c/gd-1.8.3/libpng-1.0.8/pngwtran.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2005-01-30 21:59:13 UTC
  • mfrom: (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20050130215913-xc3ke963bw49b3k4
Tags: 2:3.0-5
http://bugs.debian.org/291794
http://bugs.debian.org/287802
http://bugs.debian.org/252352
http://bugs.debian.org/267248
http://bugs.debian.org/269321
http://bugs.debian.org/269319
* Updated README.Debian file so users will understand what to do at
  install, closes: #291794, #287802.
* Updated ntop init script to give better output.
* Also changed log directory from /var/lib/ntop to /var/log/ntop,
  closes: #252352.
* Quoted the interface list to allow whitespace, closes: #267248.
* Added a couple of logcheck ignores, closes: #269321, #269319.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdchart0.94c/gd-1.8.3/libpng-1.0.8/pngwtran.c
1
 
 
2
 
/* pngwtran.c - transforms the data in a row for PNG writers
3
 
 *
4
 
 * libpng 1.0.8 - July 24, 2000
5
 
 * For conditions of distribution and use, see copyright notice in png.h
6
 
 * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
7
 
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8
 
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9
 
 */
10
 
 
11
 
#define PNG_INTERNAL
12
 
#include "png.h"
13
 
 
14
 
/* Transform the data according to the user's wishes.  The order of
15
 
 * transformations is significant.
16
 
 */
17
 
void /* PRIVATE */
18
 
png_do_write_transformations(png_structp png_ptr)
19
 
{
20
 
   png_debug(1, "in png_do_write_transformations\n");
21
 
 
22
 
   if (png_ptr == NULL)
23
 
      return;
24
 
 
25
 
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
26
 
   if (png_ptr->transformations & PNG_USER_TRANSFORM)
27
 
      if(png_ptr->write_user_transform_fn != NULL)
28
 
        (*(png_ptr->write_user_transform_fn)) /* user write transform function */
29
 
          (png_ptr,                    /* png_ptr */
30
 
           &(png_ptr->row_info),       /* row_info:     */
31
 
             /*  png_uint_32 width;          width of row */
32
 
             /*  png_uint_32 rowbytes;       number of bytes in row */
33
 
             /*  png_byte color_type;        color type of pixels */
34
 
             /*  png_byte bit_depth;         bit depth of samples */
35
 
             /*  png_byte channels;          number of channels (1-4) */
36
 
             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */
37
 
           png_ptr->row_buf + 1);      /* start of pixel data for row */
38
 
#endif
39
 
#if defined(PNG_WRITE_FILLER_SUPPORTED)
40
 
   if (png_ptr->transformations & PNG_FILLER)
41
 
      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
42
 
         png_ptr->flags);
43
 
#endif
44
 
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
45
 
   if (png_ptr->transformations & PNG_PACKSWAP)
46
 
      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
47
 
#endif
48
 
#if defined(PNG_WRITE_PACK_SUPPORTED)
49
 
   if (png_ptr->transformations & PNG_PACK)
50
 
      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,
51
 
         (png_uint_32)png_ptr->bit_depth);
52
 
#endif
53
 
#if defined(PNG_WRITE_SWAP_SUPPORTED)
54
 
   if (png_ptr->transformations & PNG_SWAP_BYTES)
55
 
      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
56
 
#endif
57
 
#if defined(PNG_WRITE_SHIFT_SUPPORTED)
58
 
   if (png_ptr->transformations & PNG_SHIFT)
59
 
      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,
60
 
         &(png_ptr->shift));
61
 
#endif
62
 
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
63
 
   if (png_ptr->transformations & PNG_INVERT_ALPHA)
64
 
      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
65
 
#endif
66
 
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
67
 
   if (png_ptr->transformations & PNG_SWAP_ALPHA)
68
 
      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
69
 
#endif
70
 
#if defined(PNG_WRITE_BGR_SUPPORTED)
71
 
   if (png_ptr->transformations & PNG_BGR)
72
 
      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
73
 
#endif
74
 
#if defined(PNG_WRITE_INVERT_SUPPORTED)
75
 
   if (png_ptr->transformations & PNG_INVERT_MONO)
76
 
      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
77
 
#endif
78
 
}
79
 
 
80
 
#if defined(PNG_WRITE_PACK_SUPPORTED)
81
 
/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
82
 
 * row_info bit depth should be 8 (one pixel per byte).  The channels
83
 
 * should be 1 (this only happens on grayscale and paletted images).
84
 
 */
85
 
void /* PRIVATE */
86
 
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
87
 
{
88
 
   png_debug(1, "in png_do_pack\n");
89
 
   if (row_info->bit_depth == 8 &&
90
 
#if defined(PNG_USELESS_TESTS_SUPPORTED)
91
 
       row != NULL && row_info != NULL &&
92
 
#endif
93
 
      row_info->channels == 1)
94
 
   {
95
 
      switch ((int)bit_depth)
96
 
      {
97
 
         case 1:
98
 
         {
99
 
            png_bytep sp, dp;
100
 
            int mask, v;
101
 
            png_uint_32 i;
102
 
            png_uint_32 row_width = row_info->width;
103
 
 
104
 
            sp = row;
105
 
            dp = row;
106
 
            mask = 0x80;
107
 
            v = 0;
108
 
 
109
 
            for (i = 0; i < row_width; i++)
110
 
            {
111
 
               if (*sp != 0)
112
 
                  v |= mask;
113
 
               sp++;
114
 
               if (mask > 1)
115
 
                  mask >>= 1;
116
 
               else
117
 
               {
118
 
                  mask = 0x80;
119
 
                  *dp = (png_byte)v;
120
 
                  dp++;
121
 
                  v = 0;
122
 
               }
123
 
            }
124
 
            if (mask != 0x80)
125
 
               *dp = (png_byte)v;
126
 
            break;
127
 
         }
128
 
         case 2:
129
 
         {
130
 
            png_bytep sp, dp;
131
 
            int shift, v;
132
 
            png_uint_32 i;
133
 
            png_uint_32 row_width = row_info->width;
134
 
 
135
 
            sp = row;
136
 
            dp = row;
137
 
            shift = 6;
138
 
            v = 0;
139
 
            for (i = 0; i < row_width; i++)
140
 
            {
141
 
               png_byte value;
142
 
 
143
 
               value = (png_byte)(*sp & 0x03);
144
 
               v |= (value << shift);
145
 
               if (shift == 0)
146
 
               {
147
 
                  shift = 6;
148
 
                  *dp = (png_byte)v;
149
 
                  dp++;
150
 
                  v = 0;
151
 
               }
152
 
               else
153
 
                  shift -= 2;
154
 
               sp++;
155
 
            }
156
 
            if (shift != 6)
157
 
               *dp = (png_byte)v;
158
 
            break;
159
 
         }
160
 
         case 4:
161
 
         {
162
 
            png_bytep sp, dp;
163
 
            int shift, v;
164
 
            png_uint_32 i;
165
 
            png_uint_32 row_width = row_info->width;
166
 
 
167
 
            sp = row;
168
 
            dp = row;
169
 
            shift = 4;
170
 
            v = 0;
171
 
            for (i = 0; i < row_width; i++)
172
 
            {
173
 
               png_byte value;
174
 
 
175
 
               value = (png_byte)(*sp & 0x0f);
176
 
               v |= (value << shift);
177
 
 
178
 
               if (shift == 0)
179
 
               {
180
 
                  shift = 4;
181
 
                  *dp = (png_byte)v;
182
 
                  dp++;
183
 
                  v = 0;
184
 
               }
185
 
               else
186
 
                  shift -= 4;
187
 
 
188
 
               sp++;
189
 
            }
190
 
            if (shift != 4)
191
 
               *dp = (png_byte)v;
192
 
            break;
193
 
         }
194
 
      }
195
 
      row_info->bit_depth = (png_byte)bit_depth;
196
 
      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
197
 
      row_info->rowbytes =
198
 
         ((row_info->width * row_info->pixel_depth + 7) >> 3);
199
 
   }
200
 
}
201
 
#endif
202
 
 
203
 
#if defined(PNG_WRITE_SHIFT_SUPPORTED)
204
 
/* Shift pixel values to take advantage of whole range.  Pass the
205
 
 * true number of bits in bit_depth.  The row should be packed
206
 
 * according to row_info->bit_depth.  Thus, if you had a row of
207
 
 * bit depth 4, but the pixels only had values from 0 to 7, you
208
 
 * would pass 3 as bit_depth, and this routine would translate the
209
 
 * data to 0 to 15.
210
 
 */
211
 
void /* PRIVATE */
212
 
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
213
 
{
214
 
   png_debug(1, "in png_do_shift\n");
215
 
#if defined(PNG_USELESS_TESTS_SUPPORTED)
216
 
   if (row != NULL && row_info != NULL &&
217
 
#else
218
 
   if (
219
 
#endif
220
 
      row_info->color_type != PNG_COLOR_TYPE_PALETTE)
221
 
   {
222
 
      int shift_start[4], shift_dec[4];
223
 
      int channels = 0;
224
 
 
225
 
      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
226
 
      {
227
 
         shift_start[channels] = row_info->bit_depth - bit_depth->red;
228
 
         shift_dec[channels] = bit_depth->red;
229
 
         channels++;
230
 
         shift_start[channels] = row_info->bit_depth - bit_depth->green;
231
 
         shift_dec[channels] = bit_depth->green;
232
 
         channels++;
233
 
         shift_start[channels] = row_info->bit_depth - bit_depth->blue;
234
 
         shift_dec[channels] = bit_depth->blue;
235
 
         channels++;
236
 
      }
237
 
      else
238
 
      {
239
 
         shift_start[channels] = row_info->bit_depth - bit_depth->gray;
240
 
         shift_dec[channels] = bit_depth->gray;
241
 
         channels++;
242
 
      }
243
 
      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
244
 
      {
245
 
         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
246
 
         shift_dec[channels] = bit_depth->alpha;
247
 
         channels++;
248
 
      }
249
 
 
250
 
      /* with low row depths, could only be grayscale, so one channel */
251
 
      if (row_info->bit_depth < 8)
252
 
      {
253
 
         png_bytep bp = row;
254
 
         png_uint_32 i;
255
 
         png_byte mask;
256
 
         png_uint_32 row_bytes = row_info->rowbytes;
257
 
 
258
 
         if (bit_depth->gray == 1 && row_info->bit_depth == 2)
259
 
            mask = 0x55;
260
 
         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)
261
 
            mask = 0x11;
262
 
         else
263
 
            mask = 0xff;
264
 
 
265
 
         for (i = 0; i < row_bytes; i++, bp++)
266
 
         {
267
 
            png_uint_16 v;
268
 
            int j;
269
 
 
270
 
            v = *bp;
271
 
            *bp = 0;
272
 
            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])
273
 
            {
274
 
               if (j > 0)
275
 
                  *bp |= (png_byte)((v << j) & 0xff);
276
 
               else
277
 
                  *bp |= (png_byte)((v >> (-j)) & mask);
278
 
            }
279
 
         }
280
 
      }
281
 
      else if (row_info->bit_depth == 8)
282
 
      {
283
 
         png_bytep bp = row;
284
 
         png_uint_32 i;
285
 
         png_uint_32 istop = channels * row_info->width;
286
 
 
287
 
         for (i = 0; i < istop; i++, bp++)
288
 
         {
289
 
 
290
 
            png_uint_16 v;
291
 
            int j;
292
 
            int c = (int)(i%channels);
293
 
 
294
 
            v = *bp;
295
 
            *bp = 0;
296
 
            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
297
 
            {
298
 
               if (j > 0)
299
 
                  *bp |= (png_byte)((v << j) & 0xff);
300
 
               else
301
 
                  *bp |= (png_byte)((v >> (-j)) & 0xff);
302
 
            }
303
 
         }
304
 
      }
305
 
      else
306
 
      {
307
 
         png_bytep bp;
308
 
         png_uint_32 i;
309
 
         png_uint_32 istop = channels * row_info->width;
310
 
 
311
 
         for (bp = row, i = 0; i < istop; i++)
312
 
         {
313
 
            int c = (int)(i%channels);
314
 
            png_uint_16 value, v;
315
 
            int j;
316
 
 
317
 
            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));
318
 
            value = 0;
319
 
            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])
320
 
            {
321
 
               if (j > 0)
322
 
                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);
323
 
               else
324
 
                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);
325
 
            }
326
 
            *bp++ = (png_byte)(value >> 8);
327
 
            *bp++ = (png_byte)(value & 0xff);
328
 
         }
329
 
      }
330
 
   }
331
 
}
332
 
#endif
333
 
 
334
 
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
335
 
void /* PRIVATE */
336
 
png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
337
 
{
338
 
   png_debug(1, "in png_do_write_swap_alpha\n");
339
 
#if defined(PNG_USELESS_TESTS_SUPPORTED)
340
 
   if (row != NULL && row_info != NULL)
341
 
#endif
342
 
   {
343
 
      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
344
 
      {
345
 
         /* This converts from ARGB to RGBA */
346
 
         if (row_info->bit_depth == 8)
347
 
         {
348
 
            png_bytep sp, dp;
349
 
            png_uint_32 i;
350
 
            png_uint_32 row_width = row_info->width;
351
 
            for (i = 0, sp = dp = row; i < row_width; i++)
352
 
            {
353
 
               png_byte save = *(sp++);
354
 
               *(dp++) = *(sp++);
355
 
               *(dp++) = *(sp++);
356
 
               *(dp++) = *(sp++);
357
 
               *(dp++) = save;
358
 
            }
359
 
         }
360
 
         /* This converts from AARRGGBB to RRGGBBAA */
361
 
         else
362
 
         {
363
 
            png_bytep sp, dp;
364
 
            png_uint_32 i;
365
 
            png_uint_32 row_width = row_info->width;
366
 
 
367
 
            for (i = 0, sp = dp = row; i < row_width; i++)
368
 
            {
369
 
               png_byte save[2];
370
 
               save[0] = *(sp++);
371
 
               save[1] = *(sp++);
372
 
               *(dp++) = *(sp++);
373
 
               *(dp++) = *(sp++);
374
 
               *(dp++) = *(sp++);
375
 
               *(dp++) = *(sp++);
376
 
               *(dp++) = *(sp++);
377
 
               *(dp++) = *(sp++);
378
 
               *(dp++) = save[0];
379
 
               *(dp++) = save[1];
380
 
            }
381
 
         }
382
 
      }
383
 
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
384
 
      {
385
 
         /* This converts from AG to GA */
386
 
         if (row_info->bit_depth == 8)
387
 
         {
388
 
            png_bytep sp, dp;
389
 
            png_uint_32 i;
390
 
            png_uint_32 row_width = row_info->width;
391
 
 
392
 
            for (i = 0, sp = dp = row; i < row_width; i++)
393
 
            {
394
 
               png_byte save = *(sp++);
395
 
               *(dp++) = *(sp++);
396
 
               *(dp++) = save;
397
 
            }
398
 
         }
399
 
         /* This converts from AAGG to GGAA */
400
 
         else
401
 
         {
402
 
            png_bytep sp, dp;
403
 
            png_uint_32 i;
404
 
            png_uint_32 row_width = row_info->width;
405
 
 
406
 
            for (i = 0, sp = dp = row; i < row_width; i++)
407
 
            {
408
 
               png_byte save[2];
409
 
               save[0] = *(sp++);
410
 
               save[1] = *(sp++);
411
 
               *(dp++) = *(sp++);
412
 
               *(dp++) = *(sp++);
413
 
               *(dp++) = save[0];
414
 
               *(dp++) = save[1];
415
 
            }
416
 
         }
417
 
      }
418
 
   }
419
 
}
420
 
#endif
421
 
 
422
 
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
423
 
void /* PRIVATE */
424
 
png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
425
 
{
426
 
   png_debug(1, "in png_do_write_invert_alpha\n");
427
 
#if defined(PNG_USELESS_TESTS_SUPPORTED)
428
 
   if (row != NULL && row_info != NULL)
429
 
#endif
430
 
   {
431
 
      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
432
 
      {
433
 
         /* This inverts the alpha channel in RGBA */
434
 
         if (row_info->bit_depth == 8)
435
 
         {
436
 
            png_bytep sp, dp;
437
 
            png_uint_32 i;
438
 
            png_uint_32 row_width = row_info->width;
439
 
            for (i = 0, sp = dp = row; i < row_width; i++)
440
 
            {
441
 
               *(dp++) = *(sp++);
442
 
               *(dp++) = *(sp++);
443
 
               *(dp++) = *(sp++);
444
 
               *(dp++) = (png_byte)(255 - *(sp++));
445
 
            }
446
 
         }
447
 
         /* This inverts the alpha channel in RRGGBBAA */
448
 
         else
449
 
         {
450
 
            png_bytep sp, dp;
451
 
            png_uint_32 i;
452
 
            png_uint_32 row_width = row_info->width;
453
 
 
454
 
            for (i = 0, sp = dp = row; i < row_width; i++)
455
 
            {
456
 
               *(dp++) = *(sp++);
457
 
               *(dp++) = *(sp++);
458
 
               *(dp++) = *(sp++);
459
 
               *(dp++) = *(sp++);
460
 
               *(dp++) = *(sp++);
461
 
               *(dp++) = *(sp++);
462
 
               *(dp++) = (png_byte)(255 - *(sp++));
463
 
               *(dp++) = (png_byte)(255 - *(sp++));
464
 
            }
465
 
         }
466
 
      }
467
 
      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
468
 
      {
469
 
         /* This inverts the alpha channel in GA */
470
 
         if (row_info->bit_depth == 8)
471
 
         {
472
 
            png_bytep sp, dp;
473
 
            png_uint_32 i;
474
 
            png_uint_32 row_width = row_info->width;
475
 
 
476
 
            for (i = 0, sp = dp = row; i < row_width; i++)
477
 
            {
478
 
               *(dp++) = *(sp++);
479
 
               *(dp++) = (png_byte)(255 - *(sp++));
480
 
            }
481
 
         }
482
 
         /* This inverts the alpha channel in GGAA */
483
 
         else
484
 
         {
485
 
            png_bytep sp, dp;
486
 
            png_uint_32 i;
487
 
            png_uint_32 row_width = row_info->width;
488
 
 
489
 
            for (i = 0, sp = dp = row; i < row_width; i++)
490
 
            {
491
 
               *(dp++) = *(sp++);
492
 
               *(dp++) = *(sp++);
493
 
               *(dp++) = (png_byte)(255 - *(sp++));
494
 
               *(dp++) = (png_byte)(255 - *(sp++));
495
 
            }
496
 
         }
497
 
      }
498
 
   }
499
 
}
500
 
#endif