| Current File : /home/mmdealscpanel/yummmdeals.com/alt-php84-pecl-imagick_3.8.0-7.el8.zip |
PK q9�Z!���! �! util/functions.phpnu �[��� <?php
// Mirrored from https://github.com/Danack/HexFloat
require_once __DIR__ . "/FloatInfo.php";
require_once __DIR__ . "/Float32Info.php";
use HexFloat\FloatInfo;
use HexFloat\Float32Info;
/**
* Returns a string containing a hexadecimal representation of the given float,
* using 64 bits of info
*
* @param float $number
* @return string
*/
function floathex(float $number)
{
return strrev(unpack('h*', pack('d', $number))[1]);
}
/**
* Returns a string containing a hexadecimal representation of the given float,
* using 32 bits of info
*
* @param float $number
* @return string
*/
function floathex32(float $num)
{
return strrev(unpack('h*', pack('f', $num))[1]);
}
/**
* Convert a floating point number to a FloatInfo object,
* which contains string representations of the float's sign,
* exponent and mantissa
* @param float $num
* @return FloatInfo
*/
function float_info(float $num)
{
$float64 = floathex($num);
//Sign bit: 1 bit
//Exponent: 11 bits
//Significand precision: 53 bits (52 explicitly stored)
$chars = str_split($float64);
// 3 bits from this
$byte1 = hexdec($chars[0]);
// 4 bits from this
$byte2 = hexdec($chars[1]);
// 1 bit from this
$byte3 = hexdec($chars[2]);
$sign = '0';
if ($byte1 >= 8) {
$sign = '1';
}
$exponentString = substr($float64, 0, 3);
$exponentValue = hexdec($exponentString) & 0x7ff;
$exponent = sprintf("%b", $exponentValue);
$exponent = str_pad($exponent, 11, '0', STR_PAD_LEFT);
$mantissa = substr($float64, 2);
$mantissa = hexdec($mantissa) & 0xfffffffffffff;
$mantissa = sprintf("%b", $mantissa);
$mantissa = str_pad($mantissa, 52, '0', STR_PAD_LEFT);
return new FloatInfo(
$sign,
$exponent,
$mantissa
);
}
/**
* Convert a floating point number to a Float32Info object,
* which contains string representations of the float's sign,
* exponent and mantissa
*
* @param float $num
* @return Float32Info
*/
function float_info_32(float $num)
{
$float32 = floathex32($num);
$chars = str_split($float32);
// 3 bits from this
$byte1 = hexdec($chars[0]);
// 4 bits from this
$byte2 = hexdec($chars[1]);
// 1 bit from this
$byte3 = hexdec($chars[2]);
$sign = '0';
if ($byte1 >= 8) {
$sign = '1';
}
$exponent3Bits = ($byte1 & 0x7);
$exponent4Bits = $byte2;
$exponent1Bit = ($byte3 & 0x8) >> 3;
$exponent = ($exponent3Bits << 5) | ($exponent4Bits << 1) | $exponent1Bit;
$exponent = sprintf("%b", $exponent);
$exponent = str_pad($exponent, 8, '0', STR_PAD_LEFT);
$mantissa = substr($float32, 2, 6);
$mantissa = hexdec($mantissa) & 0x7fffff;
$mantissa = sprintf("%b", $mantissa);
$mantissa = str_pad($mantissa, 23, '0', STR_PAD_LEFT);
return new Float32Info(
$sign,
$exponent,
$mantissa
);
}
/**
* Produce a debug string that shows the Sign, Exponent and Mantissa for
* two floating point numbers, using 64bit precision
*
*
* @param float $value1
* @param float $value2
* @return string
*
* Example result
* ┌──────┬─────────────┬──────────────────────────────────────────────────────┐
* │ Sign │ Exponent │ Mantissa │
* │ 0 │ 01111111011 │ 1001100110011001100110011001100110011001100110011010 │
* │ 0 │ 10000011001 │ 0111110101111000010000000100000000000000000000000000 │
* └──────┴─────────────┴──────────────────────────────────────────────────────┘
*
*/
function float_compare(float $value1, float $value2)
{
$float_info_1 = float_info($value1);
$float_info_2 = float_info($value2);
//Sign bit: 1 bit
//Exponent: 11 bits
//Significand precision: 53 bits (52 explicitly stored)
$output = "┌──────┬─────────────┬──────────────────────────────────────────────────────┐\n";
$output .= "│ Sign │ Exponent │ Mantissa │\n";
$format_string = "│ %s │ %s │ %s │\n";
$output .= sprintf($format_string, $float_info_1->getSign(), $float_info_1->getExponent(), $float_info_1->getMantissa());
$output .= sprintf($format_string, $float_info_2->getSign(), $float_info_2->getExponent(), $float_info_2->getMantissa());
$output .= "└──────┴─────────────┴──────────────────────────────────────────────────────┘\n";
return $output;
}
/**
* Produce a debug string that shows the Sign, Exponent and Mantissa for
* two floating point numbers, using 32bit precision
*
* @param float $value1
* @param float $value2
* @return string
*
* Example result
* ┌──────┬──────────┬─────────────────────────┐
* │ Sign │ Exponent │ Mantissa │
* │ 0 │ 01111011 │ 10011001100110011001101 │
* │ 0 │ 10011001 │ 01111101011110000100000 │
* └──────┴──────────┴─────────────────────────┘
*
*/
function float_compare_32(float $value1, float $value2)
{
$float_info_1 = float_info_32($value1);
$float_info_2 = float_info_32($value2);
$output = "┌──────┬──────────┬─────────────────────────┐\n";
$output .= "│ Sign │ Exponent │ Mantissa │\n";
$format_string = "│ %s │ %s │ %s │\n";
$output .= sprintf($format_string, $float_info_1->getSign(), $float_info_1->getExponent(), $float_info_1->getMantissa());
$output .= sprintf($format_string, $float_info_2->getSign(), $float_info_2->getExponent(), $float_info_2->getMantissa());
$output .= "└──────┴──────────┴─────────────────────────┘\n";
return $output;
}
/**
* So. One of the disadvantages of non-HDRI compiled Image Magick
* is that it can't accurately represent a '50%' color accurately.
*
* For example, if ImageMagick is compiled with 16bit color depth
* then the two closest colors to midpoint are:
* 32767 / 65535 = 0.5 - (1 / (2 ^ 17)) = 0.499992370...
* or
* 32768 / 65535 = 0.5 + (1 / (2 ^ 17)) = 0.50000762951
*
* Either way there is going to be 'error' of
* 0.00000762939453125
*
* The problem is even worse when ImageMagick is compiled with 8-bit
* numbers (though this really shouldn't be used any more) and the
* error would be 0.001953125
*
*/
function get_epsilon_for_off_by_half_errors()
{
// These could be defined better...
$epsilon_values_for_non_hdri = [
'255' => (1 / (pow(2, 8) - 1)) + 0.0000000000001,
'65535' => (1 / (pow(2, 16) - 1)) + 0.0000000000001,
'16777215' => (1 / (pow(2, 24) - 1) ) + 0.0000000000001,
'4294967295' => (1 / (pow(2, 32) - 1)) + 0.0000000000001,
];
// These could definitely be defined better...
$epsilon_values_for_hdri = [
'255' => 0.0000000000001,
'65535' => 0.0000000000001,
'16777215' => 0.0000000000001,
'4294967295' => 0.0000000000001
];
if (Imagick::getHdriEnabled() === false) {
$quantum = (string)Imagick::getQuantum();
if (array_key_exists($quantum, $epsilon_values_for_non_hdri) !== true) {
throw new Exception(
"Quantum values is $quantum which is not any of (2^(8|16|24|32)) - 1. Please report this as a bug."
);
}
return $epsilon_values_for_non_hdri[$quantum];
}
$quantum = Imagick::getQuantum();
if (array_key_exists($quantum, $epsilon_values_for_hdri) !== true) {
throw new Exception(
"Quantum values is $quantum which is not any of (2^(8|16|24|32)) - 1. Please report this as a bug."
);
}
return $epsilon_values_for_hdri[$quantum];
}PK q9�Z&f8� � util/fixup_arginfo.phpnu �[��� <?php
declare(strict_types = 1);
if ($argc !== 2) {
fwrite(STDERR, "usage php fixup_arginfo.php \$arginfo_filename\n");
exit(-1);
}
$filename = $argv[1];
$fixup_note = "file has been fixedup for different versions";
echo "Fixing $filename\n";
$input_lines = file($filename);
foreach ($input_lines as $input_line) {
if (strpos($input_line, $fixup_note) !== false) {
echo "File has already been fixedup.\n";
exit(0);
}
}
$output_lines = [];
$search = [];
$replace = [];
$search[] = "#.*Stub hash: (.*) .*/#iu";
$replace[] = "* Stub hash: regen with 'sh regen_arginfo.sh' \n* $fixup_note */";
$search[] = "#ZEND_ARG_OBJ_INFO\(0, (\w*), IMAGICK_QUANTUM_TYPE, 0\)#iu";
$replace[] = "
#if MAGICKCORE_HDRI_ENABLE
ZEND_ARG_TYPE_INFO(0, $1, IS_DOUBLE, 0)
#else
ZEND_ARG_TYPE_INFO(0, $1, IS_LONG, 0)
#endif
";
// ZEND_ARG_TYPE_INFO(pass_by_ref, name, type_hint, allow_null)
// ZEND_ARG_INFO(pass_by_ref, name)
$search[] = "#ZEND_ARG_TYPE_INFO\((\w*), (\w*), (\w*), (\w*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_ARG_TYPE_INFO($1, $2, $3, $4)
#else
ZEND_ARG_INFO($1, $2)
#endif";
$search[] = "#ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX\((\w*), 0, (\w*), IMAGICK_QUANTUM_TYPE, 0\)#iu";
$replace[] = "
#if MAGICKCORE_HDRI_ENABLE
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX($1, 0, $2, IS_DOUBLE, 0)
#else
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX($1, 0, $2, IS_LONG, 0)
#endif
";
//ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null)
#define ZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args)
$search[] = "#ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX\((\w*), (\w*), (\w*), (\w*), (\w*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX($1, $2, $3, $4, $5)
#else
ZEND_BEGIN_ARG_INFO_EX($1, 0, $2, $3)
#endif
";
//#define ZEND_ARG_TYPE_MASK(pass_by_ref, name, type_mask, default_value) \
$search[] = "#.*ZEND_ARG_TYPE_MASK\(([\w|\|]*), ([\w|\|]*), ([\w|\|]*), ([\w\|\"]*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_ARG_TYPE_MASK($1, $2, $3, $4)
#else
ZEND_ARG_INFO($1, $2)
#endif
";
//ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(name, return_reference, required_num_args, type)
//ZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args)
$search[] = "#.*ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX\(([\w|\|]*), ([\w|\|]*), ([\w|\|]*), ([\w|\|]*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX($1, $2, $3, $4)
#else
ZEND_BEGIN_ARG_INFO_EX($1, 0, $2, $3)
#endif
";
//ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, class_name, allow_null)
$search[] = "#ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX\((\w*), (\w*), (\w*), (\w*), (\w*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX($1, $2, $3, $4, $5)
#else
ZEND_BEGIN_ARG_INFO_EX($1, 0, $2, $3)
#endif
";
//ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) \
$search[] = "#.*ZEND_ARG_OBJ_INFO\((\w*), (\w*), resource, (\w*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
\tZEND_ARG_OBJ_INFO($1, $2, resource, $3)
#else
\tZEND_ARG_INFO($1, $2)
#endif
";
// ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, filename, IS_STRING, 1, "null")
$search[] = "#.*ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE\((\w*), (\w*), (\w*), (\w*), ([\w\"]*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE($1, $2, $3, $4, $5)
#else
ZEND_ARG_INFO($1, $2)
#endif
";
// ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, filename, "null")
$search[] = "#.*ZEND_ARG_INFO_WITH_DEFAULT_VALUE\((\w*), (\w*), ([\w\"]*)\)#iu";
$replace[] = "
#if PHP_VERSION_ID >= 80000
ZEND_ARG_INFO_WITH_DEFAULT_VALUE($1, $2, $3)
#else
ZEND_ARG_INFO($1, $2)
#endif
";
//#if PHP_VERSION_ID >= 80000
//ZEND_ARG_TYPE_MASK(0, files, MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_NULL, NULL)
//#else
// ZEND_ARG_INFO(0, files)
//#endif
foreach ($input_lines as $input_line) {
$input_line = rtrim($input_line);
$input_line = preg_replace($search, $replace, $input_line);
$output_lines[] = $input_line;
}
file_put_contents($filename, implode("\n", $output_lines));
echo "File has now been fixedup.\n";
PK q9�Z�w�� � util/Float32Info.phpnu �[��� <?php
namespace HexFloat;
// Mirrored from https://github.com/Danack/HexFloat
class Float32Info
{
//Sign bit: 1 bit
private $sign;
//Exponent: 11 bits
private $exponent;
//Mantissa precision: 53 bits (52 explicitly stored)
private $mantissa;
public function __construct(
$sign,
$exponent,
$mantissa
) {
// TODO - check lengths
$this->sign = $sign;
$this->exponent = $exponent;
$this->mantissa = $mantissa;
}
public function getSign()
{
return $this->sign;
}
public function getExponent()
{
return $this->exponent;
}
public function getMantissa()
{
return $this->mantissa;
}
}
PK q9�Zq�� � util/FloatInfo.phpnu �[��� <?php
namespace HexFloat;
// Mirrored from https://github.com/Danack/HexFloat
class FloatInfo
{
//Sign bit: 1 bit
private $sign;
//Exponent: 11 bits
private $exponent;
//Mantissa precision: 53 bits (52 explicitly stored)
private $mantissa;
public function __construct(
$sign,
$exponent,
$mantissa
) {
// TODO - check lengths
$this->sign = $sign;
$this->exponent = $exponent;
$this->mantissa = $mantissa;
}
public function getSign()
{
return $this->sign;
}
public function getExponent()
{
return $this->exponent;
}
public function getMantissa()
{
return $this->mantissa;
}
}
PK q9�Z*�� / tests/306_Imagick_interpolativeResizeImage.phptnu �[��� --TEST--
Test Imagick, interpolativeResizeImage
--SKIPIF--
<?php
require_once(dirname(__FILE__) . '/skipif.inc');
checkClassMethods('Imagick', array('interpolativeResizeImage'));
?>
--FILE--
<?php
function interpolativeResizeImage() {
$imagick = new \Imagick(__DIR__ . '/Biter_500.jpg');
$imagick->interpolativeResizeImage(
320,
200,
Imagick::INTERPOLATE_CATROM
);
// $imagick->writeImage(__DIR__ . '/claheImage_output_image.png');
$imagick->getImageBlob();
}
interpolativeResizeImage() ;
echo "Ok";
?>
--EXPECTF--
Ok
PK q9�Zo���c c + tests/159_Imagick_transformImage_basic.phptnu �[��� --TEST--
Test Imagick, transformImage
--SKIPIF--
<?php
$imageMagickRequiredVersion=0x675;
require_once(dirname(__FILE__) . '/skipif.inc');
checkClassMethods('Imagick', array('transformimage'));
?>
--FILE--
<?php
function transformimage() {
$imagick = new \Imagick();
$imagick->newPseudoImage(640, 480, "magick:logo");
$newImage = $imagick->transformImage("400x600", "200x300");
$bytes = $newImage->getImageBlob();
if (strlen($bytes) <= 0) { echo "Failed to generate image.";}
}
transformimage() ;
echo "Ok";
?>
--EXPECTF--
Deprecated: %s Imagick::transformImage() is deprecated in %s
Ok
PK q9�ZRo.
� � '