Can I create an image with a specific size in bytes?

Solution 1:

As suggested in the comments, you can use the image metadata. jpg supports exif data. You mentioned php, which can write raw exif data with iptcembed(). Generate a string of null bytes (binary 0) long enough to pad out the file

<?php
$path = '/path/to/image.jpg';
$size = filesize($path);
$goal = 1024 * 1024 * 5; //5MB
$zeros = str_pad("", $goal - $size, "\0"); // make a string of ($goal - $size) binary 0s
$paddedImage = iptcembed($zeros, $path);
file_put_contents("/path/to/padded-image.jpg", $paddedImage);

Solution 2:

Most implementations of image formats ignore trailing zeros. Therefore, it is relatively straightforward to pad a file to a desired size. (5 megabytes is 10240 blocks.)

#! /usr/bin/env bash

print_usage_and_exit(){
  echo "Usage: $0 FILE BLOCKS"
  echo "This script will pad FILE with zeros up to BLOCKS."
  echo "FILE must not already be larger than BLOCKS."
  exit
}
FILE=$1
BLOCKS=$2
if [ -z $FILE ] || [ -z $BLOCKS ] || [ -z "${BLOCKS##*[!0-9]*}" ]; then
  print_usage_and_exit
fi
FILE_SIZE=$(stat $FILE | awk '/Blocks:/ { print $4 }')
SIZE_DIFFERENCE=$(($BLOCKS-$FILE_SIZE))
if [ $SIZE_DIFFERENCE -le 0 ]; then
  print_usage_and_exit
fi
dd if=/dev/zero iflag=append count=$SIZE_DIFFERENCE >> $FILE 2>/dev/null

Solution 3:

Few other answers calculate how many trailing zeros you need to append, then they append. In Linux there's this simple way:

truncate -s 5MB image

(this assumes you want 5 MB, i.e. 5*1000*1000 bytes. For 5 MiB, i.e. 5*1024*1024 bytes, use -s 5M).

If originally image is larger than the specified size, then the extra data will be lost. If originally image is smaller, then padding zeros will be added. Added fragment will be sparse, if possible.

If for any reason you don't want sparseness, use fallocate:

fallocate -l 5MB image

(similarly, yet not identically: -l 5MB for 5 MB, -l 5MiB for 5 MiB).

fallocate used this way can only extend image. If the file is already at least that big then it's size won't change (sparseness can change, I won't elaborate).

Solution 4:

if you insist on Windows - I suggest going to CMD , find a suitable small file ...

>copy /B file1+file1 file2 while replacing file1 and file2 with suitable filenames .. you can repeat said copy command by using file2 as source (first 2 names) .. the files will be binary concatenated - so you get a target file of increasing size - until you are satisfied

not as nice as a script - but it works out of the (windows)-box only needs 1 source file .. that doesn't even necessarily has to be an image - as mime-type for uploads mostly is determined by the file-ending

Solution 5:

Does it have to be any specific format? For instance, would a BMP file do?

Uncompressed BMP files are exactly that: completely uncompressed. Thus, each pixel takes up a fixed amount of storage, so it's just a matter of working backwards from the file size you want to the dimensions of the image. So, for an 8-bit BMP, in theory you'd need a 5 megapixel image to get a 5 megabyte file.

Unfortunately, there are a few things that complicate the calculation somewhat:

  1. You're going to have to take the size of the BMP header into account. There are several different versions of the format, each with a different header size, so you'll need to experiment with your image editor to figure out what size header it produces.

  2. Each line of the image is padded to be a multiple of four bytes, so there might be a few extra bytes per line.

  3. BMP files can be compressed, indexed, and have color profile information included. These options are rarely used, but they are out there. If your graphics program uses these and you can't turn them off, your size calculation is going to get a lot more complicated (if it's even possible at all).