Check Image Dimensions Without getimagesize()

In a forthcoming project, it was necessary to check the dimensions of a remote image before deciding to cache it or not. While the PHP native function getimagesize() exists, it has some pitfalls. The biggest being: it relies on allow_url_fopen being enabled. While allow_url_fopen is not inherently dangerous, many web hosts do not have it set to prevent issues caused by inexperienced users (including Weblogs.us). Additionally, getimagesize() will retrieve the entire image—a waste of bandwidth, and time. This guide will cover finding the dimensions of images in the PNG and GIF formats with a word on JPEG and why it makes life difficult.

Download Sources

For either image type, we need to retrieve the remote data. In this guide, the following function, getContent(), will be used for all HTTP transactions. It employs PHP’s CURL wrappers (make sure your PHP environment supports CURL). The user can specify the range of bytes to download, if needed. Note that getContent() returns the raw data from CURL or false if there is a curl error.

function getContent($url, $range = null)
{
$curlOpt = array(
CURLOPT_RETURNTRANSFER => true, // Return web page
CURLOPT_HEADER	 => false, // Don't return headers
CURLOPT_FOLLOWLOCATION => true, // Follow redirects
CURLOPT_ENCODING => '', // Handle all encodings
CURLOPT_USERAGENT => 'image dimension grabber', // Useragent
CURLOPT_AUTOREFERER => true, // Set referer on redirect
CURLOPT_FAILONERROR	 => true, // Fail silently on HTTP error
CURLOPT_CONNECTTIMEOUT => 2, // Timeout on connect
CURLOPT_TIMEOUT => 2, // Timeout on response
CURLOPT_MAXREDIRS => 3, // Stop after x redirects
CURLOPT_SSL_VERIFYHOST => 0 // Don't verify ssl
);
//Conditionally set range, if passed in
if($range !== null)
{
$curlOpt[CURLOPT_RANGE] = $range;
}
//Instantiate a CURL context
$context = curl_init($url);
//Set our options
curl_setopt_array($context, $curlOpt);
//Get our content from CURL
$content = curl_exec($context);
//Get any errors from CURL
$error = curl_error($context);
//Close the CURL context
curl_close($context);
//Deal with CURL errors
if(empty($content))
{
return false;
}
return $content;
}

Image Dimensions in PNG

PNG is the more straight forward of the two formats covered in this guide. All multi byte entities are stored in big endian format, which is more natural for humans to read. Some may refer to this as “Motorola” format as the 68k series is big endian (this comes up more often with GIF documentation as that format was developed in the mid to late 1980s when the Motorola 68k was quite popular).

Byte	00	01	02	03	04	05	06	07	08	09	0A	0B	0C	0D	0E	0F
hex	89	50	4E	47	0D	0A	1A	0A	00	00	00	0D	49	48	44	52

All PNG files start with the 8 byte hex sequence: 0x89504E470D0A1A0A (0x89, ‘P’, ‘N’, ‘G’, 13, 10, 26, 10). After this sequence is the beginning of the first chunk, the IHDR chunk. All PNG chunks begin with a 4 byte field denoting the chunk data length in bytes. In the above example, we know the data field of the chunk will be 13 bytes in length. Next comes the 4 byte chunk identifier. While the value of the chunk length may vary from image to image, the chunk identifier for the IHDR chunk is 0x49484452 (‘I’, ‘H’, ‘D’, ‘R’).

Byte	10	11	12	13	14	15	16	17	18	19	1A	1B	1C
hex	00	00	00	3F	00	00	00	21	08	06	00	00	00

Immediately following the IHDR identifier (beginning on byte 0x10) are 4 bytes of the width and then 4 bytes for the height. The rest of the IHDR data field contains: image bit depth, color type, compression type, filter type, and interlace type; each occupying 1 byte for a total of 5 bytes. From the above data field for the IHDR chunk we see that the width is 0x3F (63 pixels) and the height is 0x21 (33 pixels). We really don’t care about anything past the IHDR, and in fact, past byte 23. Therefore, we only need to grab the first 24 bytes of any PNG image to find its dimensions.

Code

Now that we have a basic understanding of the PNG format’s header we can write code to return the dimensions of a PNG file. We will be using a common interface for both getPNGImageXY() and getGIFImageXY. A data string is passed in, and the function returns an array with the width in the first element and height in the second, or false if anything goes wrong.

function getPNGImageXY($data)
{
//The identity for a PNG is 8Bytes (64bits)long
$ident = unpack('Nupper/Nlower', $data);
//Make sure we get PNG
if($ident['upper'] !== 0x89504E47 || $ident['lower'] !== 0x0D0A1A0A)
{
return false;
}
//Get rid of the first 8 bytes that we processed
$data = substr($data, 8);
//Grab the first chunk tag, should be IHDR
$chunk = unpack('Nlength/Ntype', $data);
//IHDR must come first, if not we return false
if($chunk['type'] === 0x49484452)
{
//Get rid of the 8 bytes we just processed
$data = substr($data, 8);
//Grab our x and y
$info = unpack('NX/NY', $data);
//Return in common format
return array($info['X'], $info['Y']);
}
else
{
return false;
}
}

Based on our knowledge of the PNG header format, we know to check for 0x89504E47 as the first 4 bytes and 0x0D0A1A0A as the next 4 bytes. Should this not be the case the function returns false. Next, it removes the 8 bytes that we just processed and then checks for the IHDR chunk. If it is in the expected location, the width and length are read off of the string and placed into an array.

Note that getPNGImageXY() uses unpack() to return formatted variables from the input string. While this is not completely necessary for dealing with PNG images, it makes dealing with GIF images easier and was used for consistency between the two functions.

Example: Find the Dimensions of the Weblogs.us Logo

In this example, the first 24 bytes of the Weblogs.us logo are retrieved and the image dimensions are extracted from them. Then the dimensions are printed to the screen. This code requires getPNGImageXY() and getContent() to be defined before it (e.g. in the same file as in the code archive).

//Want to retrieve the Weblogs.us logo
$url = 'http://weblogs.us/images/weblogs.us.png';
//Only need the first 24 bytes
$data = getContent($url, '0-24');
//Check to make sure it was actually a PNG
if($temp = getPNGImageXY($data))
{
printf('Image width=%s, height=%s', $temp[0], $temp[1]);
}
else
{
echo "Image was not a PNG.";
}

Image Dimensions in GIF

GIF, while not painful like JPEG, it stores multi byte numbers in little endian format. This means that the number 18 (hex 0x12) is represented as 0x1200 if it is stored as 16bit number. Other than this little quirk, the over 20 year old format is easy to use.

Byte	00	01	02	03	04	05	06	07	08	09
hex	47	49	46	38	39	61	12	00	12	00

All GIF files begin with either ‘GIF89a’ or ‘GIF87a’ (0x474946383961 or 0x474946383761). Immediately following the GIF magic word, are 2 bytes for the width and then 2 bytes for the height. Thus, only the first 10 bytes are needed to get the dimensions of a GIF file. Above is the first 10 bytes from a GIF file. It happens to be of the GIF89a format, has a width of 18 pixels, and a height of 18 pixels.

Code

Now that we know what to expect in a GIF formatted file, we can write code to return the dimensions of a such file. For compatibility’s sake, this function will behave externally the same as getGIFImageXY().

function getGIFImageXY($data)
{
//The identity for a GIF is 6bytes (48Bits)long
$ident = unpack('nupper/nmiddle/nlower', $data);
//Make sure we get GIF 87a or 89a
if($ident['upper'] !== 0x4749 || $ident['middle'] !== 0x4638 ||
($ident['lower'] !== 0x3761 && $ident['lower'] !== 0x3961))
{
return false;
}
//Get rid of the first 6 bytes that we processed
$data = substr($data, 6);
//Grab our x and y, GIF is little endian for width and length
$info = unpack('vX/vY', $data);
//Return in common format
return array($info['X'], $info['Y']);
}

The first thing we need to do is verify the file format by looking for the ‘GIF87a’ or ‘GIF89a’ magic word. This code checks these 6 bytes, 2 bytes at a time, returning false if anything is amiss. Next, it removes the 6 processed bytes and grabs the width and height data.

Note that getGIFImageXY() uses unpack(), with good reason, to return formatted variables from the input string. By using the ‘v’ format flag, the integers returned by unpack() are read correctly as little endian rather than big endian. This saves us grief should the function be used in a big endian environment.

Example: Find the Dimensions of the Google Logo

In this example, the first 10 bytes of the Google logo are retrieved and the image dimensions are extracted from them. Then the dimensions are printed to the screen. Since the getGIFImageXY() and getPNGImageXY() functions have the same external interface, the code is almost exactly the same as that for the Weblogs.us logo dimension finder covered earlier.

//Want to retrieve the Google logo
$url = 'http://www.google.com/intl/en_ALL/images/logo.gif';
//Only need the first 10 bytes
$data = getContent($url, '0-10');
//Check to make sure it was actually a GIF
if($temp = getGIFImageXY($data))
{
printf('Image width=%s, height=%s', $temp[0], $temp[1]);
}
else
{
echo "Image was not a GIF.";
}

A Word (or Three) on JPEG

Finding the dimensions of a JPEG image is no trivial matter. Unlike other formats (e.g. PNG and GIF), JPEG does not store its dimension information in its headers. Instead, the dimension information is located at the beginning of the baseline frame. This is immediately after the 0xFFC0 magic word. Preceding the this in the file is:

• header information
• ASCII comments
• EXIF data
• thumbnail data (a JPEG file embedded within the current file)
• Huffman coding tables for the frame

All of this can easily take over 5KiB, in some cases there is over 1KiB of white space (either actual ASCII spaces or hex zeros). Hence, it is impossible to know how much data must be retrieved to find the image dimensions before opening a particular JPEG file. Thus, this guide does not cover the JPEG format. However, in the comments section for the documentation of getimagesize() there is a function that will try to determine the dimensions.

-John Havlik

[end of transmission, stay tuned]