Ignore:
Timestamp:
Feb 11, 2010, 11:19:06 PM (15 years ago)
Author:
Dmitry A. Kuminov
Message:

trunk: Merged in qt 4.6.1 sources.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/src/3rdparty/libpng/pngpread.c

    r2 r561  
    22/* pngpread.c - read a png file in push mode
    33 *
    4  * Last changed in libpng 1.2.27 [April 29, 2008]
    5  * For conditions of distribution and use, see copyright notice in png.h
    6  * Copyright (c) 1998-2008 Glenn Randers-Pehrson
     4 * Last changed in libpng 1.2.38 [July 16, 2009]
     5 * Copyright (c) 1998-2009 Glenn Randers-Pehrson
    76 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    87 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
     8 *
     9 * This code is released under the libpng license.
     10 * For conditions of distribution and use, see the disclaimer
     11 * and license in png.h
    912 */
    1013
    1114#define PNG_INTERNAL
    1215#include "png.h"
    13 
    1416#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
    1517
    16 /* push model modes */
     18/* Push model modes */
    1719#define PNG_READ_SIG_MODE   0
    1820#define PNG_READ_CHUNK_MODE 1
    … …  
    2931   png_bytep buffer, png_size_t buffer_size)
    3032{
    31    if(png_ptr == NULL || info_ptr == NULL) return;
     33   if (png_ptr == NULL || info_ptr == NULL)
     34      return;
     35
    3236   png_push_restore_buffer(png_ptr, buffer, buffer_size);
    3337
    … …  
    4448png_process_some_data(png_structp png_ptr, png_infop info_ptr)
    4549{
    46    if(png_ptr == NULL) return;
     50   if (png_ptr == NULL)
     51      return;
     52
    4753   switch (png_ptr->process_mode)
    4854   {
    … …  
    5258         break;
    5359      }
     60
    5461      case PNG_READ_CHUNK_MODE:
    5562      {
    … …  
    5764         break;
    5865      }
     66
    5967      case PNG_READ_IDAT_MODE:
    6068      {
    … …  
    6270         break;
    6371      }
     72
    6473#if defined(PNG_READ_tEXt_SUPPORTED)
    6574      case PNG_READ_tEXt_MODE:
    … …  
    6877         break;
    6978      }
     79
    7080#endif
    7181#if defined(PNG_READ_zTXt_SUPPORTED)
    … …  
    7585         break;
    7686      }
     87
    7788#endif
    7889#if defined(PNG_READ_iTXt_SUPPORTED)
    … …  
    8293         break;
    8394      }
     95
    8496#endif
    8597      case PNG_SKIP_MODE:
    … …  
    88100         break;
    89101      }
     102
    90103      default:
    91104      {
    … …  
    115128   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
    116129      num_to_check);
    117    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check);
     130   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
    118131
    119132   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
    … …  
    211224
    212225      png_push_fill_buffer(png_ptr, chunk_length, 4);
    213       png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length);
     226      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
    214227      png_reset_crc(png_ptr);
    215228      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
     229      png_check_chunk_name(png_ptr, png_ptr->chunk_name);
    216230      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
    217231   }
    218232
    219233   if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
    220      if(png_ptr->mode & PNG_AFTER_IDAT)
     234     if (png_ptr->mode & PNG_AFTER_IDAT)
    221235        png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
    222236
    223237   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
    224238   {
    225       if (png_ptr->push_length + 4 > png_ptr->buffer_size)
    226       {
    227          if (png_ptr->push_length != 13)
    228             png_error(png_ptr, "Invalid IHDR length");
    229          png_push_save_buffer(png_ptr);
    230          return;
    231       }
     239      if (png_ptr->push_length != 13)
     240         png_error(png_ptr, "Invalid IHDR length");
     241
     242      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
     243      {
     244         png_push_save_buffer(png_ptr);
     245         return;
     246      }
     247
    232248      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
    233249   }
     250
    234251   else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
    235252   {
    … …  
    239256         return;
    240257      }
     258
    241259      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
    242260
    … …  
    244262      png_push_have_end(png_ptr, info_ptr);
    245263   }
     264
    246265#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    247266   else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
    … …  
    252271         return;
    253272      }
     273
    254274      if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
    255275         png_ptr->mode |= PNG_HAVE_IDAT;
     276
    256277      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
     278
    257279      if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
    258280         png_ptr->mode |= PNG_HAVE_PLTE;
     281
    259282      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
    260283      {
    261284         if (!(png_ptr->mode & PNG_HAVE_IHDR))
    262285            png_error(png_ptr, "Missing IHDR before IDAT");
     286
    263287         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
    264288                  !(png_ptr->mode & PNG_HAVE_PLTE))
    … …  
    266290      }
    267291   }
     292
    268293#endif
    269294   else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
    … …  
    276301      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
    277302   }
     303
    278304   else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
    279305   {
    … …  
    282308       * is called after the image has been read - we have an error).
    283309       */
    284      if (!(png_ptr->mode & PNG_HAVE_IHDR))
    285        png_error(png_ptr, "Missing IHDR before IDAT");
    286      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
    287          !(png_ptr->mode & PNG_HAVE_PLTE))
    288        png_error(png_ptr, "Missing PLTE before IDAT");
     310
     311      if (!(png_ptr->mode & PNG_HAVE_IHDR))
     312         png_error(png_ptr, "Missing IHDR before IDAT");
     313
     314      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
     315          !(png_ptr->mode & PNG_HAVE_PLTE))
     316         png_error(png_ptr, "Missing PLTE before IDAT");
    289317
    290318      if (png_ptr->mode & PNG_HAVE_IDAT)
    291319      {
    292320         if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
    293            if (png_ptr->push_length == 0)
    294               return;
     321            if (png_ptr->push_length == 0)
     322               return;
    295323
    296324         if (png_ptr->mode & PNG_AFTER_IDAT)
    … …  
    306334      return;
    307335   }
     336
    308337#if defined(PNG_READ_gAMA_SUPPORTED)
    309338   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
    … …  
    314343         return;
    315344      }
     345
    316346      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
    317347   }
     348
    318349#endif
    319350#if defined(PNG_READ_sBIT_SUPPORTED)
    … …  
    325356         return;
    326357      }
     358
    327359      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
    328360   }
     361
    329362#endif
    330363#if defined(PNG_READ_cHRM_SUPPORTED)
    … …  
    336369         return;
    337370      }
     371
    338372      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
    339373   }
     374
    340375#endif
    341376#if defined(PNG_READ_sRGB_SUPPORTED)
    … …  
    347382         return;
    348383      }
     384
    349385      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
    350386   }
     387
    351388#endif
    352389#if defined(PNG_READ_iCCP_SUPPORTED)
    … …  
    358395         return;
    359396      }
     397
    360398      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
    361399   }
     400
    362401#endif
    363402#if defined(PNG_READ_sPLT_SUPPORTED)
    … …  
    369408         return;
    370409      }
     410
    371411      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
    372412   }
     413
    373414#endif
    374415#if defined(PNG_READ_tRNS_SUPPORTED)
    … …  
    380421         return;
    381422      }
     423
    382424      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
    383425   }
     426
    384427#endif
    385428#if defined(PNG_READ_bKGD_SUPPORTED)
    … …  
    391434         return;
    392435      }
     436
    393437      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
    394438   }
     439
    395440#endif
    396441#if defined(PNG_READ_hIST_SUPPORTED)
    … …  
    402447         return;
    403448      }
     449
    404450      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
    405451   }
     452
    406453#endif
    407454#if defined(PNG_READ_pHYs_SUPPORTED)
    … …  
    413460         return;
    414461      }
     462
    415463      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
    416464   }
     465
    417466#endif
    418467#if defined(PNG_READ_oFFs_SUPPORTED)
    … …  
    424473         return;
    425474      }
     475
    426476      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
    427477   }
    428478#endif
     479
    429480#if defined(PNG_READ_pCAL_SUPPORTED)
    430481   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
    … …  
    435486         return;
    436487      }
     488
    437489      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
    438490   }
     491
    439492#endif
    440493#if defined(PNG_READ_sCAL_SUPPORTED)
    … …  
    446499         return;
    447500      }
     501
    448502      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
    449503   }
     504
    450505#endif
    451506#if defined(PNG_READ_tIME_SUPPORTED)
    … …  
    457512         return;
    458513      }
     514
    459515      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
    460516   }
     517
    461518#endif
    462519#if defined(PNG_READ_tEXt_SUPPORTED)
    … …  
    468525         return;
    469526      }
     527
    470528      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
    471529   }
     530
    472531#endif
    473532#if defined(PNG_READ_zTXt_SUPPORTED)
    … …  
    479538         return;
    480539      }
     540
    481541      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
    482542   }
     543
    483544#endif
    484545#if defined(PNG_READ_iTXt_SUPPORTED)
    … …  
    490551         return;
    491552      }
     553
    492554      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
    493555   }
     556
    494557#endif
    495558   else
    … …  
    566629   png_bytep ptr;
    567630
    568    if(png_ptr == NULL) return;
     631   if (png_ptr == NULL)
     632      return;
     633
    569634   ptr = buffer;
    570635   if (png_ptr->save_buffer_size)
    … …  
    590655      if (length < png_ptr->current_buffer_size)
    591656         save_size = length;
     657
    592658      else
    593659         save_size = png_ptr->current_buffer_size;
    … …  
    607673      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
    608674      {
    609          png_size_t i,istop;
     675         png_size_t i, istop;
    610676         png_bytep sp;
    611677         png_bytep dp;
    … …  
    630696        png_error(png_ptr, "Potential overflow of save_buffer");
    631697      }
     698
    632699      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
    633700      old_buffer = png_ptr->save_buffer;
    … …  
    676743
    677744      png_push_fill_buffer(png_ptr, chunk_length, 4);
    678       png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length);
     745      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
    679746      png_reset_crc(png_ptr);
    680747      png_crc_read(png_ptr, png_ptr->chunk_name, 4);
    … …  
    698765      {
    699766         save_size = (png_size_t)png_ptr->idat_size;
    700          /* check for overflow */
    701          if((png_uint_32)save_size != png_ptr->idat_size)
     767
     768         /* Check for overflow */
     769         if ((png_uint_32)save_size != png_ptr->idat_size)
    702770            png_error(png_ptr, "save_size overflowed in pngpread");
    703771      }
    … …  
    706774
    707775      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
     776
    708777      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
    709778         png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
     779
    710780      png_ptr->idat_size -= save_size;
    711781      png_ptr->buffer_size -= save_size;
    … …  
    720790      {
    721791         save_size = (png_size_t)png_ptr->idat_size;
    722          /* check for overflow */
    723          if((png_uint_32)save_size != png_ptr->idat_size)
     792
     793         /* Check for overflow */
     794         if ((png_uint_32)save_size != png_ptr->idat_size)
    724795            png_error(png_ptr, "save_size overflowed in pngpread");
    725796      }
    … …  
    761832   png_ptr->zstream.next_in = buffer;
    762833   png_ptr->zstream.avail_in = (uInt)buffer_length;
    763    for(;;)
     834   for (;;)
    764835   {
    765836      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
    … …  
    770841            if (png_ptr->zstream.avail_in)
    771842               png_error(png_ptr, "Extra compressed data");
     843
    772844            if (!(png_ptr->zstream.avail_out))
    773845            {
    … …  
    781853         else if (ret == Z_BUF_ERROR)
    782854            break;
     855
    783856         else
    784857            png_error(png_ptr, "Decompression Error");
    … …  
    802875         png_ptr->zstream.next_out = png_ptr->row_buf;
    803876      }
     877
    804878      else
    805879         break;
    … …  
    830904
    831905#if defined(PNG_READ_INTERLACING_SUPPORTED)
    832    /* blow up interlaced rows to full size */
     906   /* Blow up interlaced rows to full size */
    833907   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
    834908   {
    … …  
    848922            {
    849923               png_push_have_row(png_ptr, png_ptr->row_buf + 1);
    850                png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */
    851             }
    852             if (png_ptr->pass == 2) /* pass 1 might be empty */
     924               png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
     925            }
     926
     927            if (png_ptr->pass == 2) /* Pass 1 might be empty */
    853928            {
    854929               for (i = 0; i < 4 && png_ptr->pass == 2; i++)
    … …  
    858933               }
    859934            }
     935
    860936            if (png_ptr->pass == 4 && png_ptr->height <= 4)
    861937            {
    … …  
    866942               }
    867943            }
     944
    868945            if (png_ptr->pass == 6 && png_ptr->height <= 4)
    869946            {
    … …  
    871948                png_read_push_finish_row(png_ptr);
    872949            }
     950
    873951            break;
    874952         }
     953
    875954         case 1:
    876955         {
    … …  
    881960               png_read_push_finish_row(png_ptr);
    882961            }
    883             if (png_ptr->pass == 2) /* skip top 4 generated rows */
     962
     963            if (png_ptr->pass == 2) /* Skip top 4 generated rows */
    884964            {
    885965               for (i = 0; i < 4 && png_ptr->pass == 2; i++)
    … …  
    889969               }
    890970            }
     971
    891972            break;
    892973         }
     974
    893975         case 2:
    894976         {
    895977            int i;
     978
    896979            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
    897980            {
    … …  
    899982               png_read_push_finish_row(png_ptr);
    900983            }
     984
    901985            for (i = 0; i < 4 && png_ptr->pass == 2; i++)
    902986            {
    … …  
    904988               png_read_push_finish_row(png_ptr);
    905989            }
    906             if (png_ptr->pass == 4) /* pass 3 might be empty */
     990
     991            if (png_ptr->pass == 4) /* Pass 3 might be empty */
    907992            {
    908993               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
    … …  
    912997               }
    913998            }
     999
    9141000            break;
    9151001         }
     1002
    9161003         case 3:
    9171004         {
    9181005            int i;
     1006
    9191007            for (i = 0; i < 4 && png_ptr->pass == 3; i++)
    9201008            {
    … …  
    9221010               png_read_push_finish_row(png_ptr);
    9231011            }
    924             if (png_ptr->pass == 4) /* skip top two generated rows */
     1012
     1013            if (png_ptr->pass == 4) /* Skip top two generated rows */
    9251014            {
    9261015               for (i = 0; i < 2 && png_ptr->pass == 4; i++)
    … …  
    9301019               }
    9311020            }
     1021
    9321022            break;
    9331023         }
     1024
    9341025         case 4:
    9351026         {
    9361027            int i;
     1028
    9371029            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
    9381030            {
    … …  
    9401032               png_read_push_finish_row(png_ptr);
    9411033            }
     1034
    9421035            for (i = 0; i < 2 && png_ptr->pass == 4; i++)
    9431036            {
    … …  
    9451038               png_read_push_finish_row(png_ptr);
    9461039            }
    947             if (png_ptr->pass == 6) /* pass 5 might be empty */
     1040
     1041            if (png_ptr->pass == 6) /* Pass 5 might be empty */
    9481042            {
    9491043               png_push_have_row(png_ptr, png_bytep_NULL);
    9501044               png_read_push_finish_row(png_ptr);
    9511045            }
     1046
    9521047            break;
    9531048         }
     1049
    9541050         case 5:
    9551051         {
    9561052            int i;
     1053
    9571054            for (i = 0; i < 2 && png_ptr->pass == 5; i++)
    9581055            {
    … …  
    9601057               png_read_push_finish_row(png_ptr);
    9611058            }
    962             if (png_ptr->pass == 6) /* skip top generated row */
     1059
     1060            if (png_ptr->pass == 6) /* Skip top generated row */
    9631061            {
    9641062               png_push_have_row(png_ptr, png_bytep_NULL);
    9651063               png_read_push_finish_row(png_ptr);
    9661064            }
     1065
    9671066            break;
    9681067         }
    … …  
    9711070            png_push_have_row(png_ptr, png_ptr->row_buf + 1);
    9721071            png_read_push_finish_row(png_ptr);
     1072
    9731073            if (png_ptr->pass != 6)
    9741074               break;
     1075
    9751076            png_push_have_row(png_ptr, png_bytep_NULL);
    9761077            png_read_push_finish_row(png_ptr);
    … …  
    9901091{
    9911092#ifdef PNG_USE_LOCAL_ARRAYS
    992    /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
    993 
    994    /* start of interlace block */
     1093   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
     1094
     1095   /* Start of interlace block */
    9951096   PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
    9961097
    997    /* offset to next interlace block */
     1098   /* Offset to next interlace block */
    9981099   PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
    9991100
    1000    /* start of interlace block in the y direction */
     1101   /* Start of interlace block in the y direction */
    10011102   PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
    10021103
    1003    /* offset to next interlace block in the y direction */
     1104   /* Offset to next interlace block in the y direction */
    10041105   PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
    10051106
    … …  
    10141115      return;
    10151116
     1117#if defined(PNG_READ_INTERLACING_SUPPORTED)
    10161118   if (png_ptr->interlaced)
    10171119   {
    … …  
    10211123      do
    10221124      {
    1023          int pass;
    1024          pass = png_ptr->pass;
    1025          pass++;
    1026          if ((pass == 1 && png_ptr->width < 5) ||
    1027              (pass == 3 && png_ptr->width < 3) ||
    1028              (pass == 5 && png_ptr->width < 2))
    1029            pass++;
    1030 
    1031          if (pass > 7)
    1032             pass--;
    1033          png_ptr->pass = (png_byte) pass;
    1034          if (pass < 7)
    1035            {
    1036              png_ptr->iwidth = (png_ptr->width +
    1037                 png_pass_inc[pass] - 1 -
    1038                 png_pass_start[pass]) /
    1039                 png_pass_inc[pass];
    1040 
    1041              png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
    1042                 png_ptr->iwidth) + 1;
    1043 
    1044              if (png_ptr->transformations & PNG_INTERLACE)
    1045                 break;
    1046 
    1047              png_ptr->num_rows = (png_ptr->height +
    1048                 png_pass_yinc[pass] - 1 -
    1049                 png_pass_ystart[pass]) /
    1050                 png_pass_yinc[pass];
    1051            }
    1052          else
    1053            break;
     1125         png_ptr->pass++;
     1126         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
     1127             (png_ptr->pass == 3 && png_ptr->width < 3) ||
     1128             (png_ptr->pass == 5 && png_ptr->width < 2))
     1129           png_ptr->pass++;
     1130
     1131         if (png_ptr->pass > 7)
     1132            png_ptr->pass--;
     1133
     1134         if (png_ptr->pass >= 7)
     1135            break;
     1136
     1137         png_ptr->iwidth = (png_ptr->width +
     1138            png_pass_inc[png_ptr->pass] - 1 -
     1139            png_pass_start[png_ptr->pass]) /
     1140            png_pass_inc[png_ptr->pass];
     1141
     1142         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,
     1143            png_ptr->iwidth) + 1;
     1144
     1145         if (png_ptr->transformations & PNG_INTERLACE)
     1146            break;
     1147
     1148         png_ptr->num_rows = (png_ptr->height +
     1149            png_pass_yinc[png_ptr->pass] - 1 -
     1150            png_pass_ystart[png_ptr->pass]) /
     1151            png_pass_yinc[png_ptr->pass];
    10541152
    10551153      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
    10561154   }
     1155#endif /* PNG_READ_INTERLACING_SUPPORTED */
    10571156}
    10581157
    … …  
    10651164      {
    10661165         png_error(png_ptr, "Out of place tEXt");
    1067          info_ptr = info_ptr; /* to quiet some compiler warnings */
     1166         info_ptr = info_ptr; /* To quiet some compiler warnings */
    10681167      }
    10691168
    … …  
    10801179
    10811180   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
    1082          (png_uint_32)(length+1));
     1181      (png_uint_32)(length + 1));
    10831182   png_ptr->current_text[length] = '\0';
    10841183   png_ptr->current_text_ptr = png_ptr->current_text;
    … …  
    10971196      if (png_ptr->buffer_size < png_ptr->current_text_left)
    10981197         text_size = png_ptr->buffer_size;
     1198
    10991199      else
    11001200         text_size = png_ptr->current_text_left;
     1201
    11011202      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
    11021203      png_ptr->current_text_left -= text_size;
    … …  
    11261227
    11271228      for (text = key; *text; text++)
    1128          /* empty loop */ ;
     1229         /* Empty loop */ ;
    11291230
    11301231      if (text < key + png_ptr->current_text_size)
    … …  
    11611262      {
    11621263         png_error(png_ptr, "Out of place zTXt");
    1163          info_ptr = info_ptr; /* to quiet some compiler warnings */
     1264         info_ptr = info_ptr; /* To quiet some compiler warnings */
    11641265      }
    11651266
    … …  
    11781279
    11791280   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
    1180        (png_uint_32)(length+1));
     1281      (png_uint_32)(length + 1));
    11811282   png_ptr->current_text[length] = '\0';
    11821283   png_ptr->current_text_ptr = png_ptr->current_text;
    … …  
    11951296      if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
    11961297         text_size = png_ptr->buffer_size;
     1298
    11971299      else
    11981300         text_size = png_ptr->current_text_left;
     1301
    11991302      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
    12001303      png_ptr->current_text_left -= text_size;
    … …  
    12201323
    12211324      for (text = key; *text; text++)
    1222          /* empty loop */ ;
     1325         /* Empty loop */ ;
    12231326
    12241327      /* zTXt can't have zero text */
    … …  
    12321335      text++;
    12331336
    1234       if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */
     1337      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
    12351338      {
    12361339         png_ptr->current_text = NULL;
    … …  
    12691372            {
    12701373               text = (png_charp)png_malloc(png_ptr,
    1271                   (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
    1272                      + key_size + 1));
     1374                     (png_uint_32)(png_ptr->zbuf_size
     1375                     - png_ptr->zstream.avail_out + key_size + 1));
     1376
    12731377               png_memcpy(text + key_size, png_ptr->zbuf,
    12741378                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
     1379
    12751380               png_memcpy(text, key, key_size);
     1381
    12761382               text_size = key_size + png_ptr->zbuf_size -
    12771383                  png_ptr->zstream.avail_out;
     1384
    12781385               *(text + text_size) = '\0';
    12791386            }
    … …  
    12841391               tmp = text;
    12851392               text = (png_charp)png_malloc(png_ptr, text_size +
    1286                   (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
    1287                    + 1));
     1393                  (png_uint_32)(png_ptr->zbuf_size
     1394                  - png_ptr->zstream.avail_out + 1));
     1395
    12881396               png_memcpy(text, tmp, text_size);
    12891397               png_free(png_ptr, tmp);
     1398
    12901399               png_memcpy(text + text_size, png_ptr->zbuf,
    12911400                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);
     1401
    12921402               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
    12931403               *(text + text_size) = '\0';
    … …  
    13531463      {
    13541464         png_error(png_ptr, "Out of place iTXt");
    1355          info_ptr = info_ptr; /* to quiet some compiler warnings */
     1465         info_ptr = info_ptr; /* To quiet some compiler warnings */
    13561466      }
    13571467
    … …  
    13681478
    13691479   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
    1370          (png_uint_32)(length+1));
     1480      (png_uint_32)(length + 1));
    13711481   png_ptr->current_text[length] = '\0';
    13721482   png_ptr->current_text_ptr = png_ptr->current_text;
    … …  
    13861496      if (png_ptr->buffer_size < png_ptr->current_text_left)
    13871497         text_size = png_ptr->buffer_size;
     1498
    13881499      else
    13891500         text_size = png_ptr->current_text_left;
     1501
    13901502      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
    13911503      png_ptr->current_text_left -= text_size;
    … …  
    14181530
    14191531      for (lang = key; *lang; lang++)
    1420          /* empty loop */ ;
     1532         /* Empty loop */ ;
    14211533
    14221534      if (lang < key + png_ptr->current_text_size - 3)
    … …  
    14241536
    14251537      comp_flag = *lang++;
    1426       lang++;     /* skip comp_type, always zero */
     1538      lang++;     /* Skip comp_type, always zero */
    14271539
    14281540      for (lang_key = lang; *lang_key; lang_key++)
    1429          /* empty loop */ ;
    1430       lang_key++;        /* skip NUL separator */
     1541         /* Empty loop */ ;
     1542
     1543      lang_key++;        /* Skip NUL separator */
    14311544
    14321545      text=lang_key;
     1546
    14331547      if (lang_key < key + png_ptr->current_text_size - 1)
    14341548      {
    14351549        for (; *text; text++)
    1436            /* empty loop */ ;
     1550           /* Empty loop */ ;
    14371551      }
    14381552
    … …  
    14421556      text_ptr = (png_textp)png_malloc(png_ptr,
    14431557         (png_uint_32)png_sizeof(png_text));
     1558
    14441559      text_ptr->compression = comp_flag + 2;
    14451560      text_ptr->key = key;
    … …  
    14691584   length)
    14701585{
    1471    png_uint_32 skip=0;
    1472    png_check_chunk_name(png_ptr, png_ptr->chunk_name);
     1586   png_uint_32 skip = 0;
    14731587
    14741588   if (!(png_ptr->chunk_name[0] & 0x20))
    14751589   {
    14761590#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
    1477      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
    1478           PNG_HANDLE_CHUNK_ALWAYS
     1591      if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
     1592         PNG_HANDLE_CHUNK_ALWAYS
    14791593#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
    1480           && png_ptr->read_user_chunk_fn == NULL
    1481 #endif
    1482         )
    1483 #endif
    1484         png_chunk_error(png_ptr, "unknown critical chunk");
    1485 
    1486      info_ptr = info_ptr; /* to quiet some compiler warnings */
     1594         && png_ptr->read_user_chunk_fn == NULL
     1595#endif
     1596         )
     1597#endif
     1598         png_chunk_error(png_ptr, "unknown critical chunk");
     1599
     1600      info_ptr = info_ptr; /* To quiet some compiler warnings */
    14871601   }
    14881602
    … …  
    15011615                 (png_charp)png_ptr->chunk_name,
    15021616                 png_sizeof(png_ptr->unknown_chunk.name));
    1503       png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1]='\0';
     1617      png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
     1618        = '\0';
    15041619
    15051620      png_ptr->unknown_chunk.size = (png_size_t)length;
     1621
    15061622      if (length == 0)
    15071623         png_ptr->unknown_chunk.data = NULL;
     1624
    15081625      else
    15091626      {
    1510          png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);
     1627         png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
     1628       (png_uint_32)length);
    15111629         png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
    15121630      }
     1631
    15131632#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
    1514       if(png_ptr->read_user_chunk_fn != NULL)
    1515       {
    1516          /* callback to user unknown chunk handler */
     1633      if (png_ptr->read_user_chunk_fn != NULL)
     1634      {
     1635         /* Callback to user unknown chunk handler */
    15171636         int ret;
    15181637         ret = (*(png_ptr->read_user_chunk_fn))
    15191638           (png_ptr, &png_ptr->unknown_chunk);
     1639
    15201640         if (ret < 0)
    15211641            png_chunk_error(png_ptr, "error in user chunk");
     1642
    15221643         if (ret == 0)
    15231644         {
    15241645            if (!(png_ptr->chunk_name[0] & 0x20))
    1525                if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
     1646               if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
    15261647                    PNG_HANDLE_CHUNK_ALWAYS)
    15271648                  png_chunk_error(png_ptr, "unknown critical chunk");
    … …  
    15301651         }
    15311652      }
     1653
    15321654      else
    15331655#endif
    … …  
    15361658      png_ptr->unknown_chunk.data = NULL;
    15371659   }
     1660
    15381661   else
    15391662#endif
    … …  
    15721695      {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
    15731696#endif
    1574    if(png_ptr == NULL) return;
     1697   if (png_ptr == NULL)
     1698      return;
     1699
    15751700   if (new_row != NULL)    /* new_row must == png_ptr->row_buf here. */
    15761701      png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
    … …  
    15821707   png_progressive_end_ptr end_fn)
    15831708{
    1584    if(png_ptr == NULL) return;
     1709   if (png_ptr == NULL)
     1710      return;
     1711
    15851712   png_ptr->info_fn = info_fn;
    15861713   png_ptr->row_fn = row_fn;
    … …  
    15931720png_get_progressive_ptr(png_structp png_ptr)
    15941721{
    1595    if(png_ptr == NULL) return (NULL);
     1722   if (png_ptr == NULL)
     1723      return (NULL);
     1724
    15961725   return png_ptr->io_ptr;
    15971726}
Note: See TracChangeset for help on using the changeset viewer.