getimagesize - PHP code example

PHP Function GetImageSize()

When you pass getimagesize() a filename, it will return an array with the image size and some extra information. The first two elements (index 0 and 1) contain the width and height of the image. Index 2 contains one of the IMAGETYPE_XXX constants indicating what type of image it is, such as IMAGETYPE_GIF, IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_SWF, IMAGETYPE_PSD, IMAGETYPE_BMP, IMAGETYPE_TIFF_II or IMAGETYPE_TIFF_MM, IMAGETYPE_JPX, IMAGETYPE_JP2, IMAGETYPE_ICO or IMAGETYPE_SWC. The last value (index 3) is a text string with the correct height="yyy" and width="xxx" string that can be used directly in an IMG tag.

If the file type is unknown, or if there is no image inside of it, this function will return a false value for the image size. In some rare cases, this function may also return a warning for not being able to access the stream.

This function uses the GD library to retrieve image information. If you are using PHP older than 5.3, it may not work with certain types of files. For example, if you try to use this function with an ICO file, you will receive a false value because support for this format was only added in PHP version 7.1. You can work around this by passing in the fileinfo extension instead of this function. You can also get extended image information from this function, such as the different JPEG APP markers as an associative array. See the documentation for more details.

getimagesize example

    public function __construct()
    {
    }

    /** * @return array{width: int, height: int, type: int}|null */
    public function extractMetadata(string $filePath): ?array
    {
        $metadata = \getimagesize($filePath);
        if (\is_array($metadata)) {
            return [
                'width' => $metadata[0],
                'height' => $metadata[1],
                'type' => $metadata[2],
            ];
        }

        return null;
    }

  public function isValid() {
    return isset($this->type);
  }

  /** * {@inheritdoc} */
  public function parseFile() {
    $this->logCall('parseFile', func_get_args());
    $data = @getimagesize($this->getSource());
    if ($data && in_array($data[2], static::supportedTypes())) {
      $this->setType($data[2]);
      $this->width = $data[0];
      $this->height = $data[1];
      return TRUE;
    }
    return FALSE;
  }

  /** * {@inheritdoc} */

            if ($file->getError() === UPLOAD_ERR_NO_FILE) {
                return true;
            }

            // Get Parameter sizes             $allowedWidth  = $params[0] ?? 0;
            $allowedHeight = $params[1] ?? 0;

            // Get uploaded image size             $info       = getimagesize($file->getTempName());
            $fileWidth  = $info[0];
            $fileHeight = $info[1];

            if ($fileWidth > $allowedWidth || $fileHeight > $allowedHeight) {
                return false;
            }
        }

        return true;
    }
}

$expected_output = '<img src="/' . $this->siteDirectory . '/files/llama.jpg" data-entity-type="file" data-entity-uuid="' . $uuid . '" />';
    $expected_output .= '<img src="/' . $this->siteDirectory . '/files/llama.jpg" data-entity-type="file" data-entity-uuid="' . $uuid . '" />';
    $output = $test($input);
    $this->assertSame($expected_output, $output->getProcessedText());
    $this->assertEquals($cache_tag, $output->getCacheTags());

    // Add a valid image for image dimension testing.     /** @var array stdClass */
    $files = $this->getTestFiles('image');
    $image = reset($files);
    \Drupal::service('file_system')->copy($image->uri, 'public://llama.jpg', FileSystemInterface::EXISTS_REPLACE);
    [$width, $height] = getimagesize('public://llama.jpg');
    $dimensions = 'width="' . $width . '" height="' . $height . '"';

    // Image dimensions are present.     $input = '<img src="llama.jpg" data-entity-type="file" data-entity-uuid="' . $uuid . '" />';
    $expected_output = '<img src="/' . $this->siteDirectory . '/files/llama.jpg" data-entity-type="file" data-entity-uuid="' . $uuid . '" ' . $dimensions . ' />';
    $output = $test($input);
    $this->assertSame($expected_output, $output->getProcessedText());
    $this->assertEquals($cache_tag, $output->getCacheTags());

    // Image dimensions are set manually.     $input = '<img src="llama.jpg" data-entity-type="file" data-entity-uuid="' . $uuid . '"width="41" height="21" />';

'extension' => $newExtension,
            ], [
                'media_id' => $media->getId(),
            ]);
        }

        $media->setExtension($this->getExtension($file));
        $media->setFileSize(filesize($filePath));
        $media->setCreated(new DateTime());

        if ($media->getType() === Media::TYPE_IMAGE) {
            $imageSize = getimagesize($filePath);

            if ($imageSize) {
                $media->setWidth($imageSize[0]);
                $media->setHeight($imageSize[1]);
            }

            $media->removeThumbnails();

            if ($newFileName) {
                $media->setPath($newFileName);
            }

catch (FileException $e) {
        return FALSE;
      }
    }
    return $success;
  }

  /** * {@inheritdoc} */
  public function parseFile() {
    $data = @getimagesize($this->getSource());
    if ($data && in_array($data[2], static::supportedTypes())) {
      $this->setType($data[2]);
      $this->preLoadInfo = $data;
      return TRUE;
    }
    return FALSE;
  }

  /** * Gets the color set for transparency in GIF images. * * @return string|null * A color string like '#rrggbb', or NULL if not set or not relevant. */

      else {
        return [];
      }
    }
    else {
      // Select one of the images we've already generated for this field.       $image_index = array_rand($images[$extension][$min_resolution][$max_resolution]);
      $file = $images[$extension][$min_resolution][$max_resolution][$image_index];
    }

    [$width, $height] = getimagesize($file->getFileUri());
    $values = [
      'target_id' => $file->id(),
      'alt' => $random->sentences(4),
      'title' => $random->sentences(4),
      'width' => $width,
      'height' => $height,
    ];
    return $values;
  }

  /** * Element validate function for resolution fields. */

'jpe|jpg|jpeg' => ['image/jpeg'],
            'png' => ['image/png'],
            'gif' => ['image/gif'],
        ]);

        if (!$valid) {
            throw new FileTypeNotAllowedException($file->getMimeType() ?? '', $this->getType());
        }

        // additional mime type validation         // we detect the mime type over the `getimagesize` extension         $imageSize = getimagesize($file->getPath() . '/' . $file->getFileName());
        if (!isset($imageSize['mime']) || $imageSize['mime'] !== $file->getMimeType()) {
            throw new FileTypeNotAllowedException($file->getMimeType() ?? '', $this->getType());
        }
    }
}

if ($getid3_temp_tempdir = $getid3_temp->tempdir) {
                    $tempdir = $getid3_temp_tempdir;
                }
                unset($getid3_temp, $getid3_temp_tempdir);
            }
        }
        $GetDataImageSize = false;
        if ($tempfilename = tempnam($tempdir, 'gI3')) {
            if (is_writable($tempfilename) && is_file($tempfilename) && ($tmp = fopen($tempfilename, 'wb'))) {
                fwrite($tmp, $imgData);
                fclose($tmp);
                $GetDataImageSize = @getimagesize($tempfilename, $imageinfo);
                if (($GetDataImageSize === false) || !isset($GetDataImageSize[0]) || !isset($GetDataImageSize[1])) {
                    return false;
                }
                $GetDataImageSize['height'] = $GetDataImageSize[0];
                $GetDataImageSize['width']  = $GetDataImageSize[1];
            }
            unlink($tempfilename);
        }
        return $GetDataImageSize;
    }

/** * Get image properties * * A helper function that gets info about the file * * @return array|bool */
    public function getProperties(bool $return = false)
    {
        $path = $this->getPathname();

        if (! $vals = getimagesize($path)) {
            throw ImageException::forFileNotSupported();
        }

        $types = [
            IMAGETYPE_GIF  => 'gif',
            IMAGETYPE_JPEG => 'jpeg',
            IMAGETYPE_PNG  => 'png',
            IMAGETYPE_WEBP => 'webp',
        ];

        $mime = 'image/' . ($types[$vals[2]] ?? 'jpg');

    try {
        if ( is_callable( 'exif_imagetype' ) ) {
            $imagetype = exif_imagetype( $file );
            $mime      = ( $imagetype ) ? image_type_to_mime_type( $imagetype ) : false;
        } elseif ( function_exists( 'getimagesize' ) ) {
            // Don't silence errors when in debug mode, unless running unit tests.             if ( defined( 'WP_DEBUG' ) && WP_DEBUG
                && ! defined( 'WP_RUN_CORE_TESTS' )
            ) {
                // Not using wp_getimagesize() here to avoid an infinite loop.                 $imagesize = getimagesize( $file );
            } else {
                // phpcs:ignore WordPress.PHP.NoSilencedErrors                 $imagesize = @getimagesize( $file );
            }

            $mime = ( isset( $imagesize['mime'] ) ) ? $imagesize['mime'] : false;
        } else {
            $mime = false;
        }

        if ( false !== $mime ) {

function wp_getimagesize( $filename, array &$image_info = null ) {
    // Don't silence errors when in debug mode, unless running unit tests.     if ( defined( 'WP_DEBUG' ) && WP_DEBUG
        && ! defined( 'WP_RUN_CORE_TESTS' )
    ) {
        if ( 2 === func_num_args() ) {
            $info = getimagesize( $filename, $image_info );
        } else {
            $info = getimagesize( $filename );
        }
    } else {
        /* * Silencing notice and warning is intentional. * * getimagesize() has a tendency to generate errors, such as * "corrupt JPEG data: 7191 extraneous bytes before marker", * even when it's able to provide image size information. * * See https://core.trac.wordpress.org/ticket/42480 */

        if (null === $constraint->minWidth && null === $constraint->maxWidth
            && null === $constraint->minHeight && null === $constraint->maxHeight
            && null === $constraint->minPixels && null === $constraint->maxPixels
            && null === $constraint->minRatio && null === $constraint->maxRatio
            && $constraint->allowSquare && $constraint->allowLandscape && $constraint->allowPortrait
            && !$constraint->detectCorrupted) {
            return;
        }

        $size = @getimagesize($value);

        if (empty($size) || (0 === $size[0]) || (0 === $size[1])) {
            $this->context->buildViolation($constraint->sizeNotDetectedMessage)
                ->setCode(Image::SIZE_NOT_DETECTED_ERROR)
                ->addViolation();

            return;
        }

        $width = $size[0];
        $height = $size[1];

        } else {
            // local file             if(!$template->smarty->security_policy->isTrustedResourceDir($params['file'])) {
                return;
            }
        }
    }

    if (!isset($params['width']) || !isset($params['height'])) {
        // FIXME: (rodneyrehm) getimagesize() loads the complete file off a remote resource, use custom [jpg,png,gif]header reader!         if (!$_image_data = @getimagesize($_image_path)) {
            if (!file_exists($_image_path)) {
                trigger_error("html_image: unable to find '$_image_path'", E_USER_NOTICE);
                return;
            } else if (!is_readable($_image_path)) {
                trigger_error("html_image: unable to read '$_image_path'", E_USER_NOTICE);
                return;
            } else {
                trigger_error("html_image: '$_image_path' is not a valid image file", E_USER_NOTICE);
                return;
            }
        }