iPhone "Optimized" PNGs

For the most piece, Apple's designer records for both the Mac and iPhone is fantastic. They are well-written, correct, and offer fantastic value examples. There are, of course, always breaks, especially with modern places. Sometimes these breaks are a issue of source constraints; the variety of records the records squads have to sustain is incredible, and frameworks are consistently being included and current.

At other instances, The apple company is tight-lipped about products not because of source difficulties, but rather purposely, though it's not always clear why. Do you want to know how quick the brand in your iPhone is, or how much storage is available to your application? Both of these are obviously appropriate to creating for the iPhone, but don't look to The apple company for that details. The details is available (processor | memory), just not from The apple company.

Here's another location where The apple company is less than completely forthcoming: When it comes to the iPhone's use of PNG pictures, The apple company claims that Xcode "optimizes" PNGs as piece of the develop procedure and, consequently, you should always use PNG pictures in your iPhone assignments. PNG pictures will usually be more substantial than JPEGs, producing your app to be a little more substantial, but you'll be recognized by some strange kind of development.

Since this details is not reported, what follows is something of an knowledgeable think depending on analysis and findings. I will fortunately be fixed on any errors, so don't think twice to titled ping me if you see something erroneous.

So, just what is this mysterious, secret "optimization"?


During the develop, Xcode generally fasteners up your PNG photograph, transforming it into something that's officially do not a PNG photograph. Xcode doesn't modify your unique pc file, but when it reports it to the Sources file of your app deal, what it does is it byte-swaps the red and pink octets and also "premultiplies the alpha" (if that doesn't add up, don't fear, we'll discuss it in a moment). The PNG options does not service either of these changes, which is why the photograph is do not officially a PNG and can't be packed by most photograph modifying application. Not that it really concerns, since the new edition only prevails within your app deal, but it does mean that any PNG pc file that you contain in your app deal should not be, for example, FTPed or e-mailed from your app immediately, because laptop file will be infected as far as most application is worried.

Byte Swapping


Byte changing is exactly what it appears to be like. Uncompressed pc visual pictures are most-often located as series of three or four bytes or "octets" which signifies each pixel in the photograph. Each byte in the pixel signifies one of the three chemical primaries (red, pink, and green), plus there's often another byte known as "alpha", which we'll look at in a second. There are other tips on how to retail shop pictures, but this is the most typical approach. The most typical byte-ordering used in this approach is RGB (or RGBA) which is for Red-Green-Blue(-Alpha). This implies that 1 pixel is showed in storage by four bytes, the first which signifies the concentration of red, the second which signifies the concentration of eco-friendly, and the third which signifies the concentration of pink (we'll pay no attention to leader for now). The PNG options uses this byte-ordering, as do many other photograph kinds.

However, the iPhone's movie storage uses a non-standard byte-ordering of BGR or Blue-Green-Red (I don't believe there's an leader element in the iPhone's vRAM). As a way to duplicate from an photograph in storage using RGBA to the movie storage using GRB is more computationally costly than just duplication from, for example, BGR to BGR, which can be done with 1, quick storage switch (or "blit") function. By doing this byte-swap in the Copy Information Build Stage, your app is (in some situations) able to neglect the leader element when running laptop file into storage so it can use the quicker storage switch function to get the photograph into movie storage (and hence onto the screen).

Premultiplied Alpha


Okay, that adds up, but what about this "premultiplying the alpha" thing? That one appears to be kind of strange, doesn't it? As described in the earlier location, the iPhone's vRAM has no leader element, so if we're going to pay no attention to that element, we still need to take it into consideration somehow. Keep in mind that PNG Images that have been improved for the iPhone are located as four principles, which signifies the Glowing blue, Green, Red, and Alpha elements (in that order). Although it's known as a "component", Alpha isn't really a coloring element at all. It's more like a modifier that functions on the other three principles, and it signifies how much of whatever is below large will display through. So, a coloring that searched like this:

B:1.0
G:0.0
R:0.0
A:0.5

Would characterize large pink, but at 50% opacity. As a way for laptop to use the leader element, it has to increase the leader instances the other three elements (and perhaps by other values) before placing them into movie storage. This multiplication procedure is more computationally costly than just duplication the value into movie storage. So, Xcode also premultiplies the leader by the three elements and shops the increased value. Because of this, large above would look like this after the Copy Information Build Phase:

B:0.5
G:0.0
R:0.0
A:0.5

Notice that the Glowing blue element in this new pixel is similar to the Glowing blue piece of the earlier edition increased by the leader. Caused by this premultiplication, is that the leader element can be ignored when running the photograph into storage and the photograph can then be blitted immediately to movie storage without having to do the costly floating-point multiplications to evaluate the leader. Well, at least, sometimes. This pixel is what the pixel would look like when utilized over white-colored.

So, what happens if there's a coloring below that needs to exhibit through? This is where elements can get a little complicated. If your app is sketching the photograph on top of something else, or if you're using the leader direct in the photograph as a cover up, then the iPhone can't use this seo. It has to do the leader estimations (which is why the leader direct is eventually left complete in the pre-multiplication process), the the byte-swapping still features some development. For the most piece, you don't have to fear about this - it all happens under the cover. The element you should take away from it though, is that you can help your iPhone know when it is secure to use the seo. The way to do that is to create sure you look at the "opaque" checkbox in Software Designer for your photograph landscapes, or other landscapes that contain pictures, or set the opaque property or home of your UIImageView to YES in value. This informs the iPhone that it's secure to do the quicker blit function and neglect the leader direct because nothing below demonstrates through an opaque subject and there's no need to do any costly sailing factor leader estimations for that subject. Of course, if you are using the leader direct in your photograph, or if you are doing complicated photograph arrangements in your app at run-time, you shouldn't create the perspective opaque. But, if you're just showing an photograph in an UIImageView, examining that opaque checkbox is a really, really excellent option.

An dreadful time, PNG pictures have 1.0 for the Alpha value in every pixel. Because of this, more often than not, application operates quicker and use less storage because of the PNG "optimizations" done by Xcode.

What happens when you use different pc file types

When you use any other pc file variety (or if you fill a non-optimized PNG files), your iPhone has to do the byte-swapping and leader premultiplication at load-time (and perhaps re-do the leader multiplication at present time). Your app generally has to do the same producing that Xcode does, but it's doing it at run-time instead of at build-time. This is going to price you both with regards to brand periods and storage price. One of the factors why Cellular Opera is the greatest storage hog of the built-in iPhone programs is because the pictures it has to fill to be able to present web-pages are all non-optimized pictures, mostly JPEGs. Since JPEG is a pressurized structure, it has the included additional phase of having to relax the photograph into storage before it can do the premultiplication and byte-swapping.

Posted in: