{"id":670,"date":"2025-05-11T04:27:30","date_gmt":"2025-05-11T02:27:30","guid":{"rendered":"https:\/\/renor.it\/invisible-watermark-in-jpeg-with-php-8\/"},"modified":"2025-12-20T15:53:53","modified_gmt":"2025-12-20T14:53:53","slug":"invisible-watermark-in-jpeg-with-php-8","status":"publish","type":"post","link":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/","title":{"rendered":"Invisible Watermark in JPEG with PHP 8"},"content":{"rendered":"

Protect your images by modifying the coefficients, without damaging them<\/h2>\n

Publishing photographs online has become essential for photographers, e-commerce sites, and bloggers, but according to the latest studies on image theft, over 70% of visual content is reshared without credit or authorization. A visible watermark certainly protects the author, but to make it truly effective against intellectual property theft, it often ruins the aesthetic of the shot with an unsightly \u201cpatch\u201d! <\/p>\n

In contrast, an \u201cinvisible\u201d watermark embedded in the coefficients of the Discrete Cosine Transform (DCT), on which the JPEG format is based, preserves perceived quality and can withstand resizing or light compression.<\/p>\n

By encoding the information in the sign<\/strong> of specific low-frequency coefficients, it is possible to ensure an effective compromise between invisibility and robustness.<\/p>\n

In this open-source project, available in my GitHub repository: https:\/\/github.com\/thesimon82\/php-dct-invisible-watermark<\/a>, written in PHP 8.3 and based on GD\/Imagick for pixel manipulation, we will demonstrate step by step how to embed a textual signature into the low-frequency (AC) coefficients of each 8\u00d78 block, how to retrieve its fingerprint, and why using the coefficient\u2019s sign<\/strong> represents a robust strategy against common JPEG compressions, even at 80% quality or lower.<\/p>\n

The goal is not purely educational: the resulting microservice can be cloned from the repository and integrated, via CLI or API, into any image publishing workflow.<\/p>\n

Technical foundations<\/h2>\n

Before writing a single line of code, it is worth clarifying how the JPEG compression algorithm processes the images it needs to compress.<\/p>\n

The JPEG format divides the image into a grid of 8\u00d78 pixel blocks; each block is transformed using the Discrete Cosine Transform (DCT), which decomposes the visual information into 64 coefficients ordered from the lowest frequency (the top-left corner, representing the average intensity) to the highest frequency (the finest details).<\/p>\n

The mid-to-low frequency coefficients are the ideal spot for our watermark: altering the zero-frequency (DC) coefficient would produce visible halos, while modifying only the highest frequencies would lead to their removal during the very first JPEG compression.<\/p>\n

By instead acting on intermediate coefficients, we can encode individual bits by modifying the sign of the coefficient<\/strong> (positive = 0, negative = 1), thus obtaining a marker that is invisible to the eye but robust enough to survive resizing and JPEG compressions down to 80% quality.<\/p>\n

This mathematical principle will guide the entire implementation.<\/p>\n

We will read each 8\u00d78 block, compute the DCT using a native PHP function, modify the sign<\/strong> of one or more selected coefficients, and save the new JPEG using GD or Imagick.<\/p>\n

In other words, the watermark will be hidden precisely in the coefficients that the JPEG compression algorithm tends to preserve: it will be invisible to the eye but difficult to remove, even in the presence of light recompressions.<\/p>\n

The mathematics that makes the watermark invisible<\/h2>\n

Each \"8×8\" block of intensities \"f_{x,y}\" (where\" x,y \in \{0,\dots,7\}\") is converted into 64 coefficients \"C_{u,v}\" (with \"u,v \in \{0,\dots,7\}\") using:<\/p>\n

\\[<\/p>\n

C_{u,v}= \\frac{1}{4}\\,\\alpha(u)\\,\\alpha(v)\\!<\/p>\n

\\sum_{x=0}^{7}\\,\\sum_{y=0}^{7}<\/p>\n

f_{x,y}\\;<\/p>\n

\\cos\\!\\Bigl[\\frac{(2x+1)u\\pi}{16}\\Bigr]\\,<\/p>\n

\\cos\\!\\Bigl[\\frac{(2y+1)v\\pi}{16}\\Bigr]<\/p>\n

\\tag{1}<\/p>\n

\\]<\/p>\n<\/p>\n

where<\/p>\n

\\[<\/p>\n

\\alpha(k)=<\/p>\n

\\begin{cases}<\/p>\n

\\dfrac1{\\sqrt{2}}, & k=0,\\\\[6pt]<\/p>\n

1, & k\\ge 1.<\/p>\n

\\end{cases}<\/p>\n

\\]<\/p>\n

\"C_{0,0}\" (the DC coefficient) represents the average luminance of the block. The AC<\/b> coefficients C_{u,v} with \"u, v \neq 0\" describe increasingly fine details as either \"u \"or \"v \"increase. <\/p>\n

Simplified numerical example<\/h3>\n

Let\u2019s suppose a block where all values are 128, a medium gray. Then: <\/p>\n

\"C_{0,0} = 8 \cdot 8 \cdot 128 \cdot \frac{1}{4} \cdot \alpha(0)^2 = 64 \cdot 128 \cdot \frac{1}{4} \cdot \frac{1}{2} = 1024\" while \"C_{u,v} = 0 \quad \text{for }\" \"(u,v) \neq (0,0)\"
because there are no frequency variations.<\/p>\n

The compressed image preserves the lower-frequency coefficients, while the higher ones are aggressively quantized\u2014often down to 0.<\/p>\n

Quantization and selection of safe frequencies<\/h3>\n

Before being saved in JPEG format, the DCT coefficients are divided by a quantization matrix \"Q_{u,v}\", specific to each frequency:<\/p>\n

\\[<\/p>\n

\\tilde{C}{u,v}= \\operatorname{round}\\!\\Bigl(\\frac{C{u,v}}{Q_{u,v}}\\right)\\Big).<\/p>\n

\\tag{2}<\/p>\n

\\]<\/p>\n

The higher the value of \"Q_{u,v}\", the greater the loss of precision, with the possibility that the coefficients will be reduced to zero.
For this reason, in our algorithm we operate on a low-frequency subset of the AC coefficients, in positions where quantization is moderate and the values are more likely to survive compression.
We also avoid coefficients that are too low (including DC), as modifying them could introduce visible artifacts.<\/p>\n

Bit encoding in the coefficient<\/h3>\n

To ensure the bit survives JPEG compression, instead of using parity, we enforce the sign of the coefficient based on the bit to be written:<\/p>\n

If the bit is 0, we make the coefficient positive<\/p>\n

\\[<\/p>\n

\\operatorname{embed}(c, b) =<\/p>\n

\\begin{cases}<\/p>\n

+\\text{minAmp} + \\text{boost}, & b = 0 \\\\\\\\<\/p>\n

-\\text{minAmp} – \\text{boost}, & b = 1<\/p>\n

\\end{cases}<\/p>\n

\\tag{3\u2019}<\/p>\n

\\]<\/p>\n

Where:<\/p>\n

\"\text{minAmp}\" ensures a value sufficiently far from zero (typically \u2265\u202f80),
\"\text{boost}\" (e.g., 64) increases the distance from zero to prevent nullification during quantization.<\/p>\n

In this way, even after lossy transformations, the sign remains unchanged and the bit can be recovered during reading.<\/p>\n

If we later wish to read the bit, we simply need to evaluate the sign<\/strong> of the quantized DCT coefficient:<\/p>\n

\\[<\/p>\n

b =<\/p>\n

\\begin{cases}<\/p>\n

0, & \\tilde{C}{u,v} \\ge 0 \\\\\\\\<\/p>\n

1, & \\tilde{C}{u,v} < 0<\/p>\n

\\end{cases}<\/p>\n

\\tag{4\u2019}<\/p>\n

\\]<\/p>\n

In other words, a positive coefficient indicates bit 0, a negative coefficient indicates bit 1.<\/p>\n

This method is more robust because the sign of a coefficient survives many lossy transformations, unlike the least significant bit.<\/p>\n

Reconstruction (Inverse DCT)<\/h3>\n

After modifying the coefficients, we invert the transformation to obtain the watermarked image block: <\/p>\n

\\[<\/p>\n

f_{x,y}= \\frac{1}{4}\\!<\/p>\n

\\sum_{u=0}^{7}\\sum_{v=0}^{7}<\/p>\n

\\alpha(u)\\,\\alpha(v)\\,<\/p>\n

\\tilde{C}_{u,v}\\,<\/p>\n

\\cos\\!\\Bigl[\\frac{(2x+1)u\\pi}{16}\\Bigr]\\,<\/p>\n

\\cos\\!\\Bigl[\\frac{(2y+1)v\\pi}{16}\\Bigr].<\/p>\n

\\tag{5}<\/p>\n

\\]<\/p>\n

The maximum error introduced by a \u00b11 variation on a mid-frequency coefficient is less than 1 quantum in luminance, which is below the human visual perception threshold for real photographs.<\/p>\n

Cyclic redundancy to induce robustness<\/h3>\n

To withstand compression or cropping, we encode the message M by duplicating each bit k times and applying a majority vote during reading. With k = 3: <\/p>\n

\\[<\/p>\n

M = b_1b_2\\dots b_n<\/p>\n

\\;\\longrightarrow\\;<\/p>\n

b_1b_1b_1\\,b_2b_2b_2\\dots b_nb_nb_n<\/p>\n

\\tag{6}<\/p>\n

\\]<\/p>\n

Correct recovery is guaranteed as long as at least two out of three copies survive<\/strong>.<\/p>\n

From formulas to code: the DCT class<\/h2>\n

Now that we have formalized the entire mathematical framework, we can translate equation (1) and its inverse directly into PHP.<\/p>\n

To keep the project in pure PHP, without native extensions or external dependencies, we implement the DCT manually on 8\u00d78 blocks.<\/p>\n

This approach is sufficiently fast for images up to a few megapixels and, most importantly, it is transparent and easy to understand and modify.<\/p>\n

The project is organized with Composer and PSR-4 autoloading, but the Dct class is completely self-contained<\/strong> and does not require any external libraries<\/strong>.<\/p>\n

If in the future you wish to extend the system with matrix analyses (e.g., box counting or distortion metrics), you can integrate MathPHP, but it is not required for the DCT.<\/p>\n

composer.json<\/h3>\n\n\n
\n
{<\/span><\/span>\n    \"<\/span>name<\/span>\"<\/span>:<\/span> \"<\/span>renornad\/php-dct-invisible-watermark<\/span>\"<\/span>,<\/span><\/span>\n    \"<\/span>description<\/span>\"<\/span>:<\/span> \"<\/span>Pure-PHP DCT watermarking library for JPEG images.<\/span>\"<\/span>,<\/span><\/span>\n    \"<\/span>type<\/span>\"<\/span>:<\/span> \"<\/span>project<\/span>\"<\/span>,<\/span><\/span>\n    \"<\/span>license<\/span>\"<\/span>:<\/span> \"<\/span>MIT<\/span>\"<\/span>,<\/span><\/span>\n    \"<\/span>require<\/span>\"<\/span>:<\/span> {<\/span><\/span>\n      \"<\/span>php<\/span>\"<\/span>:<\/span> \"<\/span>>=8.3<\/span>\"<\/span><\/span>\n    },<\/span><\/span>\n    \"<\/span>autoload<\/span>\"<\/span>:<\/span> {<\/span><\/span>\n      \"<\/span>psr-4<\/span>\"<\/span>:<\/span> {<\/span><\/span>\n        \"<\/span>Renor<\/span>\\\\<\/span>Watermark<\/span>\\\\<\/span>\"<\/span>:<\/span> \"<\/span>src\/<\/span>\"<\/span><\/span>\n      }<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span><\/code><\/pre>\n<\/div>\n
After defining our composer.json file, we proceed with the installation. Open the terminal and type the command: <\/p>\n\n
composer install<\/code><\/pre>\n
At this point, Composer will create the composer.lock file and the vendor directory, but it won\u2019t install any packages from Packagist because we are not including any dependencies.<\/p>\n
src\/Dct.php<\/h2>\n
We can now finally write the Dct class. Remember that it is preferable to include comments in the code, following the standard in English: <\/p>\n\n\n
\n
<?php<\/span><\/span>\n\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\nnamespace<\/span> Renor\\Watermark<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * 2-D Discrete Cosine Transform (DCT) and its inverse (IDCT) for 8x8 blocks.<\/span><\/span>\n *\/<\/span><\/span>\nfinal<\/span> class<\/span> Dct<\/span><\/span>\n{<\/span><\/span>\n    private<\/span> const<\/span> N = <\/span>8<\/span>;<\/span><\/span>\n    private<\/span> const<\/span> SQRT_2_INV = <\/span>0.7071067811865476<\/span>; <\/span>\/\/ 1 \/ sqrt(2)<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Performs the forward DCT on an 8x8 block of pixel intensities (0-255).<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> forward<\/span>(<\/span>array<\/span> $block<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        self<\/span>::<\/span>assertBlock<\/span>(<\/span>$block<\/span>);<\/span><\/span>\n        $C<\/span> = [];<\/span><\/span>\n\n        for<\/span> (<\/span>$u<\/span> = <\/span>0<\/span>; <\/span>$u<\/span> < <\/span>self<\/span>::N; ++<\/span>$u<\/span>) {<\/span><\/span>\n            $alphaU<\/span> = (<\/span>$u<\/span> === <\/span>0<\/span>) ? <\/span>self<\/span>::SQRT_2_INV : <\/span>1.0<\/span>;<\/span><\/span>\n            for<\/span> (<\/span>$v<\/span> = <\/span>0<\/span>; <\/span>$v<\/span> < <\/span>self<\/span>::N; ++<\/span>$v<\/span>) {<\/span><\/span>\n                $alphaV<\/span> = (<\/span>$v<\/span> === <\/span>0<\/span>) ? <\/span>self<\/span>::SQRT_2_INV : <\/span>1.0<\/span>;<\/span><\/span>\n                $sum<\/span> = <\/span>0.0<\/span>;<\/span><\/span>\n                for<\/span> (<\/span>$x<\/span> = <\/span>0<\/span>; <\/span>$x<\/span> < <\/span>self<\/span>::N; ++<\/span>$x<\/span>) {<\/span><\/span>\n                    for<\/span> (<\/span>$y<\/span> = <\/span>0<\/span>; <\/span>$y<\/span> < <\/span>self<\/span>::N; ++<\/span>$y<\/span>) {<\/span><\/span>\n                        $cosX<\/span> = <\/span>cos<\/span>((<\/span>2<\/span> * <\/span>$x<\/span> + <\/span>1<\/span>) * <\/span>$u<\/span> * M_PI \/ (<\/span>2<\/span> * <\/span>self<\/span>::N));<\/span><\/span>\n                        $cosY<\/span> = <\/span>cos<\/span>((<\/span>2<\/span> * <\/span>$y<\/span> + <\/span>1<\/span>) * <\/span>$v<\/span> * M_PI \/ (<\/span>2<\/span> * <\/span>self<\/span>::N));<\/span><\/span>\n                        $sum<\/span> += <\/span>$block<\/span>[<\/span>$x<\/span>][<\/span>$y<\/span>] * <\/span>$cosX<\/span> * <\/span>$cosY<\/span>;<\/span><\/span>\n                    }<\/span><\/span>\n                }<\/span><\/span>\n                \/\/ The DCT formula includes a factor of 1\/4<\/span><\/span>\n                $C<\/span>[<\/span>$u<\/span>][<\/span>$v<\/span>] = <\/span>0.25<\/span> * <\/span>$alphaU<\/span> * <\/span>$alphaV<\/span> * <\/span>$sum<\/span>;<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $C<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Performs the inverse DCT on an 8x8 block of coefficients, <\/span><\/span>\n     * returning pixel values in the range [0..255].<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> inverse<\/span>(<\/span>array<\/span> $coeff<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        self<\/span>::<\/span>assertBlock<\/span>(<\/span>$coeff<\/span>);<\/span><\/span>\n        $f<\/span> = [];<\/span><\/span>\n\n        for<\/span> (<\/span>$x<\/span> = <\/span>0<\/span>; <\/span>$x<\/span> < <\/span>self<\/span>::N; ++<\/span>$x<\/span>) {<\/span><\/span>\n            for<\/span> (<\/span>$y<\/span> = <\/span>0<\/span>; <\/span>$y<\/span> < <\/span>self<\/span>::N; ++<\/span>$y<\/span>) {<\/span><\/span>\n                $sum<\/span> = <\/span>0.0<\/span>;<\/span><\/span>\n                for<\/span> (<\/span>$u<\/span> = <\/span>0<\/span>; <\/span>$u<\/span> < <\/span>self<\/span>::N; ++<\/span>$u<\/span>) {<\/span><\/span>\n                    $alphaU<\/span> = (<\/span>$u<\/span> === <\/span>0<\/span>) ? <\/span>self<\/span>::SQRT_2_INV : <\/span>1.0<\/span>;<\/span><\/span>\n                    for<\/span> (<\/span>$v<\/span> = <\/span>0<\/span>; <\/span>$v<\/span> < <\/span>self<\/span>::N; ++<\/span>$v<\/span>) {<\/span><\/span>\n                        $alphaV<\/span> = (<\/span>$v<\/span> === <\/span>0<\/span>) ? <\/span>self<\/span>::SQRT_2_INV : <\/span>1.0<\/span>;<\/span><\/span>\n                        $cosX<\/span> = <\/span>cos<\/span>((<\/span>2<\/span> * <\/span>$x<\/span> + <\/span>1<\/span>) * <\/span>$u<\/span> * M_PI \/ (<\/span>2<\/span> * <\/span>self<\/span>::N));<\/span><\/span>\n                        $cosY<\/span> = <\/span>cos<\/span>((<\/span>2<\/span> * <\/span>$y<\/span> + <\/span>1<\/span>) * <\/span>$v<\/span> * M_PI \/ (<\/span>2<\/span> * <\/span>self<\/span>::N));<\/span><\/span>\n                        $sum<\/span> += <\/span>$alphaU<\/span> * <\/span>$alphaV<\/span> * <\/span>$coeff<\/span>[<\/span>$u<\/span>][<\/span>$v<\/span>] * <\/span>$cosX<\/span> * <\/span>$cosY<\/span>;<\/span><\/span>\n                    }<\/span><\/span>\n                }<\/span><\/span>\n                $pixel<\/span> = (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>0.25<\/span> * <\/span>$sum<\/span>);<\/span><\/span>\n                $f<\/span>[<\/span>$x<\/span>][<\/span>$y<\/span>] = <\/span>max<\/span>(<\/span>0<\/span>, <\/span>min<\/span>(<\/span>255<\/span>, <\/span>$pixel<\/span>));<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $f<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Checks that the array is exactly 8x8.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> static<\/span> function<\/span> assertBlock<\/span>(<\/span>array<\/span> $block<\/span>): <\/span>void<\/span><\/span>\n    {<\/span><\/span>\n        if<\/span> (<\/span>count<\/span>(<\/span>$block<\/span>) !== <\/span>self<\/span>::N) {<\/span><\/span>\n            throw<\/span> new<\/span> \\InvalidArgumentException<\/span>(<\/span>'Block must have 8 rows.'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n        foreach<\/span> (<\/span>$block<\/span> as <\/span>$row<\/span>) {<\/span><\/span>\n            if<\/span> (<\/span>count<\/span>(<\/span>$row<\/span>) !== <\/span>self<\/span>::N) {<\/span><\/span>\n                throw<\/span> new<\/span> \\InvalidArgumentException<\/span>(<\/span>'Each row must have 8 columns.'<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Disallow instantiation.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> function<\/span> __construct<\/span>()<\/span><\/span>\n    {<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre>\n<\/div>\n
This class is the core of the project. It encapsulates the algorithm of the two-dimensional Discrete Cosine Transform applied to 8\u00d78 pixel blocks, the same scheme used by the JPEG standard.
At the start of the forward method, the class checks that the input array contains exactly eight rows and eight columns; otherwise, it throws an exception to prevent a sizing error from propagating silently.  <\/p>\n
Once the shape has been verified, for each pair of frequency indices \"u, v\", it computes the double summation defined by the canonical DCT formula: it takes each luminance value \"f_{x,y}\", multiplies it by two cosine terms \u2014 one as a function of \"u\" and coordinate \"x\", the other as a function of \"v\" and coordinate \"y\" \u2014 and accumulates the result. Once the entire block has been scanned, it applies the normalization factor     \"\tfrac{1}{4} \alpha(u)\alpha(v)\", where \"\alpha(0) = \frac{1}{\sqrt{2}}\" and \"\alpha(k) = \frac{1}{2}\" for \"k \geq 1\", so that the coefficient \"C_{0,0}\" preserves the average luminance, and all the others represent, at the correct scale, the increasingly finer detail components. The method therefore returns an 8\u00d78 matrix of floating-point coefficients: it is on this frequency representation that we will later embed the watermark bits.    <\/p>\n
The inverse path is handled by the inverse method. Here too, before any processing, the class enforces a check on the shape of the block. For each pair of pixel coordinates \"x, y\", it reconstructs the luminance by summing the 64 frequency components, each weighted by the product of cosine terms and the normalization factors \"\alpha(u)\alpha(v)\". The final value is then multiplied by \"\tfrac{1}{4}\", rounded to the nearest integer, and clamped to the 0\u2013255 range, to prevent any numerical errors from pushing the result outside the valid color space.   <\/p>\n
The implementation closely follows the mathematical definition, without relying on FFT or SIMD accelerations, favoring educational clarity over performance. The constructor is private, the class cannot be instantiated, and all methods are static and stateless: in this way, the DCT behaves like a pure function\u2014easily testable and reusable. When, in the following sections, we use it to embed a bit by modifying the sign of a low-frequency coefficient, we can be confident that the forward and inverse transformations are numerically consistent and that the alteration remains confined to the values we intend to manipulate.  <\/p>\n
src\/Watermarker.php<\/h2>\n
The Watermarker class is the director that orchestrates the most delicate phase of the entire project. It receives as input or output a sequence of 8\u00d78 DCT coefficient blocks already computed by the Dct class and, without dealing with the physical reading of the JPEG file, simply manipulates those numbers to hide or retrieve an ASCII text. <\/p>\n\n\n
\n
<?php<\/span><\/span>\n\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\nnamespace<\/span> Renor\\Watermark<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * Watermarker class<\/span><\/span>\n *<\/span><\/span>\n * Embeds\/extracts a short ASCII message (max 10 characters + terminator)<\/span><\/span>\n * into low-frequency DCT coefficients. Instead of relying on the single<\/span><\/span>\n * parity bit \u2013 too fragile after rounding and quantization \u2013 here<\/span><\/span>\n * we encode the information into the **sign** of the coefficient:<\/span><\/span>\n *<\/span><\/span>\n *   bit 0  \u2192 positive coefficient<\/span><\/span>\n *   bit 1  \u2192 negative coefficient<\/span><\/span>\n *<\/span><\/span>\n * The sign is never affected during:<\/span><\/span>\n *   1. IDCT \u2192 integer rounding,<\/span><\/span>\n *   2. division by JPEG quantization tables,<\/span><\/span>\n *   3. further rounding or transformations.<\/span><\/span>\n *\/<\/span><\/span>\nfinal<\/span> class<\/span> Watermarker<\/span><\/span>\n{<\/span><\/span>\n    \/** Low-frequency coordinates (survive even at q\u224890\u2013100). *\/<\/span><\/span>\n    private<\/span> const<\/span> EMBED_COORDS = [<\/span><\/span>\n        [<\/span>0<\/span>, <\/span>1<\/span>], [<\/span>1<\/span>, <\/span>0<\/span>], [<\/span>1<\/span>, <\/span>1<\/span>], [<\/span>0<\/span>, <\/span>2<\/span>],<\/span><\/span>\n        [<\/span>2<\/span>, <\/span>0<\/span>], [<\/span>1<\/span>, <\/span>2<\/span>], [<\/span>2<\/span>, <\/span>1<\/span>], [<\/span>2<\/span>, <\/span>2<\/span>]<\/span><\/span>\n    ];<\/span><\/span>\n\n    \/** Redundancy: each bit is repeated 25 times. *\/<\/span><\/span>\n    private<\/span> const<\/span> REDUNDANCY = <\/span>25<\/span>;<\/span><\/span>\n\n    private<\/span> const<\/span> TERMINATOR = <\/span>\"<\/span>\\0<\/span>\"<\/span>;<\/span><\/span>\n\n    \/* ------------------------------------------------------------------<\/span><\/span>\n       Public API<\/span><\/span>\n    -------------------------------------------------------------------*\/<\/span><\/span>\n\n    public<\/span> static<\/span> function<\/span> embed<\/span>(<\/span>array<\/span> &<\/span>$blocks<\/span>, <\/span>string<\/span> $msg<\/span>): <\/span>void<\/span><\/span>\n    {<\/span><\/span>\n        if<\/span> (<\/span>strlen<\/span>(<\/span>$msg<\/span>) > <\/span>10<\/span>) {<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>'Message too long (max 10).'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n\n        $bits<\/span>   = <\/span>self<\/span>::<\/span>stringToBitStream<\/span>(<\/span>$msg<\/span> .<\/span> self<\/span>::TERMINATOR);<\/span><\/span>\n        $cursor<\/span> = <\/span>0<\/span>;<\/span><\/span>\n\n        foreach<\/span> (<\/span>$blocks<\/span> as <\/span>&<\/span>$block<\/span>) {<\/span><\/span>\n            foreach<\/span> (<\/span>self<\/span>::EMBED_COORDS as [<\/span>$u<\/span>, <\/span>$v<\/span>]) {<\/span><\/span>\n                if<\/span> (<\/span>$cursor<\/span> >= <\/span>count<\/span>(<\/span>$bits<\/span>)) {<\/span><\/span>\n                    return<\/span>;<\/span><\/span>\n                }<\/span><\/span>\n                $bit<\/span>           = <\/span>$bits<\/span>[<\/span>$cursor<\/span>++];<\/span><\/span>\n                $block<\/span>[<\/span>$u<\/span>][<\/span>$v<\/span>] = <\/span>self<\/span>::<\/span>forceSign<\/span>(<\/span>$block<\/span>[<\/span>$u<\/span>][<\/span>$v<\/span>], <\/span>$bit<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n        if<\/span> (<\/span>$cursor<\/span> < <\/span>count<\/span>(<\/span>$bits<\/span>)) {<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>'Image too small for the message.'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    public<\/span> static<\/span> function<\/span> extract<\/span>(<\/span>array<\/span> $blocks<\/span>): <\/span>string<\/span><\/span>\n    {<\/span><\/span>\n        $bits<\/span> = [];<\/span><\/span>\n        foreach<\/span> (<\/span>$blocks<\/span> as <\/span>$block<\/span>) {<\/span><\/span>\n            foreach<\/span> (<\/span>self<\/span>::EMBED_COORDS as [<\/span>$u<\/span>, <\/span>$v<\/span>]) {<\/span><\/span>\n                $bits<\/span>[] = ( (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>$block<\/span>[<\/span>$u<\/span>][<\/span>$v<\/span>]) < <\/span>0<\/span> ) ? <\/span>1<\/span> : <\/span>0<\/span>;<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n\n        $filtered<\/span>   = <\/span>self<\/span>::<\/span>majority<\/span>(<\/span>$bits<\/span>, <\/span>self<\/span>::REDUNDANCY);<\/span><\/span>\n        $byteChunks<\/span> = <\/span>array_chunk<\/span>(<\/span>$filtered<\/span>, <\/span>8<\/span>);<\/span><\/span>\n\n        $out<\/span> = <\/span>''<\/span>;<\/span><\/span>\n        foreach<\/span> (<\/span>$byteChunks<\/span> as <\/span>$chunk<\/span>) {<\/span><\/span>\n            if<\/span> (<\/span>count<\/span>(<\/span>$chunk<\/span>) < <\/span>8<\/span>) <\/span>break<\/span>;<\/span><\/span>\n            $ch<\/span> = <\/span>chr<\/span>(<\/span>self<\/span>::<\/span>bitsToInt<\/span>(<\/span>$chunk<\/span>));<\/span><\/span>\n            if<\/span> (<\/span>$ch<\/span> === <\/span>self<\/span>::TERMINATOR) <\/span>break<\/span>;<\/span><\/span>\n            $out<\/span> .=<\/span> $ch<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $out<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/* ------------------------------------------------------------------<\/span><\/span>\n       Private helpers<\/span><\/span>\n    -------------------------------------------------------------------*\/<\/span><\/span>\n\n    private<\/span> static<\/span> function<\/span> stringToBitStream<\/span>(<\/span>string<\/span> $s<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        $bits<\/span> = [];<\/span><\/span>\n        foreach<\/span> (<\/span>str_split<\/span>(<\/span>$s<\/span>) as <\/span>$c<\/span>) {<\/span><\/span>\n            $byte<\/span> = <\/span>ord<\/span>(<\/span>$c<\/span>);<\/span><\/span>\n            for<\/span> (<\/span>$i<\/span> = <\/span>7<\/span>; <\/span>$i<\/span> >= <\/span>0<\/span>; --<\/span>$i<\/span>) {<\/span><\/span>\n                $bit<\/span> = (<\/span>$byte<\/span> >> <\/span>$i<\/span>) & <\/span>1<\/span>;<\/span><\/span>\n                $bits<\/span> = <\/span>array_merge<\/span>(<\/span>$bits<\/span>, <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>self<\/span>::REDUNDANCY, <\/span>$bit<\/span>));<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $bits<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    private<\/span> static<\/span> function<\/span> majority<\/span>(<\/span>array<\/span> $bits<\/span>, <\/span>int<\/span> $group<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        $out<\/span> = [];<\/span><\/span>\n        foreach<\/span> (<\/span>array_chunk<\/span>(<\/span>$bits<\/span>, <\/span>$group<\/span>) as <\/span>$chunk<\/span>) {<\/span><\/span>\n            $out<\/span>[] = (<\/span>array_sum<\/span>(<\/span>$chunk<\/span>) > <\/span>$group<\/span> \/ <\/span>2<\/span>) ? <\/span>1<\/span> : <\/span>0<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $out<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    private<\/span> static<\/span> function<\/span> bitsToInt<\/span>(<\/span>array<\/span> $bits<\/span>): <\/span>int<\/span><\/span>\n    {<\/span><\/span>\n        return<\/span> array_reduce<\/span>(<\/span>$bits<\/span>, <\/span>fn<\/span>(<\/span>$v<\/span>, <\/span>$b<\/span>) => (<\/span>$v<\/span> << <\/span>1<\/span>) | <\/span>$b<\/span>, <\/span>0<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Forces the sign of the coefficient:<\/span><\/span>\n     *   bit 0 \u2192 positive   (>= +minAmp)<\/span><\/span>\n     *   bit 1 \u2192 negative   (<= -minAmp)<\/span><\/span>\n     * so the quantizer cannot flip it.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> static<\/span> function<\/span> forceSign<\/span>(<\/span><\/span>\n        float<\/span> $coeff<\/span>,<\/span><\/span>\n        int<\/span>   $bit<\/span>,<\/span><\/span>\n        int<\/span>   $minAmp<\/span> = <\/span>80<\/span>,   <\/span>\/\/ safe amplitude > luminance quantization divisors<\/span><\/span>\n        int<\/span>   $boost<\/span>  = <\/span>64<\/span>    \/\/ further offset to move away from zero<\/span><\/span>\n    ): <\/span>float<\/span> {<\/span><\/span>\n        $rounded<\/span> = (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>$coeff<\/span>);<\/span><\/span>\n\n        \/\/ Enforce minimum amplitude<\/span><\/span>\n        if<\/span> (<\/span>abs<\/span>(<\/span>$rounded<\/span>) < <\/span>$minAmp<\/span>) {<\/span><\/span>\n            $rounded<\/span> = (<\/span>$rounded<\/span> >= <\/span>0<\/span>) ? <\/span>$minAmp<\/span> : -<\/span>$minAmp<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n\n        \/\/ Set the sign according to the bit<\/span><\/span>\n        if<\/span> (<\/span>$bit<\/span> === <\/span>0<\/span> && <\/span>$rounded<\/span> < <\/span>0<\/span>) <\/span>$rounded<\/span> = <\/span>abs<\/span>(<\/span>$rounded<\/span>);<\/span><\/span>\n        if<\/span> (<\/span>$bit<\/span> === <\/span>1<\/span> && <\/span>$rounded<\/span> > <\/span>0<\/span>) <\/span>$rounded<\/span> = -<\/span>$rounded<\/span>;<\/span><\/span>\n\n        \/\/ Push further from zero: +\/-boost (preserving the sign)<\/span><\/span>\n        $rounded<\/span> += (<\/span>$rounded<\/span> > <\/span>0<\/span>) ? <\/span>$boost<\/span> : -<\/span>$boost<\/span>;<\/span><\/span>\n\n        return<\/span> (<\/span>float<\/span>) <\/span>$rounded<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    private<\/span> function<\/span> __construct<\/span>() {}<\/span><\/span>\n}<\/span><\/span><\/code><\/pre>\n<\/div>\n
When the embed method is called, the caller provides the array of DCT blocks and the message to be embedded. The method converts each character into 8 bits, and each bit is replicated 25 times (as specified by the REDUNDANCY constant), so that it can later be read using a majority vote and withstand alterations due to JPEG compression. The resulting redundant bitstream flows block by block and relies on 8 low-frequency<\/strong> coordinates defined in the constant array EMBED_COORDS. These positions were chosen because they do not affect visual perception but tend to survive even moderate JPEG compressions (quality 60\u201380).   <\/p>\n
For each selected coefficient, the private function forceSign() enforces a specific sign: positive to represent 0, negative to represent 1. This approach\u2014more robust than using parity\u2014ensures that the information remains readable even after JPEG quantization.
If the image does not contain enough blocks to represent the entire message, an exception is thrown with an explicit message.  <\/p>\n
The inverse process is handled by the extract method. Here too, the class reads the sign of the same 8 coefficients in each block, reconstructing a long vector of zeros and ones. The bits are then grouped according to the redundancy factor and passed through a majority vote function (majority()), which recovers the original bit. Every group of 8 bits yields one character, until a NUL terminator is encountered, signaling the end of the message. The resulting sequence of characters forms the original message.    <\/p>\n
The helper functions stringToBitStream, bitsToInt, and majority encapsulate binary-level details, keeping the public methods short and readable. Like the Dct class, Watermarker is also stateless and cannot be instantiated: all methods are static. This functional approach facilitates automated testing and use in concurrent environments.
In summary, the Watermarker class concretely implements the mathematical principles described earlier: cyclic redundancy, bit encoding via sign, explicit message termination\u2014all in a compact and robust flow designed to survive the typical transformations of images published online.   <\/p>\n
ImageIO: from the image to DCT blocks and back<\/h2>\n
The ImageIO class is the bridge between the mathematical theory and the actual JPEG file.<\/p>\n\n\n
\n
<?php<\/span><\/span>\n\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\nnamespace<\/span> Renor\\Watermark<\/span>;<\/span><\/span>\n\nuse<\/span> GdImage<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * Class ImageIO<\/span><\/span>\n *<\/span><\/span>\n * - Loads a JPEG image.<\/span><\/span>\n * - Converts RGB to the Y (luminance) channel.<\/span><\/span>\n * - Splits it into 8x8 blocks and applies DCT\/IDCT.<\/span><\/span>\n * - Overwrites the Y channel with the embedded watermark, merging with the original CbCr.<\/span><\/span>\n * - Saves the final image as JPEG with a specified quality.<\/span><\/span>\n *\/<\/span><\/span>\nfinal<\/span> class<\/span> ImageIO<\/span><\/span>\n{<\/span><\/span>\n    private<\/span> const<\/span> BLOCK_SIZE = <\/span>8<\/span>;<\/span><\/span>\n    private<\/span> const<\/span> MIN_WIDTH = <\/span>200<\/span>;<\/span><\/span>\n    private<\/span> const<\/span> MIN_HEIGHT = <\/span>200<\/span>;<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Embed a watermark in a JPEG image and save the result.<\/span><\/span>\n     *<\/span><\/span>\n     * <\/span>@param<\/span> string<\/span> $src      Path to the original JPEG<\/span><\/span>\n     * <\/span>@param<\/span> string<\/span> $dest     Output path for the watermarked image<\/span><\/span>\n     * <\/span>@param<\/span> string<\/span> $message  ASCII watermark (up to 10 chars)<\/span><\/span>\n     * <\/span>@param<\/span> int<\/span>    $quality  JPEG quality in [0..100], default 90<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> embed<\/span>(<\/span><\/span>\n        string<\/span> $src<\/span>,<\/span><\/span>\n        string<\/span> $dest<\/span>,<\/span><\/span>\n        string<\/span> $message<\/span>,<\/span><\/span>\n        int<\/span> $quality<\/span> = <\/span>90<\/span><\/span>\n    ): <\/span>void<\/span> {<\/span><\/span>\n        $im<\/span> = <\/span>self<\/span>::<\/span>loadJpeg<\/span>(<\/span>$src<\/span>);<\/span><\/span>\n        $w<\/span> = <\/span>imagesx<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n        $h<\/span> = <\/span>imagesy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n\n        \/\/ Ensure a minimum image size<\/span><\/span>\n        if<\/span> (<\/span>$w<\/span> < <\/span>self<\/span>::MIN_WIDTH || <\/span>$h<\/span> < <\/span>self<\/span>::MIN_HEIGHT) {<\/span><\/span>\n            imagedestroy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>\"Image must be at least 200x200 for robust embedding.\"<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n\n        \/\/ Convert RGB \u2192 Y<\/span><\/span>\n        $Y<\/span> = <\/span>self<\/span>::<\/span>rgbToY<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n\n        \/\/ Split into 8x8 blocks, apply forward DCT<\/span><\/span>\n        $blocks<\/span> = <\/span>self<\/span>::<\/span>forwardBlocks<\/span>(<\/span>$Y<\/span>, <\/span>$w<\/span>, <\/span>$h<\/span>);<\/span><\/span>\n\n        \/\/ Embed the message into the DCT coefficients<\/span><\/span>\n        Watermarker<\/span>::<\/span>embed<\/span>(<\/span>$blocks<\/span>, <\/span>$message<\/span>);<\/span><\/span>\n\n        \/\/ Reconstruct the Y channel from the inverse DCT<\/span><\/span>\n        $Ywm<\/span> = <\/span>self<\/span>::<\/span>inverseBlocks<\/span>(<\/span>$blocks<\/span>, <\/span>$w<\/span>, <\/span>$h<\/span>);<\/span><\/span>\n\n        \/\/ Merge the modified Y channel and save as JPEG<\/span><\/span>\n        self<\/span>::<\/span>mergeAndSave<\/span>(<\/span>$im<\/span>, <\/span>$Ywm<\/span>, <\/span>$dest<\/span>, <\/span>$quality<\/span>);<\/span><\/span>\n\n        imagedestroy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Extract the watermark from a JPEG image.<\/span><\/span>\n     *<\/span><\/span>\n     * <\/span>@param<\/span> string<\/span> $src Path to the watermarked JPEG<\/span><\/span>\n     * <\/span>@return<\/span> string<\/span>     The recovered ASCII message<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> extract<\/span>(<\/span>string<\/span> $src<\/span>): <\/span>string<\/span><\/span>\n    {<\/span><\/span>\n        $im<\/span> = <\/span>self<\/span>::<\/span>loadJpeg<\/span>(<\/span>$src<\/span>);<\/span><\/span>\n        $w<\/span> = <\/span>imagesx<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n        $h<\/span> = <\/span>imagesy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n\n        if<\/span> (<\/span>$w<\/span> < <\/span>self<\/span>::MIN_WIDTH || <\/span>$h<\/span> < <\/span>self<\/span>::MIN_HEIGHT) {<\/span><\/span>\n            imagedestroy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>\"Image is too small (<200x200). It may not contain a robust watermark.\"<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n\n        \/\/ Convert to Y<\/span><\/span>\n        $Y<\/span> = <\/span>self<\/span>::<\/span>rgbToY<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n\n        \/\/ Apply DCT on 8x8 blocks<\/span><\/span>\n        $blocks<\/span> = <\/span>self<\/span>::<\/span>forwardBlocks<\/span>(<\/span>$Y<\/span>, <\/span>$w<\/span>, <\/span>$h<\/span>);<\/span><\/span>\n\n        \/\/ Extract the message from the DCT blocks<\/span><\/span>\n        $msg<\/span> = <\/span>Watermarker<\/span>::<\/span>extract<\/span>(<\/span>$blocks<\/span>);<\/span><\/span>\n\n        imagedestroy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n        return<\/span> $msg<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/* -------------------------------------------------------------------------<\/span><\/span>\n       INTERNAL METHODS<\/span><\/span>\n    -------------------------------------------------------------------------- *\/<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Loads a JPEG image from disk or throws an exception if invalid.<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> loadJpeg<\/span>(<\/span>string<\/span> $path<\/span>): <\/span>GdImage<\/span><\/span>\n    {<\/span><\/span>\n        if<\/span> (!<\/span>is_file<\/span>(<\/span>$path<\/span>)) {<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>\"File not found: <\/span>$path<\/span>\"<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n        $im<\/span> = @<\/span>imagecreatefromjpeg<\/span>(<\/span>$path<\/span>);<\/span><\/span>\n        if<\/span> (!<\/span>$im<\/span>) {<\/span><\/span>\n            throw<\/span> new<\/span> \\RuntimeException<\/span>(<\/span>\"Invalid JPEG: <\/span>$path<\/span>\"<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n\n        return<\/span> $im<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Converts an RGB image to a 2D Y (luminance) matrix.<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> rgbToY<\/span>(<\/span>GdImage<\/span> $im<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        $w<\/span> = <\/span>imagesx<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n        $h<\/span> = <\/span>imagesy<\/span>(<\/span>$im<\/span>);<\/span><\/span>\n        $Y<\/span> = <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>$h<\/span>, <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>$w<\/span>, <\/span>0<\/span>));<\/span><\/span>\n\n        for<\/span> (<\/span>$y<\/span> = <\/span>0<\/span>; <\/span>$y<\/span> < <\/span>$h<\/span>; <\/span>$y<\/span>++) {<\/span><\/span>\n            for<\/span> (<\/span>$x<\/span> = <\/span>0<\/span>; <\/span>$x<\/span> < <\/span>$w<\/span>; <\/span>$x<\/span>++) {<\/span><\/span>\n                $rgb<\/span> = <\/span>imagecolorat<\/span>(<\/span>$im<\/span>, <\/span>$x<\/span>, <\/span>$y<\/span>);<\/span><\/span>\n                $r<\/span> = (<\/span>$rgb<\/span> >> <\/span>16<\/span>) & <\/span>0xFF<\/span>;<\/span><\/span>\n                $g<\/span> = (<\/span>$rgb<\/span> >> <\/span>8<\/span>) & <\/span>0xFF<\/span>;<\/span><\/span>\n                $b<\/span> = <\/span>$rgb<\/span> & <\/span>0xFF<\/span>;<\/span><\/span>\n                \/\/ ITU-R BT.601 luma formula<\/span><\/span>\n                $luma<\/span> = (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>0.299<\/span> * <\/span>$r<\/span> + <\/span>0.587<\/span> * <\/span>$g<\/span> + <\/span>0.114<\/span> * <\/span>$b<\/span>);<\/span><\/span>\n                $Y<\/span>[<\/span>$y<\/span>][<\/span>$x<\/span>] = <\/span>max<\/span>(<\/span>0<\/span>, <\/span>min<\/span>(<\/span>255<\/span>, <\/span>$luma<\/span>));<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n\n        return<\/span> $Y<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Splits the Y matrix into 8x8 blocks and applies forward DCT.<\/span><\/span>\n     *\/<\/span><\/span>\n    public<\/span> static<\/span> function<\/span> forwardBlocks<\/span>(<\/span>array<\/span> $Y<\/span>, <\/span>int<\/span> $w<\/span>, <\/span>int<\/span> $h<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        $blocks<\/span> = [];<\/span><\/span>\n        for<\/span> (<\/span>$by<\/span> = <\/span>0<\/span>; <\/span>$by<\/span> < <\/span>$h<\/span>; <\/span>$by<\/span> += <\/span>self<\/span>::BLOCK_SIZE) {<\/span><\/span>\n            for<\/span> (<\/span>$bx<\/span> = <\/span>0<\/span>; <\/span>$bx<\/span> < <\/span>$w<\/span>; <\/span>$bx<\/span> += <\/span>self<\/span>::BLOCK_SIZE) {<\/span><\/span>\n                $block<\/span> = [];<\/span><\/span>\n                for<\/span> (<\/span>$i<\/span> = <\/span>0<\/span>; <\/span>$i<\/span> < <\/span>self<\/span>::BLOCK_SIZE; <\/span>$i<\/span>++) {<\/span><\/span>\n                    $row<\/span> = [];<\/span><\/span>\n                    $srcY<\/span> = <\/span>min<\/span>(<\/span>$by<\/span> + <\/span>$i<\/span>, <\/span>$h<\/span> - <\/span>1<\/span>);<\/span><\/span>\n                    for<\/span> (<\/span>$j<\/span> = <\/span>0<\/span>; <\/span>$j<\/span> < <\/span>self<\/span>::BLOCK_SIZE; <\/span>$j<\/span>++) {<\/span><\/span>\n                        $srcX<\/span> = <\/span>min<\/span>(<\/span>$bx<\/span> + <\/span>$j<\/span>, <\/span>$w<\/span> - <\/span>1<\/span>);<\/span><\/span>\n                        $row<\/span>[] = <\/span>$Y<\/span>[<\/span>$srcY<\/span>][<\/span>$srcX<\/span>];<\/span><\/span>\n                    }<\/span><\/span>\n                    $block<\/span>[] = <\/span>$row<\/span>;<\/span><\/span>\n                }<\/span><\/span>\n                $blocks<\/span>[] = <\/span>Dct<\/span>::<\/span>forward<\/span>(<\/span>$block<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n        return<\/span> $blocks<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Applies inverse DCT to each 8x8 block and rebuilds the Y matrix.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> static<\/span> function<\/span> inverseBlocks<\/span>(<\/span>array<\/span> $blocks<\/span>, <\/span>int<\/span> $w<\/span>, <\/span>int<\/span> $h<\/span>): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        $Y<\/span> = <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>$h<\/span>, <\/span>array_fill<\/span>(<\/span>0<\/span>, <\/span>$w<\/span>, <\/span>0<\/span>));<\/span><\/span>\n        $idx<\/span> = <\/span>0<\/span>;<\/span><\/span>\n\n        for<\/span> (<\/span>$by<\/span> = <\/span>0<\/span>; <\/span>$by<\/span> < <\/span>$h<\/span>; <\/span>$by<\/span> += <\/span>self<\/span>::BLOCK_SIZE) {<\/span><\/span>\n            for<\/span> (<\/span>$bx<\/span> = <\/span>0<\/span>; <\/span>$bx<\/span> < <\/span>$w<\/span>; <\/span>$bx<\/span> += <\/span>self<\/span>::BLOCK_SIZE) {<\/span><\/span>\n                $coeffBlock<\/span> = <\/span>$blocks<\/span>[<\/span>$idx<\/span>++];<\/span><\/span>\n                $pixBlock<\/span> = <\/span>Dct<\/span>::<\/span>inverse<\/span>(<\/span>$coeffBlock<\/span>);<\/span><\/span>\n\n                for<\/span> (<\/span>$i<\/span> = <\/span>0<\/span>; <\/span>$i<\/span> < <\/span>self<\/span>::BLOCK_SIZE; <\/span>$i<\/span>++) {<\/span><\/span>\n                    $dstY<\/span> = <\/span>$by<\/span> + <\/span>$i<\/span>;<\/span><\/span>\n                    if<\/span> (<\/span>$dstY<\/span> >= <\/span>$h<\/span>) <\/span>break<\/span>;<\/span><\/span>\n                    for<\/span> (<\/span>$j<\/span> = <\/span>0<\/span>; <\/span>$j<\/span> < <\/span>self<\/span>::BLOCK_SIZE; <\/span>$j<\/span>++) {<\/span><\/span>\n                        $dstX<\/span> = <\/span>$bx<\/span> + <\/span>$j<\/span>;<\/span><\/span>\n                        if<\/span> (<\/span>$dstX<\/span> >= <\/span>$w<\/span>) <\/span>break<\/span>;<\/span><\/span>\n                        $Y<\/span>[<\/span>$dstY<\/span>][<\/span>$dstX<\/span>] = <\/span>$pixBlock<\/span>[<\/span>$i<\/span>][<\/span>$j<\/span>];<\/span><\/span>\n                    }<\/span><\/span>\n                }<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n\n        return<\/span> $Y<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Merges the watermarked Y channel with the original CbCr, then saves the final JPEG.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> static<\/span> function<\/span> mergeAndSave<\/span>(<\/span>GdImage<\/span> $orig<\/span>, <\/span>array<\/span> $Ywm<\/span>, <\/span>string<\/span> $dest<\/span>, <\/span>int<\/span> $quality<\/span>): <\/span>void<\/span><\/span>\n    {<\/span><\/span>\n        $w<\/span> = <\/span>imagesx<\/span>(<\/span>$orig<\/span>);<\/span><\/span>\n        $h<\/span> = <\/span>imagesy<\/span>(<\/span>$orig<\/span>);<\/span><\/span>\n\n        \/\/ 1) Overwrite the RGB pixels of the GDImage using the new Y<\/span><\/span>\n        for<\/span> (<\/span>$y<\/span> = <\/span>0<\/span>; <\/span>$y<\/span> < <\/span>$h<\/span>; <\/span>$y<\/span>++) {<\/span><\/span>\n            for<\/span> (<\/span>$x<\/span> = <\/span>0<\/span>; <\/span>$x<\/span> < <\/span>$w<\/span>; <\/span>$x<\/span>++) {<\/span><\/span>\n                $rgb<\/span> = <\/span>imagecolorat<\/span>(<\/span>$orig<\/span>, <\/span>$x<\/span>, <\/span>$y<\/span>);<\/span><\/span>\n                $r<\/span> = (<\/span>$rgb<\/span> >> <\/span>16<\/span>) & <\/span>0xFF<\/span>;<\/span><\/span>\n                $g<\/span> = (<\/span>$rgb<\/span> >> <\/span>8<\/span>) & <\/span>0xFF<\/span>;<\/span><\/span>\n                $b<\/span> = <\/span>$rgb<\/span> & <\/span>0xFF<\/span>;<\/span><\/span>\n\n                $cb<\/span> = -<\/span>0.169<\/span> * <\/span>$r<\/span> - <\/span>0.331<\/span> * <\/span>$g<\/span> + <\/span>0.5<\/span> * <\/span>$b<\/span> + <\/span>128<\/span>;<\/span><\/span>\n                $cr<\/span> = <\/span>0.5<\/span> * <\/span>$r<\/span> - <\/span>0.419<\/span> * <\/span>$g<\/span> - <\/span>0.081<\/span> * <\/span>$b<\/span> + <\/span>128<\/span>;<\/span><\/span>\n\n                $Yval<\/span> = <\/span>$Ywm<\/span>[<\/span>$y<\/span>][<\/span>$x<\/span>];<\/span><\/span>\n\n                $R<\/span> = <\/span>$Yval<\/span> + <\/span>1.402<\/span> * (<\/span>$cr<\/span> - <\/span>128<\/span>);<\/span><\/span>\n                $G<\/span> = <\/span>$Yval<\/span> - <\/span>0.344136<\/span> * (<\/span>$cb<\/span> - <\/span>128<\/span>) - <\/span>0.714136<\/span> * (<\/span>$cr<\/span> - <\/span>128<\/span>);<\/span><\/span>\n                $B<\/span> = <\/span>$Yval<\/span> + <\/span>1.772<\/span> * (<\/span>$cb<\/span> - <\/span>128<\/span>);<\/span><\/span>\n\n                $R<\/span> = <\/span>max<\/span>(<\/span>0<\/span>, <\/span>min<\/span>(<\/span>255<\/span>, (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>$R<\/span>)));<\/span><\/span>\n                $G<\/span> = <\/span>max<\/span>(<\/span>0<\/span>, <\/span>min<\/span>(<\/span>255<\/span>, (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>$G<\/span>)));<\/span><\/span>\n                $B<\/span> = <\/span>max<\/span>(<\/span>0<\/span>, <\/span>min<\/span>(<\/span>255<\/span>, (<\/span>int<\/span>) <\/span>round<\/span>(<\/span>$B<\/span>)));<\/span><\/span>\n\n                $color<\/span> = <\/span>imagecolorallocate<\/span>(<\/span>$orig<\/span>, <\/span>$R<\/span>, <\/span>$G<\/span>, <\/span>$B<\/span>);<\/span><\/span>\n                imagesetpixel<\/span>(<\/span>$orig<\/span>, <\/span>$x<\/span>, <\/span>$y<\/span>, <\/span>$color<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n\n        \/\/ 2) Convert GDImage to a PNG blob in memory (lossless)<\/span><\/span>\n        ob_start<\/span>();<\/span><\/span>\n        imagepng<\/span>(<\/span>$orig<\/span>);<\/span><\/span>\n        $pngData<\/span> = <\/span>ob_get_clean<\/span>();<\/span><\/span>\n\n        \/\/ 3) Create an Imagick object from the PNG blob<\/span><\/span>\n        $imagick<\/span> = <\/span>new<\/span> \\Imagick<\/span>();<\/span><\/span>\n        $imagick<\/span>-><\/span>readImageBlob<\/span>(<\/span>$pngData<\/span>);<\/span><\/span>\n\n        \/\/ 4) Set desired JPEG parameters<\/span><\/span>\n        $imagick<\/span>-><\/span>setOption<\/span>(<\/span>'jpeg:sampling-factor'<\/span>, <\/span>'1x1'<\/span>); <\/span>\/\/ disable chroma subsampling<\/span><\/span>\n        $imagick<\/span>-><\/span>setImageCompressionQuality<\/span>(<\/span>$quality<\/span>);<\/span><\/span>\n        $imagick<\/span>-><\/span>setImageCompression<\/span>(<\/span>\\Imagick<\/span>::COMPRESSION_JPEG);<\/span><\/span>\n        $imagick<\/span>-><\/span>setImageFormat<\/span>(<\/span>'jpeg'<\/span>);<\/span><\/span>\n\n        \/\/ 5) Save the file<\/span><\/span>\n        $imagick<\/span>-><\/span>writeImage<\/span>(<\/span>$dest<\/span>);<\/span><\/span>\n\n        \/\/ 6) Cleanup<\/span><\/span>\n        $imagick<\/span>-><\/span>destroy<\/span>();<\/span><\/span>\n    }<\/span><\/span>\n\n    \/**<\/span><\/span>\n     * Prevents instantiation.<\/span><\/span>\n     *\/<\/span><\/span>\n    private<\/span> function<\/span> __construct<\/span>()<\/span><\/span>\n    {<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre>\n<\/div>\n
When the static embed method is invoked, the code opens the image using the GD extension and extracts the Y (luminance) component\u2014 the only one involved in watermarking\u2014while leaving the chrominance channels Cb and Cr untouched, to ensure the watermark remains invisible to the human eye.
The Y matrix is then divided, row by row, into a grid of 8\u00d78 blocks. Each block is transformed into the frequency domain using Dct::forward, enabling the Watermarker class to embed the message bits by forcing the sign<\/strong> of 8 specifically chosen low-frequency<\/strong> coefficients.  <\/p>\n
Once the embedding is complete, ImageIO converts each block back into pixels using Dct::inverse, reconstructing a new, watermarked Y matrix. At this point, the class recalculates the RGB values by combining the modified luminance with the original chrominance components: for each pixel, it applies the inverse color space formulas according to the ITU-R BT.601 standard, ensuring that the results stay within the 0\u2013255 range. <\/p>\n
The complete bitmap is finally saved as a JPEG at the desired quality, using Imagick to disable chroma subsampling and maximize fidelity. The result is a file that is visually identical to the original but contains, within its DCT coefficients, an invisible yet resilient textual signature. <\/p>\n
The inverse process, handled by the extract method, performs the opposite operation: it reloads the image, isolates the luminance channel, divides it into blocks, computes the DCT of each block, and passes the sequence of coefficients to Watermarker::extract. This method reads the sign<\/strong> of the coefficients, applies majority voting across the repetitions of each bit, and reconstructs the original string up to the NUL termination character. <\/p>\n
All I\/O logic\u2014file opening, color conversion, and JPEG saving\u2014is confined within the ImageIO class, while Dct and Watermarker remain pure mathematical functions. This clear separation of responsibilities promotes code modularity, testability, and easy integration into any image processing pipeline. <\/p>\n
CLI test<\/h2>\n
\/embed.php<\/h3>\n
Embedding a watermark in an image<\/p>\n\n\n
\n
#!\/usr\/bin\/env php<\/span><\/span>\n<?php<\/span><\/span>\n\n\/\/ Set memory limit to 1GB<\/span><\/span>\nini_set<\/span>(<\/span>'memory_limit'<\/span>, <\/span>'1024M'<\/span>);<\/span><\/span>\nrequire<\/span> __DIR__<\/span> .<\/span> '\/vendor\/autoload.php'<\/span>;<\/span><\/span>\n\nuse<\/span> Renor\\Watermark\\<\/span>ImageIO<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * This command-line script embeds a watermark (up to 10 characters)<\/span><\/span>\n * into a JPEG and saves the result. By default, it uses quality=90.<\/span><\/span>\n *<\/span><\/span>\n * Example usage:<\/span><\/span>\n *   php embed.php --src=original.jpg --out=watermarked.jpg --msg=\"HELLO\" --q=95<\/span><\/span>\n *<\/span><\/span>\n * Or simply:<\/span><\/span>\n *   php embed.php --src=original.jpg --out=watermarked.jpg<\/span><\/span>\n *   (defaults to msg=\"DEFAULT\" and quality=90)<\/span><\/span>\n *\/<\/span><\/span>\n\n$options<\/span> = <\/span>getopt<\/span>(<\/span>''<\/span>, [<\/span>'src:'<\/span>, <\/span>'out:'<\/span>, <\/span>'msg::'<\/span>, <\/span>'q::'<\/span>]);<\/span><\/span>\n$src<\/span> = <\/span>$options<\/span>[<\/span>'src'<\/span>] ?? <\/span>null<\/span>;<\/span><\/span>\n$out<\/span> = <\/span>$options<\/span>[<\/span>'out'<\/span>] ?? <\/span>null<\/span>;<\/span><\/span>\n$msg<\/span> = <\/span>$options<\/span>[<\/span>'msg'<\/span>] ?? <\/span>'DEFAULT'<\/span>;<\/span><\/span>\n$q<\/span>   = <\/span>isset<\/span>(<\/span>$options<\/span>[<\/span>'q'<\/span>]) ? (<\/span>int<\/span>) <\/span>$options<\/span>[<\/span>'q'<\/span>] : <\/span>90<\/span>;<\/span><\/span>\n\nif<\/span> (!<\/span>$src<\/span> || !<\/span>$out<\/span>) {<\/span><\/span>\n    fwrite<\/span>(STDERR, <\/span>\"Usage: embed --src=INPUT.jpg --out=OUTPUT.jpg [--msg=STRING] [--q=90]<\/span>\\n<\/span>\"<\/span>);<\/span><\/span>\n    exit<\/span>(<\/span>1<\/span>);<\/span><\/span>\n}<\/span><\/span>\n\ntry<\/span> {<\/span><\/span>\n    ImageIO<\/span>::<\/span>embed<\/span>(<\/span>$src<\/span>, <\/span>$out<\/span>, <\/span>$msg<\/span>, <\/span>$q<\/span>);<\/span><\/span>\n    echo<\/span> \"Watermark <\/span>\\\"<\/span>$msg<\/span>\\\"<\/span> embedded successfully into <\/span>$out<\/span> at quality <\/span>$q<\/span>\\n<\/span>\"<\/span>;<\/span><\/span>\n} <\/span>catch<\/span> (\\<\/span>Exception<\/span> $e<\/span>) {<\/span><\/span>\n    fwrite<\/span>(STDERR, <\/span>\"Error: \"<\/span> .<\/span> $e<\/span>-><\/span>getMessage<\/span>() <\/span>.<\/span> \"<\/span>\\n<\/span>\"<\/span>);<\/span><\/span>\n    exit<\/span>(<\/span>1<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre>\n<\/div>\n
In this CLI script (embed.php), we define the message to embed in the image via the –msg option and call the static method ImageIO::embed() from the ImageIO class. The script accepts the following parameters: <\/p>\n
–q (optional): the JPEG quality for saving (default: 90).<\/p>\n
–src: the path to the source JPEG image (e.g., original.jpg);<\/p>\n
–out: the path to the destination JPEG file that will contain the watermark;<\/p>\n
–msg (optional): the ASCII text to embed (max 10 characters);<\/p>\n\n
php embed.php --src=original.jpg --out=watermarked.jpg --msg=\"RENOR\" --q=95<\/code><\/pre>\n
it will return:<\/p>\n\n
Watermark \"RENOR\" embedded successfully into watermarked.jpg at quality 95<\/code><\/pre>\n
\/extract.php<\/h2>\n
From here, we extract the watermark text contained in the watermarked.jpg image just created by embed.php.<\/p>\n\n\n
\n
#!\/usr\/bin\/env php<\/span><\/span>\n<?php<\/span><\/span>\n\n\/\/ Set memory limit to 1GB<\/span><\/span>\nini_set<\/span>(<\/span>'memory_limit'<\/span>, <\/span>'1024M'<\/span>);<\/span><\/span>\nrequire<\/span> __DIR__<\/span> .<\/span> '\/vendor\/autoload.php'<\/span>;<\/span><\/span>\n\nuse<\/span> Renor\\Watermark\\<\/span>ImageIO<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * This command-line script extracts a watermark from a JPEG.<\/span><\/span>\n *<\/span><\/span>\n * Usage:<\/span><\/span>\n *   php extract.php --src=watermarked.jpg<\/span><\/span>\n *\/<\/span><\/span>\n\n$options<\/span> = <\/span>getopt<\/span>(<\/span>''<\/span>, [<\/span>'src:'<\/span>]);<\/span><\/span>\n$src<\/span> = <\/span>$options<\/span>[<\/span>'src'<\/span>] ?? <\/span>null<\/span>;<\/span><\/span>\n\nif<\/span> (!<\/span>$src<\/span>) {<\/span><\/span>\n    fwrite<\/span>(STDERR, <\/span>\"Usage: extract --src=IMAGE.jpg<\/span>\\n<\/span>\"<\/span>);<\/span><\/span>\n    exit<\/span>(<\/span>1<\/span>);<\/span><\/span>\n}<\/span><\/span>\n\ntry<\/span> {<\/span><\/span>\n    $msg<\/span> = <\/span>ImageIO<\/span>::<\/span>extract<\/span>(<\/span>$src<\/span>);<\/span><\/span>\n    echo<\/span> \"Recovered message: <\/span>\\\"<\/span>$msg<\/span>\\\"\\n<\/span>\"<\/span>;<\/span><\/span>\n} <\/span>catch<\/span> (\\<\/span>Exception<\/span> $e<\/span>) {<\/span><\/span>\n    fwrite<\/span>(STDERR, <\/span>\"Error: \"<\/span> .<\/span> $e<\/span>-><\/span>getMessage<\/span>() <\/span>.<\/span> \"<\/span>\\n<\/span>\"<\/span>);<\/span><\/span>\n    exit<\/span>(<\/span>1<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre>\n<\/div>\n
The extract.php script completes the invisible watermark usage cycle by allowing the extraction of the previously embedded message. It is a simple command-line script which, given a watermarked JPEG file, reads the hidden content by decoding the sign of specific modified DCT coefficients.
The message\u2014robustly recovered even after medium-to-high quality JPEG compressions\u2014is reconstructed using majority voting on the repeated bits.
Just run the command with the –src option to specify the image to analyze, and the script will return the originally embedded string in the terminal.   <\/p>\n
We can run the command:<\/p>\n\n
php extract.php --src=watermarked.jpg  <\/code><\/pre>\n
we’ll get:<\/p>\n\n
Recovered message: \"RENOR\"<\/code><\/pre>\n
It is also worth analyzing photographs:<\/p>\n\n
\"\"<\/figure>\n
On the left, the original image; on the right, the watermarked one.<\/p>\n
We can observe that, as thoroughly described, there are indeed no elements visible to the naked eye that can be traced back to the application of a watermark, which nevertheless remains fully decodable using the extract script. <\/p>\n
Clearly, the project is purely demonstrative, and using it at an enterprise level or in production environments would require further refinement.<\/p>\n\n
[starbox] <\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
Protect your images by modifying the coefficients, without damaging them Publishing photographs online has become essential for photographers, e-commerce sites, and bloggers, but according to the latest studies on image theft, over 70% of visual content is reshared without credit or authorization. A visible watermark certainly protects the author, but to make it truly effective […]<\/p>\n","protected":false},"author":2,"featured_media":920,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_writerflow_disable_suggestions":false,"footnotes":""},"categories":[1977],"tags":[1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1391,1436,1437,1438],"class_list":["post-670","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sviluppo-software-programmazione","tag-copyright-en","tag-dct-en","tag-digital-pgotography","tag-digital-sign","tag-discrete-cosine-transform","tag-gd-en","tag-image-security","tag-images-protection","tag-imagick-en","tag-invisible-metadata","tag-invisible-watermark","tag-jpeg-en","tag-jpeg-compression","tag-open-source-en-2","tag-photography-blog","tag-php-en","tag-php-script","tag-robust-watermarking","tag-steganography"],"acf":[],"yoast_head":"\nInvisible Watermark in JPEG with PHP 8 | RENOR & Partners S.r.l.<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Invisible Watermark in JPEG with PHP 8\" \/>\n<meta property=\"og:description\" content=\"Protect your images by modifying the coefficients, without damaging them Publishing photographs online has become essential for photographers, e-commerce sites, and bloggers, but according to the latest studies on image theft, over 70% of visual content is reshared without credit or authorization. A visible watermark certainly protects the author, but to make it truly effective […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/\" \/>\n<meta property=\"og:site_name\" content=\"RENOR & Partners S.r.l.\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/renorsrl\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/simone.renzi.3954\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-05-11T02:27:30+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-12-20T14:53:53+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1536\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Simone Renzi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Simone Renzi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"23 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/\"},\"author\":{\"name\":\"Simone Renzi\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\"},\"headline\":\"Invisible Watermark in JPEG with PHP 8\",\"datePublished\":\"2025-05-11T02:27:30+00:00\",\"dateModified\":\"2025-12-20T14:53:53+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/\"},\"wordCount\":2701,\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/invisible-watermark.webp\",\"keywords\":[\"copyright\",\"dct\",\"digital pgotography\",\"digital sign\",\"discrete cosine transform\",\"gd\",\"image security\",\"images protection\",\"imagick\",\"invisible metadata\",\"invisible watermark\",\"jpeg\",\"jpeg compression\",\"open source\",\"photography blog\",\"php\",\"php script\",\"robust watermarking\",\"steganography\"],\"articleSection\":[\"Sviluppo Software & Programmazione\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/\",\"name\":\"Invisible Watermark in JPEG with PHP 8 | RENOR & Partners S.r.l.\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/invisible-watermark.webp\",\"datePublished\":\"2025-05-11T02:27:30+00:00\",\"dateModified\":\"2025-12-20T14:53:53+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#primaryimage\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/invisible-watermark.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/invisible-watermark.webp\",\"width\":1536,\"height\":1024,\"caption\":\"Esempio grafico del progetto open-source per inserire watermark invisibili all\u2019interno dei coefficienti DCT di immagini JPEG, utilizzando PHP e una libreria personalizzata senza dipendenze esterne.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/invisible-watermark-in-jpeg-with-php-8\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Blog\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Software Development & Programming\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/software-development-programming\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Invisible Watermark in JPEG with PHP 8\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"name\":\"RENOR & Partners S.r.l.\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"alternateName\":\"RENOR & Partners S.r.l.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/renor.it\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\",\"name\":\"RENOR & Partners S.r.l.\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"width\":432,\"height\":146,\"caption\":\"RENOR & Partners S.r.l.\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/renorsrl\",\"https:\\\/\\\/www.instagram.com\\\/renorpartners\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/renor-partners\\\/posts\\\/?feedView=all\"],\"description\":\"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.\",\"email\":\"info@renor.it\",\"telephone\":\"3791489430\",\"legalName\":\"RENOR AND PARTNERS S.r.l.\",\"foundingDate\":\"2022-06-21\",\"vatID\":\"16768411007\",\"taxID\":\"16768411007\",\"numberOfEmployees\":{\"@type\":\"QuantitativeValue\",\"minValue\":\"1\",\"maxValue\":\"10\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\",\"name\":\"Simone Renzi\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"caption\":\"Simone Renzi\"},\"description\":\"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.\",\"sameAs\":[\"https:\\\/\\\/renor.it\",\"https:\\\/\\\/www.facebook.com\\\/simone.renzi.3954\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/simone-renzi\"],\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/author\\\/thesimon\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Invisible Watermark in JPEG with PHP 8 | RENOR & Partners S.r.l.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/","og_locale":"en_US","og_type":"article","og_title":"Invisible Watermark in JPEG with PHP 8","og_description":"Protect your images by modifying the coefficients, without damaging them Publishing photographs online has become essential for photographers, e-commerce sites, and bloggers, but according to the latest studies on image theft, over 70% of visual content is reshared without credit or authorization. A visible watermark certainly protects the author, but to make it truly effective […]","og_url":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/","og_site_name":"RENOR & Partners S.r.l.","article_publisher":"https:\/\/www.facebook.com\/renorsrl","article_author":"https:\/\/www.facebook.com\/simone.renzi.3954\/","article_published_time":"2025-05-11T02:27:30+00:00","article_modified_time":"2025-12-20T14:53:53+00:00","og_image":[{"width":1536,"height":1024,"url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp","type":"image\/webp"}],"author":"Simone Renzi","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Simone Renzi","Est. reading time":"23 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#article","isPartOf":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/"},"author":{"name":"Simone Renzi","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795"},"headline":"Invisible Watermark in JPEG with PHP 8","datePublished":"2025-05-11T02:27:30+00:00","dateModified":"2025-12-20T14:53:53+00:00","mainEntityOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/"},"wordCount":2701,"publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp","keywords":["copyright","dct","digital pgotography","digital sign","discrete cosine transform","gd","image security","images protection","imagick","invisible metadata","invisible watermark","jpeg","jpeg compression","open source","photography blog","php","php script","robust watermarking","steganography"],"articleSection":["Sviluppo Software & Programmazione"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/","url":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/","name":"Invisible Watermark in JPEG with PHP 8 | RENOR & Partners S.r.l.","isPartOf":{"@id":"https:\/\/renor.it\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#primaryimage"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp","datePublished":"2025-05-11T02:27:30+00:00","dateModified":"2025-12-20T14:53:53+00:00","breadcrumb":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#primaryimage","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/invisible-watermark.webp","width":1536,"height":1024,"caption":"Esempio grafico del progetto open-source per inserire watermark invisibili all\u2019interno dei coefficienti DCT di immagini JPEG, utilizzando PHP e una libreria personalizzata senza dipendenze esterne."},{"@type":"BreadcrumbList","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/invisible-watermark-in-jpeg-with-php-8\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/renor.it\/en\/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https:\/\/renor.it\/en\/blog\/"},{"@type":"ListItem","position":3,"name":"Software Development & Programming","item":"https:\/\/renor.it\/en\/blog\/software-development-programming\/"},{"@type":"ListItem","position":4,"name":"Invisible Watermark in JPEG with PHP 8"}]},{"@type":"WebSite","@id":"https:\/\/renor.it\/en\/#website","url":"https:\/\/renor.it\/en\/","name":"RENOR & Partners S.r.l.","description":"","publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"alternateName":"RENOR & Partners S.r.l.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/renor.it\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/renor.it\/en\/#organization","name":"RENOR & Partners S.r.l.","url":"https:\/\/renor.it\/en\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","width":432,"height":146,"caption":"RENOR & Partners S.r.l."},"image":{"@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/renorsrl","https:\/\/www.instagram.com\/renorpartners\/","https:\/\/www.linkedin.com\/company\/renor-partners\/posts\/?feedView=all"],"description":"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.","email":"info@renor.it","telephone":"3791489430","legalName":"RENOR AND PARTNERS S.r.l.","foundingDate":"2022-06-21","vatID":"16768411007","taxID":"16768411007","numberOfEmployees":{"@type":"QuantitativeValue","minValue":"1","maxValue":"10"}},{"@type":"Person","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795","name":"Simone Renzi","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","caption":"Simone Renzi"},"description":"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.","sameAs":["https:\/\/renor.it","https:\/\/www.facebook.com\/simone.renzi.3954\/","https:\/\/www.linkedin.com\/in\/simone-renzi"],"url":"https:\/\/renor.it\/en\/author\/thesimon\/"}]}},"_links":{"self":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/670","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/comments?post=670"}],"version-history":[{"count":0,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/670\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media\/920"}],"wp:attachment":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media?parent=670"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/categories?post=670"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/tags?post=670"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}