当然，长和系的记者会，也以气氛非常活跃闻名，这可能与主席李嘉诚的健谈不无关系。

3月27日，李嘉诚携长子、长和系副主席李泽钜、和黄董事总经理霍建宁出席记者会。相比于情绪高昂、表情丰富的父亲李嘉诚来说，李泽钜向来显得拘谨，讲话声音比较低沉，这让李嘉诚不得不屡次提醒李泽鉅讲话“大声一点”。

席间，李嘉诚坦言做主席很辛苦，“幸亏有一帮好伙计。”他的核心管理层均在台下列席记者会。

除了对长和系去年业绩的兴趣之外，李家家长李嘉诚与两个儿子李泽钜和李泽楷的关系，以及李嘉诚退休去向等，向来是外界关注的热点。最近，业界传闻李嘉诚对次子李泽楷可能即将到来的婚讯不甚满意，也不可避免地在业绩会上被一再提及。

当然，李嘉诚对这些家事均不置可否，或一笑带过，但却坦言，尽管矛盾在所难免，但与两个儿子关系不错，而且最近没有退休打算，如果真有这么一天的话，他将全心全意打理自己的慈善基金，“绝不会偷懒”。

去年，长实为股东带来盈利276.78亿港元，和黄收益总额更高达3087.75亿港元，其中股东应占盈利306亿港元，换言之，长和系股东总体应占盈利高达582.78亿港元。

买股要量力

《21世纪》：现在美国经济影响全球市场状况不佳，内地股市也有泡沫，你怎么看内地股市的情况？港股最近也没方向，你怎么看？

李嘉诚：我觉得，美国的经济问题，不是一朝一日能解决的，带来的麻烦也很多。

另外，我觉得投资者买股票最重要的是要看PE。我记得1989年，日本的股票，最高到了差不多38000点，很多股票的PE高到不合理，我一股都没买，直到现在，日本的股市还没有恢复到原来价格的三分之一，所以这个情形，最关键是要看PE是不是高到离谱，要小心。

至于港股现在是不是已经到了合理的水平，我不敢这么说，今天的恒生指数跟去年同期相比，我相信还要高出15%。至于内地的股市，我觉得投资者最重要的是，量力而为，要买PE不太高的、赚钱能力强、有能力提高派息水平的公司。

《21世纪》：美国次按问题造成全球经济环境不稳定，对香港有什么影响？

李嘉诚：过去10年，美国的GDP每年有3%的增长，今年可能降到2.9%，第二季度甚至可能出现负增长。美国平均购买力占GDP大概70%，如果当地消费下跌一至两成,对当地经济会构成一定影响, 所以美国的问题影响是很大的，因为一定会影响美国人的购买能力。但对于香港,目前香港对美国的直接出口比重很低,所以应该对经济影响不大。

《21世纪》：你怎么看待内地宏调对楼市和股市的影响？

李嘉诚：现在内地的宏观调控，今年来看，对股市也好，楼市也好，肯定会有不同程度的影响，但长远来看是好的，对经济健康都有利。

《21世纪》：现在香港有些发展商降价卖房，你是否看淡香港楼市升势？

李嘉诚：我举个最简单的例子，我旗下的楼盘“首都”，一天内卖掉2000多套,超过100亿港元，即便几次加价，也都能卖完，证明购买力不俗。

现在香港是负利率，有利于楼价。美国的楼价有回落，但美国的楼市情况跟香港完全不同，一方面，香港政府是最大的业主，政府拿地出来勾地，如果地供应平衡，楼价难以下跌，而且从供求关系来看，香港的需求不少。

我们的货尾也都卖完了。另外，发展商将货尾减价销售属于正常现象，因为货尾位置一般比较差。

长和控制权不会注入基金

《21世纪》：很多投资者都很关心集团管理层的稳定性，你与两个儿子的感情如何？

李嘉诚：两个都是我儿子，感情很好，当然矛盾有，批评也有，但都是在所难免。

对我自己来说，没想过退休，但如果有一日我退休的话，我会全力打理我的基金，全职的，不会偷懒，当然如果做得到的话。但是，长实的控制权不会注入到这个基金当中。

《21世纪》：你曾经说过要把海外业务慢慢交给二儿子李泽楷打理，现在怎么样？

李泽楷：个人来说，我海外是有投资的，但不需要跟公众交代的。

《21世纪》：今年的慈善捐款哪里会多点？国内和香港，还是海外？今年的捐助计划怎样？

李嘉诚：我有一个原则，每一年捐的钱应该80%以上要用在香港和内地，其它地方不应该超过20%。

不算公司捐助在内，我个人已经捐过了88亿港元，大部分是在内地和香港，但是很多都没有公布，我在内地捐助的建筑，没有一个用我的名字命名的，连对汕头大学的捐款也都没有用自己的名字命名，所以很多人都不知道我捐钱，估计我在内地的捐助对外公布的不超过1/4。

今年的话，有空就会主动去想怎么捐钱，未来捐款只会增加不会减少，因为基金会的资金有回报，有资源继续捐款。

无计划售资产

《21世纪》：去年集团业绩这么好，部分原因是出售和电国际印度流动电讯业务取得的特殊收益358.2亿港元，今年是否会继续卖资产以保持盈利增长？

李嘉诚：我不能说绝对不会，我只能告诉你，现在我没有这个计划。

当然，如果有人给很好的条件，也不是绝对不可能，我要看哪里有好的项目、好价格、好公司、好股东，才能作决定，但我不能预测未来怎样，因为法律不允许。我现在很有信心能把我们的业务做得好，未来如果对股东有利，我们也会视情况而定。

《21世纪》：传闻你有对Facebook进行股权投资？

李嘉诚：有的。我以个人名义对Facebook的投资超过1亿美元，因为Facebook业务做得好,有高速增长,而且日后在和黄的手机网络中可以使用Facebook的服务，至于今后会否增持，任何事情都是有可能的。

《21世纪》：目前香港货柜码头是不是面临内地压力？

李嘉诚：码头来看，因为出口很多都是在内地，原材料和工厂也都设在内地，货运肯定是内地方便。我保守估计，四年后，香港可能连第三的地位都难保。

现在上海、新加坡、深圳，都很方便，深圳现在的运量为2000万标准箱，香港是2400万箱，按照深圳的增速，很快就可以超过香港。

很多人希望港珠澳大桥修好之后，香港可以多点货过来，但往来香港的费用、过大桥的费用，都很高，为什么要来香港呢？所以，我对现在的生意已经很满意。

J2ME is bare-bones anｄ I recently realised that it doesn’t have any image encoders. Sure, you can create Image objects… but there is no way to persist them to disc oｒ to send them over the network in a recognised format.

With the goal of creating a low-memory PNG encoder based on TinyLine GZIPInputStream, I wrote an uncompressed BMP encoder as a gentle introduction. I am posting it here (under the LGPL) incase it helps somebody out… I got tripped up by some file format details (including Endianness) so you don’t need to go through it.

Unfortunately, you won’t be able to load BMPs anｄ display them without writing your own decoder! (J2ME only supports PNG)… but at least it allows you to communicate images with the outside world.

One of the biggest problems with J2ME is that there aren’t any great open source libraries out there. That’s one of Java’s greatest strengths. I intend to post a few of my J2ME utility classes here as I write them. I’m currently working on a hobby project which I intend to release here, anｄ if it goes according to plan, I intend to reveal some bluetooth convenience classes.

REC-png.html

PNG (Portable Network Graphics) Specification

Version 1.0

W3C Recommendation 01-October-1996

For list of authors, see Credits (Chapter 19).

Status of this document

This document has been reviewed by W3C members anｄ other interested parties anｄ has been endorsed by the Director as a W3C Recommendation. It is a stable document anｄ may be used as reference material oｒ cited as a normative reference from another document. W3C's role in making the Recommendation is to draw attention to the specification anｄ to promote its widespread deployment. This enhances the functionality anｄ interoperability of the Web.

A list of current W3C Recommendations anｄ other technical documents can be found at http://www.w3.org/pub/WWW/TR/.

The Consortium staff have encouraged the development of PNG, as have Compuserve, Inc. Most of the work has been done by the PNG Development Group, png-[email]group@w3.org[/email]. The Consortium does not currently have plans to work on any future versions of PNG, though were the necessity to arise, anｄ were an activity in that area to receive the support of Members, the Consortium could in principle support some future activity.

Abstract

PNG is designed to work well in online viewing applications, such as the World Wide Web, so it is fully streamable with a progressive display option. PNG is robust, providing both full file integrity checking anｄ simple detection of common transmission errors. Also, PNG can store gamma anｄ chromaticity data for improved color matching on heterogeneous platforms.

This specification defines a proposed Internet Media Type image/png.

Table of Contents

• 1. Introduction
• 2. Data Representation
  • 2.1. Integers anｄ byte order
  • 2.2. Color values
  • 2.3. Image layout
  • 2.4. Alpha channel
  • 2.5. Filtering
  • 2.6. Interlaced data order
  • 2.7. Gamma correction
  • 2.8. Text strings
• 3. File Structure
  • 3.1. PNG file signature
  • 3.2. Chunk layout
  • 3.3. Chunk naming conventions
  • 3.4. CRC algorithm
• 4. Chunk Specifications
  • 4.1. Critical chunks
    • 4.1.1. IHDR Image header
    • 4.1.2. PLTE Palette
    • 4.1.3. IDAT Image data
    • 4.1.4. IEND Image trailer
  • 4.2. Ancillary chunks
    • 4.2.1. bKGD Background color
    • 4.2.2. cHRM Primary chromaticities anｄ white point
    • 4.2.3. gAMA Image gamma
    • 4.2.4. hIST Image histogram
    • 4.2.5. pHYs Physical pixel dimensions
    • 4.2.6. sBIT Significant bits
    • 4.2.7. tEXt Textual data
    • 4.2.8. tIME Image last-modification time
    • 4.2.9. tRNS Transparency
    • 4.2.10. zTXt Compressed textual data
  • 4.3. Summary of standard chunks
  • 4.4. Additional chunk types
• 5. Deflate/Inflate Compression
• 6. Filter Algorithms
  • 6.1. Filter types
  • 6.2. Filter type 0: None
  • 6.3. Filter type 1: Sub
  • 6.4. Filter type 2: Up
  • 6.5. Filter type 3: Average
  • 6.6. Filter type 4: Paeth
• 7. Chunk Ordering Rules
  • 7.1. Behavior of PNG editors
  • 7.2. Ordering of ancillary chunks
  • 7.3. Ordering of critical chunks
• 8. Miscellaneous Topics
  • 8.1. File name extension
  • 8.2. Internet media type
  • 8.3. Macintosh file layout
  • 8.4. Multiple-image extension
  • 8.5. Security considerations
• 9. Recommendations for Encoders
  • 9.1. Sample depth scaling
  • 9.2. Encoder gamma handling
  • 9.3. Encoder color handling
  • 9.4. Alpha channel creation
  • 9.5. Suggested palettes
  • 9.6. Filter selection
  • 9.7. Text chunk processing
  • 9.8. Use of private chunks
  • 9.9. Private type anｄ method codes
• 10. Recommendations for Decoders
  • 10.1. Error checking
  • 10.2. Pixel dimensions
  • 10.3. Truecolor image handling
  • 10.4. Sample depth rescaling
  • 10.5. Decoder gamma handling
  • 10.6. Decoder color handling
  • 10.7. Background color
  • 10.8. Alpha channel processing
  • 10.9. Progressive display
  • 10.10. Suggested-palette anｄ histogram usage
  • 10.11. Text chunk processing
• 11. Glossary
• 12. Appendix: Rationale
  • 12.1. Why a new file format?
  • 12.2. Why these features?
  • 12.3. Why not these features?
  • 12.4. Why not use format X?
  • 12.5. Byte order
  • 12.6. Interlacing
  • 12.7. Why gamma?
  • 12.8. Non-premultiplied alpha
  • 12.9. Filtering
  • 12.10. Text strings
  • 12.11. PNG file signature
  • 12.12. Chunk layout
  • 12.13. Chunk naming conventions
  • 12.14. Palette histograms
• 13. Appendix: Gamma Tutorial
• 14. Appendix: Color Tutorial
• 15. Appendix: Sample CRC Code
• 16. Appendix: Online Resources
• 17. Appendix: Revision History
• 18. References
• 19. Credits

1. Introduction

Although the initial motivation for developing PNG was to replace GIF, the design provides some useful new features not available in GIF, with minimal cost to developers.

GIF features retained in PNG include:

• Indexed-color images of up to 256 colors.
• Streamability: files can be read anｄ written serially, thus allowing the file format to be used as a communications protocol for on-the-fly generation anｄ display of images.
• Progressive display: a suitably prepared image file can be displayed as it is received over a communications link, yielding a low-resolution image very quickly followed by gradual improvement of detail.
• Transparency: portions of the image can be marked as transparent, creating the effect of a non-rectangular image.
• Ancillary information: textual comments anｄ other data can be stored within the image file.
• Complete hardware anｄ platform independence.
• Effective, 100% lossless compression.

• Truecolor images of up to 48 bits per pixel.
• Grayscale images of up to 16 bits per pixel.
• Full alpha channel (general transparency masks).
• Image gamma information, which supports automatic display of images with correct brightness/contrast regardless of the machines used to originate anｄ display the image.
• Reliable, straightforward detection of file corruption.
• Faster initial presentation in progressive display mode.

• Simple anｄ portable: developers should be able to implement PNG easily.
• Legally unencumbered: to the best knowledge of the PNG authors, no algorithms under legal challenge are used. (Some considerable effort has been spent to verify this.)
• Well compressed: both indexed-color anｄ truecolor images are compressed as effectively as in any other widely used lossless format, anｄ in most cases more effectively.
• Interchangeable: any standard-conforming PNG decoder must read all conforming PNG files.
• Flexible: the format allows for future extensions anｄ private add-ons, without compromising interchangeability of basic PNG.
• Robust: the design supports full file integrity checking as well as simple, quick detection of common transmission errors.

The main part of this specification gives the definition of the file format anｄ recommendations for encoder anｄ decoder behavior. An appendix gives the rationale for many design decisions. Although the rationale is not part of the formal specification, reading it can help implementors understand the design. Cross-references in the main text point to relevant parts of the rationale. Additional appendixes, also not part of the formal specification, provide tutorials on gamma anｄ color theory as well as other supporting material.

In this specification, the word "must" indicates a mandatory requirement, while "should" indicates recommended behavior.

See Rationale: Why a new file format? (Section 12.1), Why these features? (Section 12.2), Why not these features? (Section 12.3), Why not use format X? (Section 12.4).

Pronunciation

2. Data Representation

2.1. Integers anｄ byte order

See Rationale: Byte order (Section 12.5).

2.2. Color values

Sample values are not necessarily linear; the gAMA chunk specifies the gamma characteristic of the source device, anｄ viewers are strongly encouraged to compensate properly. See Gamma correction (Section 2.7).

Source data with a precision not directly supported in PNG (for example, 5 bit/sample truecolor) must be scaled up to the next higher supported bit depth. This scaling is reversible with no loss of data, anｄ it reduces the number of cases that decoders have to cope with. See Recommendations for Encoders: Sample depth scaling (Section 9.1) anｄ Recommendations for Decoders: Sample depth rescaling (Section 10.4).

2.3. Image layout

Three types of pixel are supported:

• An indexed-color pixel is represented by a single sample that is an index into a supplied palette. The image bit depth determines the maximum number of palette entries, but not the color precision within the palette.
• A grayscale pixel is represented by a single sample that is a grayscale level, where zero is black anｄ the largest value for the bit depth is white.
• A truecolor pixel is represented by three samples: red (zero = black, max = red) appears first, then green (zero = black, max = green), then blue (zero = black, max = blue). The bit depth specifies the size of each sample, not the total pixel size.

Optionally, grayscale anｄ truecolor pixels can also include an alpha sample, as described in the next section.

Pixels are always packed into scanlines with no wasted bits between pixels. Pixels smaller than a byte never cross byte boundaries; they are packed into bytes with the leftmost pixel in the high-order bits of a byte, the rightmost in the low-order bits. Permitted bit depths anｄ pixel types are restricted so that in all cases the packing is simple anｄ efficient.

PNG permits multi-sample pixels only with 8- anｄ 16-bit samples, so multiple samples of a single pixel are never packed into one byte. 16-bit samples are stored in network byte order (MSB first).

Scanlines always begin on byte boundaries. When pixels have fewer than 8 bits anｄ the scanline width is not evenly divisible by the number of pixels per byte, the low-order bits in the last byte of each scanline are wasted. The contents of these wasted bits are unspecified.

An additional "filter type" byte is added to the beginning of every scanline (see Filtering, Section 2.5). The filter type byte is not considered part of the image data, but it is included in the datastream sent to the compression step.

2.4. Alpha channel

An alpha value of zero represents full transparency, anｄ a value of (2^bitdepth)-1 represents a fully opaque pixel. Intermediate values indicate partially transparent pixels that can be combined with a background image to yield a composite image. (Thus, alpha is really the degree of opacity of the pixel. But most people refer to alpha as providing transparency information, not opacity information, anｄ we continue that custom here.)

Alpha channels can be included with images that have either 8 oｒ 16 bits per sample, but not with images that have fewer than 8 bits per sample. Alpha samples are represented with the same bit depth used for the image samples. The alpha sample for each pixel is stored immediately following the grayscale oｒ RGB samples of the pixel.

The color values stored for a pixel are not affected by the alpha value assigned to the pixel. This rule is sometimes called "unassociated" oｒ "non-premultiplied" alpha. (Another common technique is to store sample values premultiplied by the alpha fraction; in effect, such an image is already composited against a black background. PNG does not use premultiplied alpha.)

Transparency control is also possible without the storage cost of a full alpha channel. In an indexed-color image, an alpha value can be defined for each palette entry. In grayscale anｄ truecolor images, a single pixel value can be identified as being "transparent". These techniques are controlled by the tRNS ancillary chunk type.

If no alpha channel nor tRNS chunk is present, all pixels in the image are to be treated as fully opaque.

Viewers can support transparency control partially, oｒ not at all.

See Rationale: Non-premultiplied alpha (Section 12.8), Recommendations for Encoders: Alpha channel creation (Section 9.4), anｄ Recommendations for Decoders: Alpha channel processing (Section 10.8).

2.5. Filtering

PNG defines several different filter algorithms, including "None" which indicates no filtering. The filter algorithm is specified for each scanline by a filter type byte that precedes the filtered scanline in the precompression datastream. An intelligent encoder can switch filters from one scanline to the next. The method for choosing which filter to employ is up to the encoder.

See Filter Algorithms (Chapter 6) anｄ Rationale: Filtering (Section 12.9).

2.6. Interlaced data order

With interlace method 0, pixels are stored sequentially from left to right, anｄ scanlines sequentially from top to bottom (no interlacing).

Interlace method 1, known as Adam7 after its author, Adam M. Costello, consists of seven distinct passes over the image. Each pass transmits a subset of the pixels in the image. The pass in which each pixel is transmitted is defined by replicating the following 8-by-8 pattern over the entire image, starting at the upper left corner:

   1 6 4 6 2 6 4 6
   7 7 7 7 7 7 7 7
   5 6 5 6 5 6 5 6
   7 7 7 7 7 7 7 7
   3 6 4 6 3 6 4 6
   7 7 7 7 7 7 7 7
   5 6 5 6 5 6 5 6
   7 7 7 7 7 7 7 7

The data within each pass is laid out as though it were a complete image of the appropriate dimensions. For example, if the complete image is 16 by 16 pixels, then pass 3 will contain two scanlines, each containing four pixels. When pixels have fewer than 8 bits, each such scanline is padded as needed to fill an integral number of bytes (see Image layout, Section 2.3). Filtering is done on this reduced image in the usual way, anｄ a filter type byte is transmitted before each of its scanlines (see Filter Algorithms, Chapter 6). Notice that the transmission order is defined so that all the scanlines transmitted in a pass will have the same number of pixels; this is necessary for proper application of some of the filters.

Caution: If the image contains fewer than five columns oｒ fewer than five rows, some passes will be entirely empty. Encoders anｄ decoders must handle this case correctly. In particular, filter type bytes are only associated with nonempty scanlines; no filter type bytes are present in an empty pass.

See Rationale: Interlacing (Section 12.6) anｄ Recommendations for Decoders: Progressive display (Section 10.9).

2.7. Gamma correction

Gamma correction is not applied to the alpha channel, if any. Alpha samples always represent a linear fraction of full opacity.

For high-precision applications, the exact chromaticity of the RGB data in a PNG image can be specified via the cHRM chunk, allowing more accurate color matching than gamma correction alone will provide. See Color Tutorial (Chapter 14) if you aren't already familiar with color representation issues.

See Rationale: Why gamma? (Section 12.7), Recommendations for Encoders: Encoder gamma handling (Section 9.2), anｄ Recommendations for Decoders: Decoder gamma handling (Section 10.5).

2.8. Text strings

ISO 8859-1 (Latin-1) is the character set recommended for use in text strings [ISO-8859]. This character set is a superset of 7-bit ASCII.

Character codes not defined in Latin-1 should not be used, because they have no platform-independent meaning. If a non-Latin-1 code does appear in a PNG text string, its interpretation will vary across platforms anｄ decoders. Some systems might not even be able to display all the characters in Latin-1, but most modern systems can.

Provision is also made for the storage of compressed text.

See Rationale: Text strings (Section 12.10).

3. File Structure

3.1. PNG file signature

   137 80 78 71 13 10 26 10

See Rationale: PNG file signature (Section 12.11).

3.2. Chunk layout

Length

A 4-byte unsigned integer giving the number of bytes in the chunk's data field. The length counts only the data field, not itself, the chunk type code, oｒ the CRC. Zero is a valid length. Although encoders anｄ decoders should treat the length as unsigned, its value must not exceed (2^31)-1 bytes.

Chunk Type

A 4-byte chunk type code. For convenience in description anｄ in examining PNG files, type codes are restricted to consist of uppercase anｄ lowercase ASCII letters (A-Z anｄ a-z, oｒ 65-90 anｄ 97-122 decimal). However, encoders anｄ decoders must treat the codes as fixed binary values, not character strings. For example, it would not be correct to represent the type code IDAT by the EBCDIC equivalents of those letters. Additional naming conventions for chunk types are discussed in the next section.

Chunk Data

The data bytes appropriate to the chunk type, if any. This field can be of zero length.

CRC

A 4-byte CRC (Cyclic Redundancy Check) calculated on the preceding bytes in the chunk, including the chunk type code anｄ chunk data fields, but not including the length field. The CRC is always present, even for chunks containing no data. See CRC algorithm (Section 3.4).

The chunk data length can be any number of bytes up to the maximum; therefore, implementors cannot assume that chunks are aligned on any boundaries larger than bytes.

Chunks can appear in any order, subject to the restrictions placed on each chunk type. (One notable restriction is that IHDR must appear first anｄ IEND must appear last; thus the IEND chunk serves as an end-of-file marker.) Multiple chunks of the same type can appear, but only if specifically permitted for that type.

See Rationale: Chunk layout (Section 12.12).

3.3. Chunk naming conventions

Four bits of the type code, namely bit 5 (value 32) of each byte, are used to convey chunk properties. This choice means that a human can read off the assigned properties according to whether each letter of the type code is uppercase (bit 5 is 0) oｒ lowercase (bit 5 is 1). However, decoders should test the properties of an unknown chunk by numerically testing the specified bits; testing whether a character is uppercase oｒ lowercase is inefficient, anｄ even incorrect if a locale-specific case definition is used.

It is worth noting that the property bits are an inherent part of the chunk name, anｄ hence are fixed for any chunk type. Thus, TEXT anｄ Text would be unrelated chunk type codes, not the same chunk with different properties. Decoders must recognize type codes by a simple four-byte literal comparison; it is incorrect to perform case conversion on type codes.

The semantics of the property bits are:

Ancillary bit: bit 5 of first byte

0 (uppercase) = critical, 1 (lowercase) = ancillary.

Chunks that are not strictly necessary in order to meaningfully display the contents of the file are known as "ancillary" chunks. A decoder encountering an unknown chunk in which the ancillary bit is 1 can safely ignore the chunk anｄ proceed to display the image. The time chunk (tIME) is an example of an ancillary chunk.

Chunks that are necessary for successful display of the file's contents are called "critical" chunks. A decoder encountering an unknown chunk in which the ancillary bit is 0 must indicate to the user that the image contains information it cannot safely interpret. The image header chunk (IHDR) is an example of a critical chunk.

 

Private bit: bit 5 of second byte

0 (uppercase) = public, 1 (lowercase) = private.

A public chunk is one that is part of the PNG specification oｒ is registered in the list of PNG special-purpose public chunk types. Applications can also define private (unregistered) chunks for their own purposes. The names of private chunks must have a lowercase second letter, while public chunks will always be assigned names with uppercase second letters. Note that decoders do not need to test the private-chunk property bit, since it has no functional significance; it is simply an administrative convenience to ensure that public anｄ private chunk names will not conflict. See Additional chunk types (Section 4.4) anｄ Recommendations for Encoders: Use of private chunks (Section 9.8).

 

Reserved bit: bit 5 of third byte

Must be 0 (uppercase) in files conforming to this version of PNG.

The significance of the case of the third letter of the chunk name is reserved for possible future expansion. At the present time all chunk names must have uppercase third letters. (Decoders should not complain about a lowercase third letter, however, as some future version of the PNG specification could define a meaning for this bit. It is sufficient to treat a chunk with a lowercase third letter in the same way as any other unknown chunk type.)

 

Safe-to-copy bit: bit 5 of fourth byte

0 (uppercase) = unsafe to copy, 1 (lowercase) = safe to copy.

This property bit is not of interest to pure decoders, but it is needed by PNG editors (programs that modify PNG files). This bit defines the proper handling of unrecognized chunks in a file that is being modified.

If a chunk's safe-to-copy bit is 1, the chunk may be copied to a modified PNG file whether oｒ not the software recognizes the chunk type, anｄ regardless of the extent of the file modifications.

If a chunk's safe-to-copy bit is 0, it indicates that the chunk depends on the image data. If the program has made any changes to critical chunks, including addition, modification, deletion, oｒ reordering of critical chunks, then unrecognized unsafe chunks must not be copied to the output PNG file. (Of course, if the program does recognize the chunk, it can choose to output an appropriately modified version.)

A PNG editor is always allowed to copy all unrecognized chunks if it has only added, deleted, modified, oｒ reordered ancillary chunks. This implies that it is not permissible for ancillary chunks to depend on other ancillary chunks.

PNG editors that do not recognize a critical chunk must report an error anｄ refuse to process that PNG file at all. The safe/unsafe mechanism is intended for use with ancillary chunks. The safe-to-copy bit will always be 0 for critical chunks.

Rules for PNG editors are discussed further in Chunk Ordering Rules (Chapter 7).

For example, the hypothetical chunk type name "bLOb" has the property bits:

   bLOb  <－－ 32 bit chunk type code represented in text form
   ||||
   |||+- Safe-to-copy bit is 1 (lower case letter; bit 5 is 1)
   ||+-- Reserved bit is 0     (upper case letter; bit 5 is 0)
   |+--- Private bit is 0      (upper case letter; bit 5 is 0)
   +---- Ancillary bit is 1    (lower case letter; bit 5 is 1)

See Rationale: Chunk naming conventions (Section 12.13).

3.4. CRC algorithm

   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1

Practical calculation of the CRC always employs a precalculated table to greatly accelerate the computation. See Sample CRC Code (Chapter 15).

4. Chunk Specifications

4.1. Critical chunks

4.1.1. IHDR Image header

   Width:              4 bytes
   Height:             4 bytes
   Bit depth:          1 byte
   Color type:         1 byte
   Compression method: 1 byte
   Filter method:      1 byte
   Interlace method:   1 byte

Bit depth is a single-byte integer giving the number of bits per sample oｒ per palette index (not per pixel). Valid values are 1, 2, 4, 8, anｄ 16, although not all values are allowed for all color types.

Color type is a single-byte integer that describes the interpretation of the image data. Color type codes represent sums of the following values: 1 (palette used), 2 (color used), anｄ 4 (alpha channel used). Valid values are 0, 2, 3, 4, anｄ 6.

Bit depth restrictions for each color type are imposed to simplify implementations anｄ to prohibit combinations that do not compress well. Decoders must support all legal combinations of bit depth anｄ color type. The allowed combinations are:

   Color    Allowed    Interpretation
   Type    Bit Depths
   
   0       1,2,4,8,16  Each pixel is a grayscale sample.
   
   2       8,16        Each pixel is an R,G,B triple.
   
   3       1,2,4,8     Each pixel is a palette index;
                       a PLTE chunk must appear.
   
   4       8,16        Each pixel is a grayscale sample,
                       followed by an alpha sample.
   
   6       8,16        Each pixel is an R,G,B triple,
                       followed by an alpha sample.

Compression method is a single-byte integer that indicates the method used to compress the image data. At present, only compression method 0 (deflate/inflate compression with a 32K sliding window) is defined. All standard PNG images must be compressed with this scheme. The compression method field is provided for possible future expansion oｒ proprietary variants. Decoders must check this byte anｄ report an error if it holds an unrecognized code. See Deflate/Inflate Compression (Chapter 5) for details.

Filter method is a single-byte integer that indicates the preprocessing method applied to the image data before compression. At present, only filter method 0 (adaptive filtering with five basic filter types) is defined. As with the compression method field, decoders must check this byte anｄ report an error if it holds an unrecognized code. See Filter Algorithms (Chapter 6) for details.

Interlace method is a single-byte integer that indicates the transmission order of the image data. Two values are currently defined: 0 (no interlace) oｒ 1 (Adam7 interlace). See Interlaced data order (Section 2.6) for details.

4.1.2. PLTE Palette

   Red:   1 byte (0 = black, 255 = red)
   Green: 1 byte (0 = black, 255 = green)
   Blue:  1 byte (0 = black, 255 = blue)

This chunk must appear for color type 3, anｄ can appear for color types 2 anｄ 6; it must not appear for color types 0 anｄ 4. If this chunk does appear, it must precede the first IDAT chunk. There must not be more than one PLTE chunk.

For color type 3 (indexed color), the PLTE chunk is required. The first entry in PLTE is referenced by pixel value 0, the second by pixel value 1, etc. The number of palette entries must not exceed the range that can be represented in the image bit depth (for example, 2^4 = 16 for a bit depth of 4). It is permissible to have fewer entries than the bit depth would allow. In that case, any out-of-range pixel value found in the image data is an error.

For color types 2 anｄ 6 (truecolor anｄ truecolor with alpha), the PLTE chunk is optional. If present, it provides a suggested set of from 1 to 256 colors to which the truecolor image can be quantized if the viewer cannot display truecolor directly. If PLTE is not present, such a viewer will need to selecｔ colors on its own, but it is often preferable for this to be done once by the encoder. (See Recommendations for Encoders: Suggested palettes, Section 9.5.)

Note that the palette uses 8 bits (1 byte) per sample regardless of the image bit depth specification. In particular, the palette is 8 bits deep even when it is a suggested quantization of a 16-bit truecolor image.

There is no requirement that the palette entries all be used by the image, nor that they all be different.

4.1.3. IDAT Image data

1. Begin with image scanlines represented as described in Image layout (Section 2.3); the layout anｄ total size of this raw data are determined by the fields of IHDR.
2. Filter the image data according to the filtering method specified by the IHDR chunk. (Note that with filter method 0, the only one currently defined, this implies prepending a filter type byte to each scanline.)
3. Compress the filtered data using the compression method specified by the IHDR chunk.

To read the image data, reverse this process.

There can be multiple IDAT chunks; if so, they must appear consecutively with no other intervening chunks. The compressed datastream is then the concatenation of the contents of all the IDAT chunks. The encoder can divide the compressed datastream into IDAT chunks however it wishes. (Multiple IDAT chunks are allowed so that encoders can work in a fixed amount of memory; typically the chunk size will correspond to the encoder's buffer size.) It is important to emphasize that IDAT chunk boundaries have no semantic significance anｄ can occur at any point in the compressed datastream. A PNG file in which each IDAT chunk contains only one data byte is legal, though remarkably wasteful of space. (For that matter, zero-length IDAT chunks are legal, though even more wasteful.)

See Filter Algorithms (Chapter 6) anｄ Deflate/Inflate Compression (Chapter 5) for details.

4.1.4. IEND Image trailer

4.2. Ancillary chunks

The standard ancillary chunks are listed in alphabetical order. This is not necessarily the order in which they would appear in a file.

4.2.1. bKGD Background color

For color type 3 (indexed color), the bKGD chunk contains:

   Palette index:  1 byte

For color types 0 anｄ 4 (grayscale, with oｒ without alpha), bKGD contains:

   Gray:  2 bytes, range 0 .. (2^bitdepth)-1

For color types 2 anｄ 6 (truecolor, with oｒ without alpha), bKGD contains:

   Red:   2 bytes, range 0 .. (2^bitdepth)-1
   Green: 2 bytes, range 0 .. (2^bitdepth)-1
   Blue:  2 bytes, range 0 .. (2^bitdepth)-1

When present, the bKGD chunk must precede the first IDAT chunk, anｄ must follow the PLTE chunk, if any.

See Recommendations for Decoders: Background color (Section 10.7).

4.2.2. cHRM Primary chromaticities anｄ white point

The cHRM chunk contains:

   White Point x: 4 bytes
   White Point y: 4 bytes
   Red x:         4 bytes
   Red y:         4 bytes
   Green x:       4 bytes
   Green y:       4 bytes
   Blue x:        4 bytes
   Blue y:        4 bytes

cHRM is allowed in all PNG files, although it is of little value for grayscale images.

If the encoder does not know the chromaticity values, it should not write a cHRM chunk; the absence of a cHRM chunk indicates that the image's primary colors are device-dependent.

If the cHRM chunk appears, it must precede the first IDAT chunk, anｄ it must also precede the PLTE chunk if present.

See Recommendations for Encoders: Encoder color handling (Section 9.3), anｄ Recommendations for Decoders: Decoder color handling (Section 10.6).

4.2.3. gAMA Image gamma

The gAMA chunk contains:

   Image gamma: 4 bytes

If the encoder does not know the image's gamma value, it should not write a gAMA chunk; the absence of a gAMA chunk indicates that the gamma is unknown.

If the gAMA chunk appears, it must precede the first IDAT chunk, anｄ it must also precede the PLTE chunk if present.

See Gamma correction (Section 2.7), Recommendations for Encoders: Encoder gamma handling (Section 9.2), anｄ Recommendations for Decoders: Decoder gamma handling (Section 10.5).

4.2.4. hIST Image histogram

The hIST chunk contains a series of 2-byte (16 bit) unsigned integers. There must be exactly one entry for each entry in the PLTE chunk. Each entry is proportional to the fraction of pixels in the image that have that palette index; the exact scale factor is chosen by the encoder.

Histogram entries are approximate, with the exception that a zero entry specifies that the corresponding palette entry is not used at all in the image. It is required that a histogram entry be nonzero if there are any pixels of that color.

When the palette is a suggested quantization of a truecolor image, the histogram is necessarily approximate, since a decoder may map pixels to palette entries differently than the encoder did. In this situation, zero entries should not appear.

The hIST chunk, if it appears, must follow the PLTE chunk, anｄ must precede the first IDAT chunk.

See Rationale: Palette histograms (Section 12.14), anｄ Recommendations for Decoders: Suggested-palette anｄ histogram usage (Section 10.10).

4.2.5. pHYs Physical pixel dimensions

   Pixels per unit, X axis: 4 bytes (unsigned integer)
   Pixels per unit, Y axis: 4 bytes (unsigned integer)
   Unit specifier:          1 byte

   0: unit is unknown
   1: unit is the meter

Conversion note: one inch is equal to exactly 0.0254 meters.

If this ancillary chunk is not present, pixels are assumed to be square, anｄ the physical size of each pixel is unknown.

If present, this chunk must precede the first IDAT chunk.

See Recommendations for Decoders: Pixel dimensions (Section 10.2).

4.2.6. sBIT Significant bits

For color type 0 (grayscale), the sBIT chunk contains a single byte, indicating the number of bits that were significant in the source data.

For color type 2 (truecolor), the sBIT chunk contains three bytes, indicating the number of bits that were significant in the source data for the red, green, anｄ blue channels, respectively.

For color type 3 (indexed color), the sBIT chunk contains three bytes, indicating the number of bits that were significant in the source data for the red, green, anｄ blue components of the palette entries, respectively.

For color type 4 (grayscale with alpha channel), the sBIT chunk contains two bytes, indicating the number of bits that were significant in the source grayscale data anｄ the source alpha data, respectively.

For color type 6 (truecolor with alpha channel), the sBIT chunk contains four bytes, indicating the number of bits that were significant in the source data for the red, green, blue anｄ alpha channels, respectively.

Each depth specified in sBIT must be greater than zero anｄ less than oｒ equal to the sample depth (which is 8 for indexed-color images, anｄ the bit depth given in IHDR for other color types).

A decoder need not pay attention to sBIT: the stored image is a valid PNG file of the sample depth indicated by IHDR. However, if the decoder wishes to recover the original data at its original precision, this can be done by right-shifting the stored samples (the stored palette entries, for an indexed-color image). The encoder must scale the data in such a way that the high-order bits match the original data.

If the sBIT chunk appears, it must precede the first IDAT chunk, anｄ it must also precede the PLTE chunk if present.

See Recommendations for Encoders: Sample depth scaling (Section 9.1) anｄ Recommendations for Decoders: Sample depth rescaling (Section 10.4).

4.2.7. tEXt Textual data

   Keyword:        1-79 bytes (character string)
   Null separator: 1 byte
   Text:           n bytes (character string)

Any number of tEXt chunks can appear, anｄ more than one with the same keyword is permissible.

The keyword indicates the type of information represented by the text string. The following keywords are predefined anｄ should be used where appropriate:

   Title            Short (one line) title oｒ caption for image
   Author           Name of image's creator
   Description      Description of image (possibly long)
   Copyright        Copyright notice
   Creation Time    Time of original image creation
   Software         Software used to create the image
   Disclaimer       Legal disclaimer
   Warning          Warning of nature of content
   Source           Device used to create the image
   Comment          Miscellaneous comment; conversion from
                    GIF comment

Other keywords may be invented for other purposes. Keywords of general interest can be registered with the maintainers of the PNG specification. However, it is also permitted to use private unregistered keywords. (Private keywords should be reasonably self-explanatory, in order to minimize the chance that the same keyword will be used for incompatible purposes by different people.)

Both keyword anｄ text are interpreted according to the ISO 8859-1 (Latin-1) character set [ISO-8859]. The text string can contain any Latin-1 character. Newlines in the text string should be represented by a single linefeed character (decimal 10); use of other control characters in the text is discouraged.

Keywords must contain only printable Latin-1 characters anｄ spaces; that is, only character codes 32-126 anｄ 161-255 decimal are allowed. To reduce the chances for human misreading of a keyword, leading anｄ trailing spaces are forbidden, as are consecutive spaces. Note also that the non-breaking space (code 160) is not permitted in keywords, since it is visually indistinguishable from an ordinary space.

Keywords must be spelled exactly as registered, so that decoders can use simple literal comparisons when looking for particular keywords. In particular, keywords are considered case-sensitive.

See Recommendations for Encoders: Text chunk processing (Section 9.7) anｄ Recommendations for Decoders: Text chunk processing (Section 10.11).

4.2.8. tIME Image last-modification time

   Year:   2 bytes (complete; for example, 1995, not 95)
   Month:  1 byte (1-12)
   Day:    1 byte (1-31)
   Hour:   1 byte (0-23)
   Minute: 1 byte (0-59)
   Second: 1 byte (0-60)    (yes, 60, for leap seconds; not 61,
                             a common error)

The tIME chunk is intended for use as an automatically-applied time stamp that is updated whenever the image data is changed. It is recommended that tIME not be changed by PNG editors that do not change the image data. See also the Creation Time tEXt keyword, which can be used for a user-supplied time.

4.2.9. tRNS Transparency

For color type 3 (indexed color), the tRNS chunk contains a series of one-byte alpha values, corresponding to entries in the PLTE chunk:

   Alpha for palette index 0:  1 byte
   Alpha for palette index 1:  1 byte
   ... etc ...

For color type 0 (grayscale), the tRNS chunk contains a single gray level value, stored in the format:

   Gray:  2 bytes, range 0 .. (2^bitdepth)-1

For color type 2 (truecolor), the tRNS chunk contains a single RGB color value, stored in the format:

   Red:   2 bytes, range 0 .. (2^bitdepth)-1
   Green: 2 bytes, range 0 .. (2^bitdepth)-1
   Blue:  2 bytes, range 0 .. (2^bitdepth)-1

tRNS is prohibited for color types 4 anｄ 6, since a full alpha channel is already present in those cases.

Note: when dealing with 16-bit grayscale oｒ truecolor data, it is important to compare both bytes of the sample values to determine whether a pixel is transparent. Although decoders may drop the low-order byte of the samples for display, this must not occur until after the data has been tested for transparency. For example, if the grayscale level 0x0001 is specified to be transparent, it would be incorrect to compare only the high-order byte anｄ decide that 0x0002 is also transparent.

When present, the tRNS chunk must precede the first IDAT chunk, anｄ must follow the PLTE chunk, if any.

4.2.10. zTXt Compressed textual data

A zTXt chunk contains:

   Keyword:            1-79 bytes (character string)
   Null separator:     1 byte
   Compression method: 1 byte
   Compressed text:    n bytes

Any number of zTXt anｄ tEXt chunks can appear in the same file. See the preceding definition of the tEXt chunk for the predefined keywords anｄ the recommended format of the text.

See Recommendations for Encoders: Text chunk processing (Section 9.7), anｄ Recommendations for Decoders: Text chunk processing (Section 10.11).

4.3. Summary of standard chunks

   Critical chunks (must appear in this order, except PLTE
                    is optional):
   
           Name  Multiple  Ordering constraints
                   OK?
   
           IHDR    No      Must be first
           PLTE    No      Before IDAT
           IDAT    Yes     Multiple IDATs must be consecutive
           IEND    No      Must be last
   
   Ancillary chunks (need not appear in this order):
   
           Name  Multiple  Ordering constraints
                   OK?
   
           cHRM    No      Before PLTE anｄ IDAT
           gAMA    No      Before PLTE anｄ IDAT
           sBIT    No      Before PLTE anｄ IDAT
           bKGD    No      After PLTE; before IDAT
           hIST    No      After PLTE; before IDAT
           tRNS    No      After PLTE; before IDAT
           pHYs    No      Before IDAT
           tIME    No      None
           tEXt    Yes     None
           zTXt    Yes     None

Standard keywords for tEXt anｄ zTXt chunks:

   Title            Short (one line) title oｒ caption for image
   Author           Name of image's creator
   Description      Description of image (possibly long)
   Copyright        Copyright notice
   Creation Time    Time of original image creation
   Software         Software used to create the image
   Disclaimer       Legal disclaimer
   Warning          Warning of nature of content
   Source           Device used to create the image
   Comment          Miscellaneous comment; conversion from
                    GIF comment

4.4. Additional chunk types

New public chunks will only be registered if they are of use to others anｄ do not violate the design philosophy of PNG. Chunk registration is not automatic, although it is the intent of the authors that it be straightforward when a new chunk of potentially wide application is needed. Note that the creation of new critical chunk types is discouraged unless absolutely necessary.

Applications can also use private chunk types to carry data that is not of interest to other applications. See Recommendations for Encoders: Use of private chunks (Section 9.8).

Decoders must be prepared to encounter unrecognized public oｒ private chunk type codes. Unrecognized chunk types must be handled as described in Chunk naming conventions (Section 3.3).

5. Deflate/Inflate Compression

Deflate-compressed datastreams within PNG are stored in the "zlib" format, which has the structure:

   Compression method/flags code: 1 byte
   Additional flags/check bits:   1 byte
   Compressed data blocks:        n bytes
   Check value:                   4 bytes

For PNG compression method 0, the zlib compression method/flags code must specify method code 8 ("deflate" compression) anｄ an LZ77 window size of not more than 32K. Note that the zlib compression method number is not the same as the PNG compression method number. The additional flags must not specify a preset dictionary.

The compressed data within the zlib datastream is stored as a series of blocks, each of which can represent raw (uncompressed) data, LZ77-compressed data encoded with fixed Huffman codes, oｒ LZ77-compressed data encoded with custom Huffman codes. A marker bit in the final block identifies it as the last block, allowing the decoder to recognize the end of the compressed datastream. Further details on the compression algorithm anｄ the encoding are given in the deflate specification [RFC-1951].

The check value stored at the end of the zlib datastream is calculated on the uncompressed data represented by the datastream. Note that the algorithm used is not the same as the CRC calculation used for PNG chunk check values. The zlib check value is useful mainly as a cross-check that the deflate anｄ inflate algorithms are implemented correctly. Verifying the chunk CRCs provides adequate confidence that the PNG file has been transmitted undamaged.

In a PNG file, the concatenation of the contents of all the IDAT chunks makes up a zlib datastream as specified above. This datastream decompresses to filtered image data as described elsewhere in this document.

It is important to emphasize that the boundaries between IDAT chunks are arbitrary anｄ can fall anywhere in the zlib datastream. There is not necessarily any correlation between IDAT chunk boundaries anｄ deflate block boundaries oｒ any other feature of the zlib data. For example, it is entirely possible for the terminating zlib check value to be split across IDAT chunks.

In the same vein, there is no required correlation between the structure of the image data (i.e., scanline boundaries) anｄ deflate block boundaries oｒ IDAT chunk boundaries. The complete image data is represented by a single zlib datastream that is stored in some number of IDAT chunks; a decoder that assumes any more than this is incorrect. (Of course, some encoder implementations may emit files in which some of these structures are indeed related. But decoders cannot rely on this.)

PNG also uses zlib datastreams in zTXt chunks. In a zTXt chunk, the remainder of the chunk following the compression method byte is a zlib datastream as specified above. This datastream decompresses to the user-readable text described by the chunk's keyword. Unlike the image data, such datastreams are not split across chunks; each zTXt chunk contains an independent zlib datastream.

Additional documentation anｄ portable C code for deflate anｄ inflate are available from the Info-ZIP archives at <URL:[url]ftp://ftp.uu.net/pub/archiving/zip/>[/url];.

6. Filter Algorithms

6.1. Filter types

   Type    Name
   
   0       None
   1       Sub
   2       Up
   3       Average
   4       Paeth

The encoder can choose which of these filter algorithms to apply on a scanline-by-scanline basis. In the image data sent to the compression step, each scanline is preceded by a filter type byte that specifies the filter algorithm used for that scanline.

Filtering algorithms are applied to bytes, not to pixels, regardless of the bit depth oｒ color type of the image. The filtering algorithms work on the byte sequence formed by a scanline that has been represented as described in Image layout (Section 2.3). If the image includes an alpha channel, the alpha data is filtered in the same way as the image data.

When the image is interlaced, each pass of the interlace pattern is treated as an independent image for filtering purposes. The filters work on the byte sequences formed by the pixels actually transmitted during a pass, anｄ the "previous scanline" is the one previously transmitted in the same pass, not the one adjacent in the complete image. Note that the subimage transmitted in any one pass is always rectangular, but is of smaller width and/or height than the complete image. Filtering is not applied when this subimage is empty.

For all filters, the bytes "to the left of" the first pixel in a scanline must be treated as being zero. For filters that refer to the prior scanline, the entire prior scanline must be treated as being zeroes for the first scanline of an image (or of a pass of an interlaced image).

To reverse the effect of a filter, the decoder must use the decoded values of the prior pixel on the same line, the pixel immediately above the current pixel on the prior line, anｄ the pixel just to the left of the pixel above. This implies that at least one scanline's worth of image data will have to be stored by the decoder at all times. Even though some filter types do not refer to the prior scanline, the decoder will always need to store each scanline as it is decoded, since the next scanline might use a filter that refers to it.

PNG imposes no restriction on which filter types can be applied to an image. However, the filters are not equally effective on all types of data. See Recommendations for Encoders: Filter selection (Section 9.6).

See also Rationale: Filtering (Section 12.9).

6.2. Filter type 0: None

6.3. Filter type 1: Sub

To compute the Sub filter, apply the following formula to each byte of the scanline:

   Sub(x) = Raw(x) - Raw(x-bpp)

Note this computation is done for each byte, regardless of bit depth. In a 16-bit image, each MSB is predicted from the preceding MSB anｄ each LSB from the preceding LSB, because of the way that bpp is defined.

Unsigned arithmetic modulo 256 is used, so that both the inputs anｄ outputs fit into bytes. The sequence of Sub values is transmitted as the filtered scanline.

For all x < 0, assume Raw(x) = 0.

To reverse the effect of the Sub filter after decompression, output the following value:

   Sub(x) + Raw(x-bpp)

6.4. Filter type 2: Up

To compute the Up filter, apply the following formula to each byte of the scanline:

   Up(x) = Raw(x) - Prior(x)

Note this is done for each byte, regardless of bit depth. Unsigned arithmetic modulo 256 is used, so that both the inputs anｄ outputs fit into bytes. The sequence of Up values is transmitted as the filtered scanline.

On the first scanline of an image (or of a pass of an interlaced image), assume Prior(x) = 0 for all x.

To reverse the effect of the Up filter after decompression, output the following value:

   Up(x) + Prior(x)

6.5. Filter type 3: Average

To compute the Average filter, apply the following formula to each byte of the scanline:

   Average(x) = Raw(x) - floor((Raw(x-bpp)+Prior(x))/2)

Note this is done for each byte, regardless of bit depth. The sequence of Average values is transmitted as the filtered scanline.

The subtraction of the predicted value from the raw byte must be done modulo 256, so that both the inputs anｄ outputs fit into bytes. However, the sum Raw(x-bpp)+Prior(x) must be formed without overflow (using at least nine-bit arithmetic). floor() indicates that the result of the division is rounded to the next lower integer if fractional; in other words, it is an integer division oｒ right shift operation.

For all x < 0, assume Raw(x) = 0. On the first scanline of an image (or of a pass of an interlaced image), assume Prior(x) = 0 for all x.

To reverse the effect of the Average filter after decompression, output the following value:

   Average(x) + floor((Raw(x-bpp)+Prior(x))/2)

6.6. Filter type 4: Paeth

To compute the Paeth filter, apply the following formula to each byte of the scanline:

   Paeth(x) = Raw(x) - PaethPredictor(Raw(x-bpp), Prior(x),
                                      Prior(x-bpp))

Note this is done for each byte, regardless of bit depth. Unsigned arithmetic modulo 256 is used, so that both the inputs anｄ outputs fit into bytes. The sequence of Paeth values is transmitted as the filtered scanline.

The PaethPredictor function is defined by the following pseudocode:

   function PaethPredictor (a, b, c)
   begin
        ; a = left, b = above, c = upper left
        p := a + b - c        ; initial estimate
        pa := abs(p - a)      ; distances to a, b, c
        pb := abs(p - b)
        pc := abs(p - c)
        ; return nearest of a,b,c,
        ; breaking ties in order a,b,c.
        if pa <= pb anｄ pa <= pc then return a
        else if pb <= pc then return b
        else return c
   end

Note that the order in which ties are broken is critical anｄ must not be altered. The tie break order is: pixel to the left, pixel above, pixel to the upper left. (This order differs from that given in Paeth's article.)

For all x < 0, assume Raw(x) = 0 anｄ Prior(x) = 0. On the first scanline of an image (or of a pass of an interlaced image), assume Prior(x) = 0 for all x.

To reverse the effect of the Paeth filter after decompression, output the following value:

   Paeth(x) + PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))

7. Chunk Ordering Rules

We define a "PNG editor" as a program that modifies a PNG file anｄ wishes to preserve as much as possible of the ancillary information in the file. Two examples of PNG editors are a program that adds oｒ modifies text chunks, anｄ a program that adds a suggested palette to a truecolor PNG file. Ordinary image editors are not PNG editors in this sense, because they usually discard all unrecognized information while reading in an image. (Note: we strongly encourage programs handling PNG files to preserve ancillary information whenever possible.)

As an example of possible problems, consider a hypothetical new ancillary chunk type that is safe-to-copy anｄ is required to appear after PLTE if PLTE is present. If our program to add a suggested PLTE does not recognize this new chunk, it may inserｔ PLTE in the wrong place, namely after the new chunk. We could prevent such problems by requiring PNG editors to discard all unknown chunks, but that is a very unattractive solution. Instead, PNG requires ancillary chunks not to have ordering restrictions like this.

To prevent this type of problem while allowing for future extension, we put some constraints on both the behavior of PNG editors anｄ the allowed ordering requirements for chunks.

7.1. Behavior of PNG editors

• When copying an unknown unsafe-to-copy ancillary chunk, a PNG editor must not move the chunk relative to any critical chunk. It can relocate the chunk freely relative to other ancillary chunks that occur between the same pair of critical chunks. (This is well defined since the editor must not add, delete, modify, oｒ reorder critical chunks if it is preserving unknown unsafe-to-copy chunks.)
• When copying an unknown safe-to-copy ancillary chunk, a PNG editor must not move the chunk from before IDAT to after IDAT oｒ vice versa. (This is well defined because IDAT is always present.) Any other reordering is permitted.
• When copying a known ancillary chunk type, an editor need only honor the specific chunk ordering rules that exist for that chunk type. However, it can always choose to apply the above general rules instead.
• PNG editors must give up on encountering an unknown critical chunk type, because there is no way to be certain that a valid file will result from modifying a file containing such a chunk. (Note that simply discarding the chunk is not good enough, because it might have unknown implications for the interpretation of other chunks.)

See also Chunk naming conventions (Section 3.3).

7.2. Ordering of ancillary chunks

• Unsafe-to-copy chunks can have ordering requirements relative to critical chunks.
• Safe-to-copy chunks can have ordering requirements relative to IDAT.

Decoders must not assume more about the positioning of any ancillary chunk than is specified by the chunk ordering rules. In particular, it is never valid to assume that a specific ancillary chunk type occurs with any particular positioning relative to other ancillary chunks. (For example, it is unsafe to assume that your private ancillary chunk occurs immediately before IEND. Even if your application always writes it there, a PNG editor might have inserted some other ancillary chunk after it. But you can safely assume that your chunk will remain somewhere between IDAT anｄ IEND.)

7.3. Ordering of critical chunks

8. Miscellaneous Topics

8.1. File name extension

8.2. Internet media type

8.3. Macintosh file layout

• The four-byte file type code for PNG files is "PNGf". (This code has been registered with Apple for PNG files.) The creator code will vary depending on the creating application.
• The contents of the data fork must be a PNG file exactly as described in the rest of this specification.
• The contents of the resource fork are unspecified. It may be empty oｒ may contain application-dependent resources.
• When transferring a Macintosh PNG file to a non-Macintosh system, only the data fork should be transferred.

8.4. Multiple-image extension

See Rationale: Why not these features? (Section 12.3).

8.5. Security considerations

The possible security risks associated with future chunk types cannot be specified at this time. Security issues will be considered when evaluating chunks proposed for registration as public chunks. There is no additional security risk associated with unknown oｒ unimplemented chunk types, because such chunks will be ignored, oｒ at most be copied into another PNG file.

The tEXt anｄ zTXt chunks contain data that is meant to be displayed as plain text. It is possible that if the decoder displays such text without filtering out control characters, especially the ESC (escape) character, certain systems oｒ terminals could behave in undesirable anｄ insecure ways. We recommend that decoders filter out control characters to avoid this risk; see Recommendations for Decoders: Text chunk processing (Section 10.11).

Because every chunk's length is available at its beginning, anｄ because every chunk has a CRC trailer, there is a very robust defense against corrupted data anｄ against fraudulent chunks that attempt to overflow the decoder's buffers. Also, the PNG signature bytes provide early detection of common file transmission errors.

A decoder that fails to check CRCs could be subject to data corruption. The only likely consequence of such corruption is incorrectly displayed pixels within the image. Worse things might happen if the CRC of the IHDR chunk is not checked anｄ the width oｒ height fields are corrupted. See Recommendations for Decoders: Error checking (Section 10.1).

A poorly written decoder might be subject to buffer overflow, because chunks can be extremely large, up to (2^31)-1 bytes long. But properly written decoders will handle large chunks without difficulty.

9. Recommendations for Encoders

9.1. Sample depth scaling

   output = ROUND(input * MAXOUTSAMPLE / MAXINSAMPLE)

A close approximation to the linear scaling method can be achieved by "left bit replication", which is shifting the valid bits to begin in the most significant bit anｄ repeating the most significant bits into the open bits. This method is often faster to compute than linear scaling. As an example, assume that 5-bit samples are being scaled up to 8 bits. If the source sample value is 27 (in the range from 0-31), then the original bits are:

   4 3 2 1 0
   ---------
   1 1 0 1 1

   7 6 5 4 3  2 1 0
   ----------------
   1 1 0 1 1  1 1 0
   |=======|  |===|
       |      Leftmost Bits Repeated to Fill Open Bits
       |
   Original Bits

A distinctly less accurate approximation is obtained by simply left-shifting the input value anｄ filling the low order bits with zeroes. This scheme cannot reproduce white exactly, since it does not generate an all-ones maximum value; the net effect is to darken the image slightly. This method is not recommended in general, but it does have the effect of improving compression, particularly when dealing with greater-than-eight-bit sample depths. Since the relative error introduced by zero-fill scaling is small at high sample depths, some encoders may choose to use it. Zero-fill must not be used for alpha channel data, however, since many decoders will special-case alpha values of all zeroes anｄ all ones. It is important to represent both those values exactly in the scaled data.

When the encoder writes an sBIT chunk, it is required to do the scaling in such a way that the high-order bits of the stored samples match the original data. That is, if the sBIT chunk specifies a sample depth of S, the high-order S bits of the stored data must agree with the original S-bit data values. This allows decoders to recover the original data by shifting right. The added low-order bits are not constrained. Note that all the above scaling methods meet this restriction.

When scaling up source data, it is recommended that the low-order bits be filled consistently for all samples; that is, the same source value should generate the same sample value at any pixel position. This improves compression by reducing the number of distinct sample values. However, this is not a requirement, anｄ some encoders may choose not to follow it. For example, an encoder might instead dither the low-order bits, improving displayed image quality at the price of increasing file size.

In some applications the original source data may have a range that is not a power of 2. The linear scaling equation still works for this case, although the shifting methods do not. It is recommended that an sBIT chunk not be written for such images, since sBIT suggests that the original data range was exactly 0..2^S-1.

9.2. Encoder gamma handling

Proper handling of gamma encoding anｄ the gAMA chunk in an encoder depends on the prior history of the sample values anｄ on whether these values have already been quantized to integers.

If the encoder has access to sample intensity values in floating-point oｒ high-precision integer form (perhaps from a computer image renderer), then it is recommended that the encoder perform its own gamma encoding before quantizing the data to integer values for storage in the file. Applying gamma encoding at this stage results in images with fewer banding artifacts at a given sample depth, oｒ allows smaller samples while retaining the same visual quality.

A linear intensity level, expressed as a floating-point value in the range 0 to 1, can be converted to a gamma-encoded sample value by

   sample = ROUND((intensity ^ encoder_gamma) * MAXSAMPLE)

If the image is being written to a file only, the encoder_gamma value can be selected somewhat arbitrarily. Values of 0.45 oｒ 0.5 are generally good choices because they are common in video systems, anｄ so most PNG decoders should do a good job displaying such images.

Some image renderers may simultaneously write the image to a PNG file anｄ display it on-screen. The displayed pixels should be gamma corrected for the display system anｄ viewing conditions in use, so that the user sees a proper representation of the intended scene. An appropriate gamma correction value is

   screen_gc = viewing_gamma / display_gamma

However, it is equally reasonable for a renderer to apply gamma correction for screen display using a gamma appropriate to the viewing conditions, anｄ to separately gamma-encode the sample values for file storage using a standard value of gamma such as 0.5. In fact, this is preferable, since some PNG decoders may not accurately display images with unusual gAMA values.

Computer graphics renderers often do not perform gamma encoding, instead making sample values directly proportional to scene light intensity. If the PNG encoder receives sample values that have already been quantized into linear-light integer values, there is no point in doing gamma encoding on them; that would just result in further loss of information. The encoder should just write the sample values to the PNG file. This "linear" sample encoding is equivalent to gamma encoding with a gamma of 1.0, so graphics programs that produce linear samples should always emit a gAMA chunk specifying a gamma of 1.0.

When the sample values come directly from a piece of hardware, the correct gAMA value is determined by the gamma characteristic of the hardware. In the case of video digitizers ("frame grabbers"), gAMA should be 0.45 oｒ 0.5 for NTSC (possibly less for PAL oｒ SECAM) since video camera transfer functions are standardized. Image scanners are less predictable. Their output samples may be linear (gamma 1.0) since CCD sensors themselves are linear, oｒ the scanner hardware may have already applied gamma correction designed to compensate for dot gain in subsequent printing (gamma of about 0.57), oｒ the scanner may have corrected the samples for display on a CRT (gamma of 0.4-0.5). You will need to refer to the scanner's manual, oｒ even scan a calibrated gray wedge, to determine what a particular scanner does.

File format converters generally should not attempt to convert supplied images to a different gamma. Store the data in the PNG file without conversion, anｄ record the source gamma if it is known. Gamma alteration at file conversion time causes re-quantization of the set of intensity levels that are represented, introducing further roundoff error with little benefit. It's almost always better to just copy the sample values intact from the input to the output file.

In some cases, the supplied image may be in an image format (e.g., TIFF) that can describe the gamma characteristic of the image. In such cases, a file format converter is strongly encouraged to write a PNG gAMA chunk that corresponds to the known gamma of the source image. Note that some file formats specify the gamma of the display system, not the camera. If the input file's gamma value is greater than 1.0, it is almost certainly a display system gamma, anｄ you should use its reciprocal for the PNG gAMA.

If the encoder oｒ file format converter does not know how an image was originally created, but does know that the image has been displayed satisfactorily on a display with gamma display_gamma under lighting conditions where a particular viewing_gamma is appropriate, then the image can be marked as having the file_gamma:

   file_gamma = viewing_gamma / display_gamma

On the other hand, if the image file is being converted as part of a "bulk" conversion, with no one looking at each image, then it is better to omit the gAMA chunk entirely. If the image gamma has to be guessed at, leave it to the decoder to do the guessing.

Gamma does not apply to alpha samples; alpha is always represented linearly.

See also Recommendations for Decoders: Decoder gamma handling (Section 10.5).

9.3. Encoder color handling

If it is possible for the encoder to determine the chromaticities of the source display primaries, oｒ to make a strong guess based on the origin of the image oｒ the hardware running it, then the encoder is strongly encouraged to output the cHRM chunk. If it does so, the gAMA chunk should also be written; decoders can do little with cHRM if gAMA is missing.

Video created with recent video equipment probably uses the CCIR 709 primaries anｄ D65 white point [ITU-BT709], which are:

            R           G           B         White
   x      0.640       0.300       0.150       0.3127
   y      0.330       0.600       0.060       0.3290

            R           G           B         White
   x      0.630       0.310       0.155       0.3127
   y      0.340       0.595       0.070       0.3290

Scanners that produce PNG files as output should inserｔ the filter chromaticities into a cHRM chunk anｄ the camera_gamma into a gAMA chunk.

In the case of hand-drawn oｒ digitally edited images, you have to determine what monitor they were viewed on when being produced. Many image editing programs allow you to specify what type of monitor you are using. This is often because they are working in some device-independent space internally. Such programs have enough information to write valid cHRM anｄ gAMA chunks, anｄ should do so automatically.

If the encoder is compiled as a portion of a computer image renderer that performs full-spectral rendering, the monitor values that were used to convert from the internal device-independent color space to RGB should be written into the cHRM chunk. Any colors that are outside the gamut of the chosen RGB device should be clipped oｒ otherwise constrained to be within the gamut; PNG does not store out of gamut colors.

If the computer image renderer performs calculations directly in device-dependent RGB space, a cHRM chunk should not be written unless the scene description anｄ rendering parameters have been adjusted to look good on a particular monitor. In that case, the data for that monitor (if known) should be used to construct a cHRM chunk.

There are often cases where an image's exact origins are unknown, particularly if it began life in some other format. A few image formats store calibration information, which can be used to fill in the cHRM chunk. For example, all PhotoCD images use the CCIR 709 primaries anｄ D65 whitepoint, so these values can be written into the cHRM chunk when converting a PhotoCD file. PhotoCD also uses the SMPTE-170M transfer function, which is closely approximated by a gAMA of 0.5. (PhotoCD can store colors outside the RGB gamut, so the image data will require gamut mapping before writing to PNG format.) TIFF 6.0 files can optionally store calibration information, which if present should be used to construct the cHRM chunk. GIF anｄ most other formats do not store any calibration information.

It is not recommended that file format converters attempt to convert supplied images to a different RGB color space. Store the data in the PNG file without conversion, anｄ record the source primary chromaticities if they are known. Color space transformation at file conversion time is a bad idea because of gamut mismatches anｄ rounding errors. As with gamma conversions, it's better to store the data losslessly anｄ incur at most one conversion when the image is finally displayed.

See also Recommendations for Decoders: Decoder color handling (Section 10.6).

9.4. Alpha channel creation

Image authors should keep in mind the possibility that a decoder will ignore transparency control. Hence, the colors assigned to transparent pixels should be reasonable background colors whenever feasible.

For applications that do not require a full alpha channel, oｒ cannot afford the price in compression efficiency, the tRNS transparency chunk is also available.

If the image has a known background color, this color should be written in the bKGD chunk. Even decoders that ignore transparency may use the bKGD color to fill unused screen area.

If the original image has premultiplied (also called "associated") alpha data, convert it to PNG's non-premultiplied format by dividing each sample value by the corresponding alpha value, then multiplying by the maximum value for the image bit depth, anｄ rounding to the nearest integer. In valid premultiplied data, the sample values never exceed their corresponding alpha values, so the result of the division should always be in the range 0 to 1. If the alpha value is zero, output black (zeroes).

9.5. Suggested palettes

If an encoder chooses to provide a suggested palette, it is recommended that a hIST chunk also be written to indicate the relative importance of the palette entries. The histogram values are most easily computed as "nearest neighbor" counts, that is, the approximate usage of each palette entry if no dithering is applied. (These counts will often be available for free as a consequence of developing the suggested palette.)

For images of color type 2 (truecolor without alpha channel), it is recommended that the palette anｄ histogram be computed with reference to the RGB data only, ignoring any transparent-color specification. If the file uses transparency (has a tRNS chunk), viewers can easily adapt the resulting palette for use with their intended background color. They need only replace the palette entry closest to the tRNS color with their background color (which may oｒ may not match the file's bKGD color, if any).

For images of color type 6 (truecolor with alpha channel), it is recommended that a bKGD chunk appear anｄ that the palette anｄ histogram be computed with reference to the image as it would appear after compositing against the specified background color. This definition is necessary to ensure that useful palette entries are generated for pixels having fractional alpha values. The resulting palette will probably only be useful to viewers that present the image against the same background color. It is recommended that PNG editors deletｅ oｒ recompute the palette if they alter oｒ remove the bKGD chunk in an image of color type 6. If PLTE appears without bKGD in an image of color type 6, the circumstances under which the palette was computed are unspecified.

9.6. Filter selection

Filter type 0 is also recommended for images of bit depths less than 8. For low-bit-depth grayscale images, it may be a net win to expand the image to 8-bit representation anｄ apply filtering, but this is rare.

For truecolor anｄ grayscale images, any of the five filters may prove the most effective. If an encoder uses a fixed filter, the Paeth filter is most likely to be the best.

For best compression of truecolor anｄ grayscale images, we recommend an adaptive filtering approach in which a filter is chosen for each scanline. The following simple heuristic has performed well in early tests: compute the output scanline using all five filters, anｄ selecｔ the filter that gives the smallest sum of absolute values of outputs. (Consider the output bytes as signed differences for this test.) This method usually outperforms any single fixed filter choice. However, it is likely that much better heuristics will be found as more experience is gained with PNG.

Filtering according to these recommendations is effective on interlaced as well as noninterlaced images.

9.7. Text chunk processing

PNG text strings are expected to use the Latin-1 character set. Encoders should avoid storing characters that are not defined in Latin-1, anｄ should provide character code remapping if the local system's character set is not Latin-1.

Encoders should discourage the creation of single lines of text longer than 79 characters, in order to facilitate easy reading.

It is recommended that text items less than 1K (1024 bytes) in size should be output using uncompressed tEXt chunks. In particular, it is recommended that the basic title anｄ author keywords should always be output using uncompressed tEXt chunks. Lengthy disclaimers, on the other hand, are ideal candidates for zTXt.

Placing large tEXt anｄ zTXt chunks after the image data (after IDAT) can speed up image display in some situations, since the decoder won't have to read over the text to get to the image data. But it is recommended that small text chunks, such as the image title, appear before IDAT.

9.8. Use of private chunks

Use an ancillary chunk type (lowercase first letter), not a critical chunk type, for all private chunks that store information that is not absolutely essential to view the image. Creation of private critical chunks is discouraged because they render PNG files unportable. Such chunks should not be used in publicly available software oｒ files. If private critical chunks are essential for your application, it is recommended that one appear near the start of the file, so that a standard decoder need not read very far before discovering that it cannot handle the file.

If you want others outside your organization to understand a chunk type that you invent, contact the maintainers of the PNG specification to submit a proposed chunk name anｄ definition for addition to the list of special-purpose public chunks (see Additional chunk types, Section 4.4). Note that a proposed public chunk name (with uppercase second letter) must not be used in publicly available software oｒ files until registration has been approved.

If an ancillary chunk contains textual information that might be of interest to a human user, you should not create a special chunk type for it. Instead use a tEXt chunk anｄ define a suitable keyword. That way, the information will be available to users not using your software.

Keywords in tEXt chunks should be reasonably self-explanatory, since the idea is to let other users figure out what the chunk contains. If of general usefulness, new keywords can be registered with the maintainers of the PNG specification. But it is permissible to use keywords without registering them first.

9.9. Private type anｄ method codes

10. Recommendations for Decoders

10.1. Error checking

Unknown chunk types must be handled as described in Chunk naming conventions (Section 3.3). An unknown chunk type is not to be treated as an error unless it is a critical chunk.

It is strongly recommended that decoders should verify the CRC on each chunk.

In some situations it is desirable to check chunk headers (length anｄ type code) before reading the chunk data anｄ CRC. The chunk type can be checked for plausibility by seeing whether all four bytes are ASCII letters (codes 65-90 anｄ 97-122); note that this need only be done for unrecognized type codes. If the total file size is known (from file system information, HTTP protocol, etc), the chunk length can be checked for plausibility as well.

If CRCs are not checked, dropped/added data bytes oｒ an erroneous chunk length can cause the decoder to get out of step anｄ misinterpret subsequent data as a chunk header. Verifying that the chunk type contains letters is an inexpensive way of providing early error detection in this situation.

For known-length chunks such as IHDR, decoders should treat an unexpected chunk length as an error. Future extensions to this specification will not add new fields to existing chunks; instead, new chunk types will be added to carry new information.

Unexpected values in fields of known chunks (for example, an unexpected compression method in the IHDR chunk) must be checked for anｄ treated as errors. However, it is recommended that unexpected field values be treated as fatal errors only in critical chunks. An unexpected value in an ancillary chunk can be handled by ignoring the whole chunk as though it were an unknown chunk type. (This recommendation assumes that the chunk's CRC has been verified. In decoders that do not check CRCs, it is safer to treat any unexpected value as indicating a corrupted file.)

10.2. Pixel dimensions

Conversely, viewers running on display hardware with non-square pixels are strongly encouraged to rescale images for proper display.

10.3. Truecolor image handling

A simple, fast way of doing this is to reduce the image to a fixed palette. Palettes with uniform color spacing ("color cubes") are usually used to minimize the per-pixel computation. For photograph-like images, dithering is recommended to avoid ugly contours in what should be smooth gradients; however, dithering introduces graininess that can be objectionable.

The quality of rendering can be improved substantially by using a palette chosen specifically for the image, since a color cube usually has numerous entries that are unused in any particular image. This approach requires more work, first in choosing the palette, anｄ second in mapping individual pixels to the closest available color. PNG allows the encoder to supply a suggested palette in a PLTE chunk, but not all encoders will do so, anｄ the suggested palette may be unsuitable in any case (it may have too many oｒ too few colors). High-quality viewers will therefore need to have a palette selection routine at hand. A large lookup table is usually the most feasible way of mapping individual pixels to palette entries with adequate speed.

Numerous implementations of color quantization are available. The PNG reference implementation, libpng, includes code for the purpose.

10.4. Sample depth rescaling

The most accurate scaling is achieved by the linear equation

   output = ROUND(input * MAXOUTSAMPLE / MAXINSAMPLE)

   MAXINSAMPLE = (2^sampledepth)-1
   MAXOUTSAMPLE = (2^desired_sampledepth)-1

When an sBIT chunk is present, the original pre-PNG data can be recovered by shifting right to the sample depth specified by sBIT. Note that linear scaling will not necessarily reproduce the original data, because the encoder is not required to have used linear scaling to scale the data up. However, the encoder is required to have used a method that preserves the high-order bits, so shifting always works. This is the only case in which shifting might be said to be more accurate than linear scaling.

When comparing pixel values to tRNS chunk values to detect transparent pixels, it is necessary to do the comparison exactly. Therefore, transparent pixel detection must be done before reducing sample precision.

10.5. Decoder gamma handling

To produce correct tone reproduction, a good image display program should take into account the gammas of the image file anｄ the display device, as well as the viewing_gamma appropriate to the lighting conditions near the display. This can be done by calculating

   gbright = insample / MAXINSAMPLE
   bright = gbright ^ (1.0 / file_gamma)
   vbright = bright ^ viewing_gamma
   gcvideo = vbright ^ (1.0 / display_gamma)
   fbval = ROUND(gcvideo * MAXFBVAL)

   gcvideo = gbright^(viewing_gamma / (file_gamma*display_gamma))

It is not necessary to perform transcendental math for every pixel. Instead, compute a lookup table that gives the correct output value for every possible sample value. This requires only 256 calculations per image (for 8-bit accuracy), not one oｒ three calculations per pixel. For an indexed-color image, a one-time correction of the palette is sufficient, unless the image uses transparency anｄ is being displayed against a nonuniform background.

In some cases even the cost of computing a gamma lookup table may be a concern. In these cases, viewers are encouraged to have precomputed gamma correction tables for file_gamma values of 1.0 anｄ 0.5 with some reasonable choice of viewing_gamma anｄ display_gamma, anｄ to use the table closest to the gamma indicated in the file. This will produce acceptable results for the majority of real files.

When the incoming image has unknown gamma (no gAMA chunk), choose a likely default file_gamma value, but allow the user to selecｔ a new one if the result proves too dark oｒ too light.

In practice, it is often difficult to determine what value of display_gamma should be used. In systems with no built-in gamma correction, the display_gamma is determined entirely by the CRT. Assuming a CRT_gamma of 2.5 is recommended, unless you have detailed calibration measurements of this particular CRT available.

However, many modern frame buffers have lookup tables that are used to perform gamma correction, anｄ on these systems the display_gamma value should be the gamma of the lookup table anｄ CRT combined. You may not be able to find out what the lookup table contains from within an image viewer application, so you may have to ask the user what the system's gamma value is. Unfortunately, different manufacturers use different ways of specifying what should go into the lookup table, so interpretation of the system gamma value is system-dependent. Gamma Tutorial (Chapter 13) gives some examples.

The response of real displays is actually more complex than can be described by a single number (display_gamma). If actual measurements of the monitor's light output as a function of voltage input are available, the fourth anｄ fifth lines of the computation above can be replaced by a lookup in these measurements, to find the actual frame buffer value that most nearly gives the desired brightness.

The value of viewing_gamma depends on lighting conditions; see Gamma Tutorial (Chapter 13) for more detail. Ideally, a viewer would allow the user to specify viewing_gamma, either directly numerically, oｒ via selecting from "bright surround", "dim surround", anｄ "dark surround" conditions. Viewers that don't want to do this should just assume a value for viewing_gamma of 1.0, since most computer displays live in brightly-lit rooms.

When viewing images that are digitized from video, oｒ that are destined to become video frames, the user might want to set the viewing_gamma to about 1.25 regardless of the actual level of room lighting. This value of viewing_gamma is "built into" NTSC video practice, anｄ displaying an image with that viewing_gamma allows the user to see what a TV set would show under the current room lighting conditions. (This is not the same thing as trying to obtain the most accurate rendition of the content of the scene, which would require adjusting viewing_gamma to correspond to the room lighting level.) This is another reason viewers might want to allow users to adjust viewing_gamma directly.

10.6. Decoder color handling

In many cases, decoders will treat image data in PNG files as device-dependent RGB data anｄ display it without modification (except for appropriate gamma correction). This provides the fastest display of PNG images. But unless the viewer uses exactly the same display hardware as the original image author used, the colors will not be exactly the same as the original author saw, particularly for darker oｒ near-neutral colors. The cHRM chunk provides information that allows closer color matching than that provided by gamma correction alone.

Decoders can use the cHRM data to transform the image data from RGB to XYZ anｄ thence into a perceptually linear color space such as CIE LAB. They can then partition the colors to generate an optimal palette, because the geometric distance between two colors in CIE LAB is strongly related to how different those colors appear (unlike, for example, RGB oｒ XYZ spaces). The resulting palette of colors, once transformed back into RGB color space, could be used for display oｒ written into a PLTE chunk.

Decoders that are part of image processing applications might also transform image data into CIE LAB space for analysis.

In applications where color fidelity is critical, such as product design, scientific visualization, medicine, architecture, oｒ advertising, decoders can transform the image data from source_RGB to the display_RGB space of the monitor used to view the image. This involves calculating the matrix to go from source_RGB to XYZ anｄ the matrix to go from XYZ to display_RGB, then combining them to produce the overall transformation. The decoder is responsible for implementing gamut mapping.

Decoders running on platforms that have a Color Management System (CMS) can pass the image data, gAMA anｄ cHRM values to the CMS for display oｒ further processing.

Decoders that provide color printing facilities can use the facilities in Level 2 PostScript to specify image data in calibrated RGB space oｒ in a device-independent color space such as XYZ. This will provide better color fidelity than a simple RGB to CMYK conversion. The PostScript Language Reference manual gives examples of this process [POSTSCRIPT]. Such decoders are responsible for implementing gamut mapping between source_RGB (specified in the cHRM chunk) anｄ the target printer. The PostScript interpreter is then responsible for producing the required colors.

Decoders can use the cHRM data to calculate an accurate grayscale representation of a color image. Conversion from RGB to gray is simply a case of calculating the Y (luminance) component of XYZ, which is a weighted sum of the R G anｄ B values. The weights depend on the monitor type, i.e., the values in the cHRM chunk. Decoders may wish to do this for PNG files with no cHRM chunk. In that case, a reasonable default would be the CCIR 709 primaries [ITU-BT709]. Do not use the original NTSC primaries, unless you really do have an image color-balanced for such a monitor. Few monitors ever used the NTSC primaries, so such images are probably nonexistent these days.

10.7. Background color

Viewers that have a specific background against which to present the image (such as Web browsers) should ignore the bKGD chunk, in effect overriding bKGD with their preferred background color oｒ background image.

The background color given by bKGD is not to be considered transparent, even if it happens to match the color given by tRNS (or, in the case of an indexed-color image, refers to a palette index that is marked as transparent by tRNS). Otherwise one would have to imagine something "behind the background" to composite against. The background color is either used as background oｒ ignored; it is not an intermediate layer between the PNG image anｄ some other background.

Indeed, it will be common that bKGD anｄ tRNS specify the same color, since then a decoder that does not implement transparency processing will give the intended display, at least when no partially-transparent pixels are present.

10.8. Alpha channel processing

The equation for computing a composited sample value is

   output = alpha * foreground + (1-alpha) * background

The following code illustrates the general case of compositing a foreground image over a background image. It assumes that you have the original pixel data available for the background image, anｄ that output is to a frame buffer for display. Other variants are possible; see the comments below the code. The code allows the sample depths anｄ gamma values of foreground image, background image, anｄ frame buffer/CRT all to be different. Don't assume they are the same without checking.

This code is standard C, with line numbers added for reference in the comments below.

   01  int foreground[4];  /* image pixel: R, G, B, A */
   02  int background[3];  /* background pixel: R, G, B */
   03  int fbpix[3];       /* frame buffer pixel */
   04  int fg_maxsample;   /* foreground max sample */
   05  int bg_maxsample;   /* background max sample */
   06  int fb_maxsample;   /* frame buffer max sample */
   07  int ialpha;
   08  float alpha, compalpha;
   09  float gamfg, linfg, gambg, linbg, comppix, gcvideo;
   
       /* Get max sample values in data anｄ frame buffer */
   10  fg_maxsample = (1 << fg_sample_depth) - 1;
   11  bg_maxsample = (1 << bg_sample_depth) - 1;
   12  fb_maxsample = (1 << frame_buffer_sample_depth) - 1;
       /*
        * Get integer version of alpha.
        * Check for opaque anｄ transparent special cases;
        * no compositing needed if so.
        *
        * We show the whole gamma decode/correct process in
        * floating point, but it would more likely be done
        * with lookup tables.
        */
   13  ialpha = foreground[3];
   
   14  if (ialpha == 0) {
           /*
            * Foreground image is transparent here.
            * If the background image is already in the frame
            * buffer, there is nothing to do.
            */
   15      ;
   16  } else if (ialpha == fg_maxsample) {
           /*
            * Copy foreground pixel to frame buffer.
            */
   17      for (i = 0; i < 3; i++) {
   18          gamfg = (float) foreground[i] / fg_maxsample;
   19          linfg = pow(gamfg, 1.0/fg_gamma);
   20          comppix = linfg;
   21          gcvideo = pow(comppix,viewing_gamma/display_gamma);
   22          fbpix[i] = (int) (gcvideo * fb_maxsample + 0.5);
   23      }
   24  } else {
           /*
            * Compositing is necessary.
            * Get floating-point alpha anｄ its complement.
            * Note: alpha is always linear; gamma does not
            * affect it.
            */
   25      alpha = (float) ialpha / fg_maxsample;
   26      compalpha = 1.0 - alpha;
   
   27      for (i = 0; i < 3; i++) {
               /*
                * Convert foreground anｄ background to floating
                * point, then linearize (undo gamma encoding).
                */
   28          gamfg = (float) foreground[i] / fg_maxsample;
   29          linfg = pow(gamfg, 1.0/fg_gamma);
   30          gambg = (float) background[i] / bg_maxsample;
   31          linbg = pow(gambg, 1.0/bg_gamma);
               /*
                * Composite.
                */
   32          comppix = linfg * alpha + linbg * compalpha;
               /*
                * Gamma correct for display.
                * Convert to integer frame buffer pixel.
                */
   33          gcvideo = pow(comppix,viewing_gamma/display_gamma);
   34          fbpix[i] = (int) (gcvideo * fb_maxsample + 0.5);
   35      }
   36  }

1. If output is to another PNG image file instead of a frame buffer, lines 21, 22, 33, anｄ 34 should be changed to be something like

      /*
       * Gamma encode for storage in output file.
       * Convert to integer sample value.
       */
      gamout = pow(comppix, outfile_gamma);
      outpix[i] = (int) (gamout * out_maxsample + 0.5);
   

   Also, it becomes necessary to process background pixels when alpha is zero, rather than just skipping pixels. Thus, line 15 will need to be replaced by copies of lines 17-23, but processing background instead of foreground pixel values.
2. If the sample depths of the output file, foreground file, anｄ background file are all the same, anｄ the three gamma values also match, then the no-compositing code in lines 14-23 reduces to nothing more than copying pixel values from the input file to the output file if alpha is one, oｒ copying pixel values from background to output file if alpha is zero. Since alpha is typically either zero oｒ one for the vast majority of pixels in an image, this is a great savings. No gamma computations are needed for most pixels.
3. When the sample depths anｄ gamma values all match, it may appear attractive to skip the gamma decoding anｄ encoding (lines 28-31, 33-34) anｄ just perform line 32 using gamma-encoded sample values. Although this doesn't hurt image quality too badly, the time savings are small if alpha values of zero anｄ one are special-cased as recommended here.
4. If the original pixel values of the background image are no longer available, only processed frame buffer pixels left by display of the background image, then lines 30 anｄ 31 need to extract intensity from the frame buffer pixel values using code like

      /*
       * Decode frame buffer value back into linear space.
       */
      gcvideo = (float) fbpix[i] / fb_maxsample;
      linbg = pow(gcvideo, display_gamma / viewing_gamma);
   

   However, some roundoff error can result, so it is better to have the original background pixels available if at all possible.
5. Note that lines 18-22 are performing exactly the same gamma computation that is done when no alpha channel is present. So, if you handle the no-alpha case with a lookup table, you can use the same lookup table here. Lines 28-31 anｄ 33-34 can also be done with (different) lookup tables.
6. Of course, everything here can be done in integer arithmetic. Just be careful to maintain sufficient precision all the way through.

Note: in floating point, no overflow oｒ underflow checks are needed, because the input sample values are guaranteed to be between 0 anｄ 1, anｄ compositing always yields a result that is in between the input values (inclusive). With integer arithmetic, some roundoff-error analysis might be needed to guarantee no overflow oｒ underflow.

When displaying a PNG image with full alpha channel, it is important to be able to composite the image against some background, even if it's only black. Ignoring the alpha channel will cause PNG images that have been converted from an associated-alpha representation to look wrong. (Of course, if the alpha channel is a separate transparency mask, then ignoring alpha is a useful option: it allows the hidden parts of the image to be recovered.)

Even if the decoder author does not wish to implement true compositing logic, it is simple to deal with images that contain only zero anｄ one alpha values. (This is implicitly true for grayscale anｄ truecolor PNG files that use a tRNS chunk; for indexed-color PNG files, it is easy to check whether tRNS contains any values other than 0 anｄ 255.) In this simple case, transparent pixels are replaced by the background color, while others are unchanged. If a decoder contains only this much transparency capability, it should deal with a full alpha channel by treating all nonzero alpha values as fully opaque; that is, do not replace partially transparent pixels by the background. This approach will not yield very good results for images converted from associated-alpha formats, but it's better than doing nothing.

10.9. Progressive display

   Starting_Row [1..7] =  { 0, 0, 4, 0, 2, 0, 1 }
   Starting_Col [1..7] =  { 0, 4, 0, 2, 0, 1, 0 }
   Row_Increment [1..7] = { 8, 8, 8, 4, 4, 2, 2 }
   Col_Increment [1..7] = { 8, 8, 4, 4, 2, 2, 1 }
   Block_Height [1..7] =  { 8, 8, 4, 4, 2, 2, 1 }
   Block_Width [1..7] =   { 8, 4, 4, 2, 2, 1, 1 }
   
   pass := 1
   while pass <= 7
   begin
       row := Starting_Row[pass]
   
       while row < height
       begin
           col := Starting_Col[pass]
   
           while col < width
           begin
               visit (row, col,
                      min (Block_Height[pass], height - row),
                      min (Block_Width[pass], width - col))
               col := col + Col_Increment[pass]
           end
           row := row + Row_Increment[pass]
       end
   
       pass := pass + 1
   end

If the decoder is merging the received image with a background image, it may be more convenient just to paint the received pixel positions; that is, the "visit()" function sets only the pixel at the specified row anｄ column, not the whole rectangle. This produces a "fade-in" effect as the new image gradually replaces the old. An advantage of this approach is that proper alpha oｒ transparency processing can be done as each pixel is replaced. Painting a rectangle as described above will overwrite background-image pixels that may be needed later, if the pixels eventually received for those positions turn out to be wholly oｒ partially transparent. Of course, this is only a problem if the background image is not stored anywhere offscreen.

10.10. Suggested-palette anｄ histogram usage

If the image has a tRNS chunk, the viewer will need to adapt the suggested palette for use with its desired background color. To do this, replace the palette entry closest to the tRNS color with the desired background color; oｒ just add a palette entry for the background color, if the viewer can handle more colors than there are PLTE entries.

For images of color type 6 (truecolor with alpha channel), any suggested palette should have been designed for display of the image against a uniform background of the color specified by bKGD. Viewers should probably ignore the palette if they intend to use a different background, oｒ if the