Parallelizable and Lightweight Reversible Data Hiding Framework for Encryption-Then-Compression Systems

Abstract

Encryption-then-compression (EtC) enables secure image processing while retaining coding efficiency. In grayscale-based EtC pipelines with YCbCr transformation and component serialization, reversible data hiding (RDH) becomes challenging because cross-channel correspondence is disrupted, and block-wise encryption operations (permutation, rotation, and brightness inversion) break embedding synchronization. This paper presents a block-independent and lightweight RDH framework for such component-serialized grayscale EtC systems. The framework combines diagonal pixel absolute difference (DPAD)-based embedding with an encryption-invariant synchronization index (EISI), enabling reliable encrypted-domain extraction and self-synchronization under component serialization and block permutation, without auxiliary side information or any modification to the underlying EtC pipeline. All operations are performed locally at the block level, making the framework naturally parallelizable when needed. Experiments on standard datasets with diverse texture characteristics demonstrate reliable data extraction and perfect reversibility while preserving the structural properties required for secure encryption and lossless-mode compression. These results indicate that the proposed framework is well-suited to practical EtC deployments where lightweight implementation and block-level independence are essential.

1. Introduction

The widespread deployment of digital imaging systems has intensified the demand for secure and efficient image processing across a wide range of electronic platforms. In many practical scenarios, images must be transmitted, stored, or processed by untrusted intermediate systems, making confidentiality a fundamental requirement. At the same time, compression remains indispensable for reducing storage costs and transmission bandwidth. These requirements have motivated the development of encryption-then-compression (EtC) frameworks, in which images are encrypted prior to compression so that privacy is preserved without sacrificing coding efficiency [1,2,3,4,5,6,7].

Compared with traditional compression-then-encryption (CtE) approaches [8,9,10,11,12,13], EtC systems maintain confidentiality throughout the processing pipeline and avoid exposing unencrypted content at intermediate stages. However, conventional compression algorithms optimized for natural images, such as JPEG, JPEG 2000, JPEG XL, and PNG [14,15,16,17], typically perform poorly on encrypted data because encryption destroys spatial correlation. To mitigate this issue, recent EtC pipelines adopt compression-friendly visual encryption strategies (e.g., block-wise scrambling) that preserve certain local statistical properties while ensuring visual confidentiality. In this study, the compression stage is instantiated in lossless mode (PNG, JPEG 2000 lossless, and JPEG XL lossless), consistent with our experimental protocol and the bit-exact reversibility requirement of reversible processing. Accordingly, decompression is pixel-wise identical to the pre-compression image, i.e., $D\left(C\right(\mathbf{I}\left)\right)=\mathbf{I}$, where $C(·)$ and $D(·)$ denote a paired compression and decompression function, respectively, and $\mathbf{I}$ denotes the input image. Robustness under aggressive lossy compression (e.g., low-quality JPEG) is beyond the scope of this paper.

Beyond confidentiality and coding efficiency, many EtC deployments require embedding reversible auxiliary payloads (e.g., provenance/integrity tags, audit metadata, or access-control labels) into protected images while keeping the underlying compression/encryption pipeline unchanged, which motivates reversible data hiding (RDH) and RDH in encrypted images (RDHEIs) [18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44]. Such requirements arise in practical scenarios, including cloud storage/content delivery, lossless medical archiving, and secure forensics/mission workflows.

In particular, state-of-the-art EtC pipelines increasingly employ grayscale-based representations to improve compression efficiency and compatibility with standard codecs [6,7]. These systems first convert RGB images into the YCbCr color space and then serialize the luminance and chrominance components into a single grayscale image prior to encryption, as shown in Figure 1. While this design is effective for compression, it fundamentally disrupts spatial correspondence across color channels. As a result, the original alignment between color components is lost, posing a significant challenge for RDH, which typically relies on spatial or inter-pixel correlations for reliable embedding and extraction [31,32,33].

Figure 1. The grayscale-based encryption-then-compression (EtC) pipeline [6,7]. In this paper, the encrypted grayscale image is compressed by a standard codec in lossless mode to satisfy the bit-exact reversibility requirement of reversible data hiding (RDH).

This challenge is further exacerbated by the block-based visual encryption operations commonly employed in grayscale-based EtC systems, including block permutation, block rotation or reflection, and block-wise brightness inversion [6,7]. These operations effectively destroy the spatial order of image blocks, making it difficult to preserve or recover the correct embedding sequence after encryption. Consequently, many existing RDH schemes for encrypted images either fail under such transformations or require auxiliary information, global synchronization, or restrictive assumptions that limit their applicability in practical EtC pipelines [39,40,41,42,43,44].

From an implementation perspective, an additional difficulty arises from the structural complexity of many RDH/RDHEI schemes. Approaches that rely on global histogram analysis, sequential decoding, or inter-block dependencies inherently limit scalability and complicate deployment on modern electronic platforms [36,37,38]. While lightweight RDH/RDHEI designs have been explored [28,29], they are not tailored to grayscale-based EtC pipelines with YCbCr color space transformation and component serialization, nor do they address the synchronization loss caused by the combined block permutation, rotation/reflection, and brightness inversion used in state-of-the-art grayscale-based EtC systems [6,7]. Therefore, a practical RDH framework for such EtC pipelines should be lightweight, block-independent, and capable of self-synchronization without auxiliary side information.

To address these issues, this paper proposes a block-independent and lightweight RDH framework specifically designed for grayscale-based EtC systems with YCbCr color space transformation and component serialization [6,7]. The framework employs a diagonal pixel absolute differences (DPAD)-based embedding strategy and an encryption-invariant synchronization index (EISI), both of which have been previously introduced in our earlier studies, as fundamental building blocks. By integrating these established techniques into a unified, block-independent framework, the proposed approach enables reliable data embedding and extraction under block permutation, rotation/reflection, and brightness inversion applied to component-serialized grayscale representations, without requiring auxiliary side information.

The main technical aspects of this work can be summarized as follows:

• A RDH framework is developed specifically for grayscale-based EtC pipelines employing YCbCr color space transformation and component serialization, where conventional RDH schemes fail due to the loss of cross-channel correspondence.
• An EISI is employed to recover the embedding order under the block permutation applied to component-serialized grayscale representations, enabling data extraction without auxiliary side information.
• A block-level RDH procedure based on an existing DPAD embedding strategy is employed to ensure compatibility with block permutation, rotation/reflection, and brightness inversion in grayscale-based EtC systems; since all computations are local and constant per block with no inter-block dependencies, the resulting RDH pipeline is lightweight and naturally parallelizable.

Experimental results demonstrate that the proposed scheme achieves reliable data extraction and perfect reversibility while maintaining the statistical characteristics required by the underlying EtC framework [15,16,17,38]. These results confirm that the proposed method provides a practical and effective solution for RDH in modern EtC-based image processing systems with block-level independence.

Paper Organization. The remainder of this paper is organized as follows: Section 2 introduces the grayscale-based EtC pipeline and the limitations of conventional RDH in this setting; Section 3 presents the proposed auxiliary-free, self-synchronizing framework; Section 4 details the embedding and extraction procedures; Section 5 reports experimental results, including security preservation, lossless compression efficiency, capacity, ablation, and complexity/parallel scalability; and Section 6 concludes the paper with limitations and future work.

2. Preparation

2.1. Grayscale-Based EtC System for Efficient Processing

Most existing image compression techniques are optimized for natural (unencrypted) images and therefore perform poorly when applied to noise-like encrypted data. While traditional compression-then-encryption (CtE) systems preserve compression efficiency, they expose unencrypted content during the compression stage and are thus unsuitable for privacy-sensitive applications. In contrast, encryption-then-compression (EtC) systems apply encryption prior to compression, enabling secure image processing without sacrificing coding efficiency.

Among various EtC approaches, the grayscale-based EtC framework [6,7] has attracted considerable attention due to its compatibility with standard image codecs and its block-based processing structure. In this framework, an RGB image is first converted into the YCbCr color space, and the luminance and chrominance components are serialized into a single grayscale representation. The resulting grayscale image is then encrypted using a set of block-based operations. Owing to the local and independent nature of these operations, the framework is well-suited for block-wise processing without introducing inter-block dependencies. Note that the RGB↔YCbCr conversion is an inherent step of the target grayscale-based EtC pipeline [6,7] for codec compatibility, rather than an additional operation introduced by our RDH method.

The overall procedure of the grayscale-based EtC system is summarized as follows. Here, “PRNG” denotes a key-driven pseudo-random number generator (seeded by the secret key) that produces deterministic pseudo-random sequences for the block-wise operations as in [6,7].

• Convert an RGB image $I_{\mathrm{RGB}}$ of size $X\times Y$ into a YCbCr image $I_{\mathrm{YCbCr}}$ consisting of three channels: $I_{\mathrm{Y}}$, $I_{\mathrm{Cb}}$, and $I_{\mathrm{Cr}}$.
• Horizontally concatenate the three channels to generate a grayscale image $I_{\mathrm{g}}$ of size $3X\times Y$ (see Figure 2).
  

  Figure 2. Illustration of grayscale-based image generation [6,7]. The RGB components are converted to YCbCr and concatenated horizontally to form ${\mathbf{I}}_{\mathrm{g}}$ (4:4:4) prior to encryption.
• Divide $I_{\mathrm{g}}$ into non-overlapping blocks of size $B_x\times B_y$.
• Pseudo-randomly permute the block positions using a PRNG.
• Pseudo-randomly rotate and/or flip each block using another PRNG.
• Pseudo-randomly invert the brightness of each block using a third PRNG.
• Obtain the encrypted grayscale image $I_{\mathrm{e}}$ of size $3X\times Y$.

Details of Steps 1, 4, 5, and 6 are described below.

2.1.1. Color Space Transformation

Let the pixel values at the same spatial position in the RGB and YCbCr images be denoted by R, G, B, Y, $C_b$, and $C_r$, respectively. The color space transformation is defined as

$$\begin{array}{cc}\hfill Y& =uint\left(0.299R+0.587G+0.114B\right),\hfill \end{array}$$

(1)

$$\begin{array}{cc}\hfill \hspace{1em}\hspace{1em} C_b& =uint\left(-0.1687R-0.3313G+0.5B+128\right),\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill \hspace{1em}\hspace{1em} C_r& =uint\left(0.5R-0.4187G-0.0813B+128\right),\hfill \end{array}$$

(3)

with the inverse transformation given by

$$\begin{array}{cc}\hfill R& =uint\left(Y+1.402(C_r-128)\right),\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em} G& =uint\left(Y-0.3441(C_b-128)-0.7141(C_r-128)\right),\hfill \end{array}$$

(5)

$$\begin{array}{cc}\hfill B& =uint\left(Y+1.772(C_b-128)\right).\hfill \end{array}$$

(6)

Here, $uint(·)$ denotes rounding followed by clamping to the range $[0,255]$ [14].

2.1.2. Block Permutation

Using a PRNG with key $K_1$, the blocks in $I_{\mathrm{g}}$ are pseudo-randomly permuted as shown in Figure 3. This operation destroys the global spatial structure of the image while preserving intra-block pixel relationships. Specifically, the image is partitioned into non-overlapping blocks and indexed in raster-scan order. A key-driven PRNG seeded by $K_1$ generates a deterministic permutation of the block indices, and the blocks are rearranged accordingly to form the permuted image.

Figure 3. An example of block permutation. (a) Before permutation. (b) After permutation.

2.1.3. Block Rotation/Flipping

Using another PRNG with key $K_2$, each block is pseudo-randomly rotated and/or flipped. As illustrated in Figure 4, this step scrambles local geometric orientation while keeping the set of pixel values within each block unchanged. Specifically, each block is assigned an index, and a key-driven PRNG seeded by $K_2$ generates a deterministic pseudo-random integer $r_i$ for block $B_i$. The value $r_i$ selects one transform from a predefined candidate set consisting of four rotations $\{0^{\circ },{90}^{\circ },{180}^{\circ },{270}^{\circ }\}$ with an optional reflection, and the selected transform is applied independently to each block. This operation assumes square blocks ($B_x=B_y$) as in [6,7].

Figure 4. Block rotation and flipping.

2.1.4. Brightness Inversion

With key $K_3$, the pixel values in each block are inverted, c.f. Figure 5, according to

$$p^{\prime }=\left\{\begin{array}{cc}p,\hfill & r\left(i\right)=0\hfill \\ A-p,\hfill & r\left(i\right)=1\hfill \end{array}\right.,$$

(7)

where p and $p^{\prime }$ denote the original and transformed pixel values, respectively, $r\left(i\right)$ is a random bit for the i-th block, and A is the maximum possible pixel value.

Figure 5. An example of a negative–positive transformation (all pixels are inverted for illustration). (a) Original. (b) Brightness inverted.

2.2. Limitations of Conventional RDH Schemes

RDH can be applied either before or after encryption. In the context of EtC systems, RDH performed prior to encryption is often preferable, c.f., Figure 6, as it avoids the complexity associated with manipulating encrypted data.

Figure 6. The RDH assumed in this paper.

However, conventional RDH schemes encounter substantial difficulties when applied to grayscale-based EtC pipelines:

• Computational Overhead: Methods based on prediction-error expansion or histogram shifting [37,38] typically rely on global histogram analysis or complex predictors, which introduce non-local dependencies.
• Auxiliary Information Dependence: To cope with geometric transformations and brightness inversion, many schemes require additional side information, increasing system complexity and reducing effective payload.
• Color Transformation Sensitivity: The non-bijective nature of RGB-to-YCbCr conversion causes rounding errors that invalidate reversibility assumptions in many existing RDH approaches.

These limitations motivate the development of an RDH framework that is lightweight, block-independent, and robust to the specific distortions introduced by grayscale-based EtC systems. The proposed method addresses these requirements through a block-wise design based on diagonal pixel differences, as detailed in the following section.

3. Proposed Framework

The proposed framework is designed with the following objectives in mind:

• Compatibility: Ensuring seamless integration with grayscale-based EtC pipelines employing YCbCr color space transformation and component serialization, while remaining robust against the three standard block-based encryption operations used in EtC systems [6,7].
• Reliability: Enabling accurate extraction of embedded data and perfect image restoration without relying on image-dependent parameters or auxiliary side information.
• Structural Efficiency: Organizing embedding and extraction operations in a block-independent manner using only low-complexity arithmetic, so that the resulting framework is naturally amenable to parallel execution.

3.1. Support for Color Space Conversion and Component Serialization

In the considered grayscale-based EtC pipeline, an RGB image is first converted into the YCbCr color space, and the luminance and chrominance components are serialized into a single grayscale image prior to encryption. The proposed framework performs data embedding directly on this component-serialized grayscale representation, thereby avoiding interference with the reversibility of the color space transformation.

In particular, data embedding is restricted to the Cb and Cr chrominance components rather than the Y (luminance) component. Since the Y channel typically exhibits higher sensitivity to pixel modification, avoiding it helps reduce visual distortion and mitigates overflow/underflow risks in reversible processing.

As conceptually illustrated in Figure 7, after YCbCr component serialization, the subsequent block-based encryption operations in the grayscale-based EtC system—block permutation, block rotation/reflection, and block-wise brightness inversion—severely disrupt the spatial ordering and orientation consistency of blocks, making conventional scan-order-dependent embedding/extraction unreliable. In contrast, each block preserves its EISI under these operations, which enables the extractor to reconstruct an embedding-consistent block order directly in the encrypted domain without auxiliary side information.

Figure 7. Impact of block-based encryption and EISI-based synchronization in component-serialized grayscale EtC systems.

Embedding in the RGB domain is unsuitable in this context. The RGB-to-YCbCr conversion involves rounding operations (Equations (1)–(6)), which introduce quantization errors that cannot be compensated once subsequent encryption operations disrupt pixel correlations. As confirmed by preliminary experiments (Section 5.5), embedding cues defined in the RGB domain are almost entirely destroyed after color space conversion. Therefore, reliable reversible embedding must be performed on the YCbCr-derived grayscale representation before encryption.

3.2. Auxiliary-Information-Free and Self-Synchronizing Block-Level Design

As illustrated in Figure 7, the block-based encryption operations employed in EtC systems—namely block permutation, rotation/reflection, and brightness inversion—severely disrupt the spatial ordering of blocks. As a result, embedding schemes that rely on global scanning order or inter-block dependencies become ineffective.

To address this issue, the proposed framework adopts a block-independent design that leverages two previously established components:

3.2.1. Transformation-Invariant Embedding Cue (DPAD)

As an embedding cue, the framework employs the DPAD, which is computed using only basic subtraction and absolute value operations. DPAD is invariant under block rotation, flipping, and brightness inversion, allowing embedded and non-embedded blocks to be distinguished directly in the encrypted domain. By relying solely on local pixel relationships, DPAD avoids the need for complex predictors or global statistics.

3.2.2. Encryption-Invariant Synchronization Index (EISI)

While DPAD enables reliable block-level embedding detection, it does not recover the original ordering of permuted blocks. For this purpose, the framework adopts the EISI, a content-based tag computed independently within each block. Because EISI is invariant under block permutation applied to component-serialized grayscale representations, it enables the extraction process to reconstruct the embedding-consistent order without auxiliary side information. As conceptually illustrated in Figure 7, each block preserves its EISI value even after block-based encryption, allowing the extractor to restore the correct embedding order directly in the encrypted domain.

Since both DPAD computation and EISI evaluation are performed independently for each block, embedding and extraction can be carried out without inter-block dependencies. This auxiliary-free, self-synchronizing structure simplifies system integration and naturally supports parallel execution across blocks.

4. Proposed Scheme

The proposed scheme is designed to meet the following objectives, focusing on practical deployment within grayscale-based EtC pipelines:

• Compatibility: Supporting grayscale image generation based on the YCbCr color space and ensuring robustness against the three visual encryption operations of EtC systems [6,7].
• Reliability: Enabling accurate extraction of embedded data and perfect image restoration without requiring the transmission, storage, or memorization of image-dependent parameters or auxiliary side information.
• Lightweight and Parallelizable Design: Ensuring that the embedding and extraction procedures rely only on low-complexity arithmetic and block-wise independent operations, which are amenable to parallel implementation and hardware-friendly deployment.

4.1. Design Strategy

4.1.1. Support for Color Space Conversion

To generate the grayscale image used in the embedding stage, the proposed scheme first converts RGB images to the YCbCr color space and horizontally concatenates the three components (Figure 8). This structure ensures that data embedding is performed within the EtC pipeline without interfering with the reversibility of the color transformation.

Figure 8. Policy for inverse color space conversion support.

Specifically, the proposed scheme embeds data into the Cb and Cr chrominance components, excluding the Y (luminance) component. This design choice provides the following practical advantages:

• Reduced processing scope: Restricting the embedding and extraction operations to chrominance components simplifies the processing flow and reduces the number of candidate blocks to be examined, which is beneficial for practical implementations.
• Favorable local statistics for difference-based embedding: Compared with the luminance component, chrominance components often exhibit smoother local variations, which tend to produce smaller difference values and can improve the feasibility of difference-expansion-based reversible embedding under strict reversibility constraints.
• Conservative distortion control: Avoiding modifications to the luminance component helps limit perceptually sensitive changes and reduces the risk of value overflow/underflow when combined with RGB↔YCbCr conversion and subsequent EtC operations.

Crucially, direct embedding in the RGB domain is identified as unsuitable for this framework. The RGB-to-YCbCr conversion involves rounding operations that introduce quantization errors. These errors are not bitwise reversible after the encryption process disrupts the pixel correlations. Our experiments (discussed in Section 5.5) confirm that over 99.99% of embedding cues defined in the RGB domain are destroyed after color conversion. This demonstrates that for a reliable reversible system, embedding must be performed on the YCbCr-derived grayscale representation prior to encryption.

4.1.2. Auxiliary-Information-Free and Self-Synchronizing Embedding

As illustrated in Figure 7, the EtC encryption steps [6,7]—specifically block permutation, rotation/flipping, and brightness inversion—dramatically alter the spatial arrangement of blocks. Consequently, the original order of the embedded bitstream is disrupted, rendering conventional RDH schemes infeasible.

To address this, we adopt a block-independent embedding strategy based on two lightweight components that are preserved under the EtC operations:

• Transformation-Invariant Embedding Cue (DPAD): We build upon the DPAD, whose computation requires only basic subtraction and absolute value operations. DPAD is preserved under block rotation/reflection and brightness inversion, enabling the decoder to identify candidate embeddable blocks from the encrypted image without decryption.
• EISI: To handle the synchronization issue caused by block permutation, we build upon an EISI, which is computed locally within each block and remains available after the EtC operations. In particular, the EISI is designed to support ordering recovery even under block permutation applied to component-serialized grayscale representations, enabling extraction without auxiliary side information.

4.2. Data Embedding Procedure

The proposed scheme embeds data into grayscale images generated from YCbCr-transformed color images as shown in Figure 9. The process follows these steps:

Figure 9. Overview of the proposed data hiding scheme.

• Color Space Conversion. Convert the RGB image $I_{\mathrm{RGB}}$ of size $X\times Y$ into the YCbCr color space, resulting in three separate channels: $I_{\mathrm{Y}}$, $I_{\mathrm{Cb}}$, and $I_{\mathrm{Cr}}$.
• Channel Concatenation. Horizontally concatenate the three channels to generate a grayscale image $I_{\mathrm{g}}$ of size $3X\times Y$.
• Block Partitioning. Divide $I_{\mathrm{g}}$ into non-overlapping $4\times 4$ blocks. The embedding block size is set to $4\times 4$, which evenly partitions the $8\times 8$ encryption blocks of the target EtC system [6,7] and prevents any embedding block from spanning two encrypted blocks. Moreover, $4\times 4$ provides a suitable balance for the DPAD + EISI design: $2\times 2$ tends to produce less discriminative EISI (higher collision probability), whereas $8\times 8$ increases the chance of violating reversible-embedding constraints (e.g., overflow/underflow) under DPAD.
• Pattern Selection (O or X). Select one of two embedding patterns —O or X— as shown in Figure 10. Each pattern defines specific pixel pairs within the block used to compute DPAD values. The indices $\{s,t,u,v,w,x,y,z\}$ are assigned as follows:

  $$\mathrm{O}:\left\{\begin{array}{c}s=3,t=8\hfill \\ u=9,v=14\hfill \\ w=2,x=5\hfill \\ y=12,z=15\hfill \end{array}\right.\mathrm{X}:\left\{\begin{array}{c}s=1,t=6\hfill \\ u=11,v=16\hfill \\ w=4,x=7\hfill \\ y=10,z=13\hfill \end{array}\right.$$

  (8)
  

  Figure 10. For the b-th $4\times 4$-pixel block (left), pattern O uses the 2nd, 3rd, 5th, 8th, 9th, 12th, 14th, and 15th pixels within the block for embedding (center), while pattern X utilizes the 1st, 4th, 6th, 7th, 10th, 11th, 13th, and 16th pixels (right).
• DPAD Computation. For each block, calculate the absolute differences between pixel pairs along diagonal paths, $d_{b,a}$ where $a\in \{1,2,3,4\}$. Compute the mean of these differences, ${\overline{d}}_b$, and their relative difference, $d_b$, to determine embeddability.

  $$\begin{array}{cccc}\hfill d_{b,1}& =\left|g_{b,s}-g_{b,t}\right|,\hfill & \hfill d_{b,2}& =\left|g_{b,u}-g_{b,v}\right|,\hfill \end{array}$$

  (9)

  $$\begin{array}{cccc}\hfill d_{b,3}& =\left|g_{b,w}-g_{b,x}\right|,\hfill & \hfill d_{b,4}& =\left|g_{b,y}-g_{b,z}\right|,\hfill \end{array}$$

  (10)

  $${\overline{d}}_b={\displaystyle \frac{1}{4}}\sum _{a=1}^4{d}_{b,a},d_b=⌊{\displaystyle \frac{d_{b,1}+d_{b,2}}{2}}⌋-⌊{\displaystyle \frac{d_{b,3}+d_{b,4}}{2}}⌋.$$

  (11)
• Parameter Determination. Set parameters $t_0$, $t_1$, ${\tau }_0$, and ${\tau }_1$ based on the distribution of zero-frequency (histogram-gap) DPAD values. Let the DPAD value domain be $\mathcal{D}=\{0,1,\dots ,255\}$ for 8-bit images, and let $H\left(d\right)$ denote the empirical histogram count of DPAD value d computed over the blocks used for parameter determination. We define the set of zero-frequency DPAD values as

  $${\mathcal{V}}_0=\{d\in \mathcal{D}\mid H\left(d\right)=0\},$$

  (12)

  and its even/odd subsets as

  $${\mathcal{V}}_{0,\mathrm{even}}=\{d\in {\mathcal{V}}_0\mid dmod2=0\},{\mathcal{V}}_{0,\mathrm{odd}}=\{d\in {\mathcal{V}}_0\mid dmod2=1\}.$$

  (13)
  After sorting each subset in ascending order, $even\left(n\right)$ and $odd\left(n\right)$ denote the n-th smallest elements of ${\mathcal{V}}_{0,\mathrm{even}}$ and ${\mathcal{V}}_{0,\mathrm{odd}}$, respectively.

  $$\begin{array}{cccc}\hfill t_0& =⌈{\displaystyle \frac{even\left(1\right)}{2}}⌉,\hfill & \hfill t_1& =⌈{\displaystyle \frac{even\left(2\right)}{2}}⌉,\hfill \end{array}$$

  (14)

  $$\begin{array}{cccc}\hfill {\tau }_0& =⌈{\displaystyle \frac{odd\left(1\right)-1}{2}}⌉,\hfill & \hfill {\tau }_1& =⌈{\displaystyle \frac{odd\left(2\right)-1}{2}}⌉.\hfill \end{array}$$

  (15)
• Trial Embedding. Only blocks with $d_b\in \{-1,0,1\}$ are considered for embedding. Note that blocks from the luminance channel $I_{\mathrm{Y}}$ are explicitly excluded to optimize efficiency and image quality.
  • If $d_b=0$, attempt to expand $\left|d_b\right|$ based on $t_1$.
  • If $\left|d_b\right|=1$, attempt to expand $\left|d_b\right|$ using ${\tau }_1$.
  We perform a reversibility pre-check by simulating the required rounding/clamping in the RGB↔YCbCr conversion and verifying that the difference-expansion update does not cause overflow/underflow. Blocks that violate these constraints are excluded from embedding. For suitable blocks, an EISI ${\mathrm{eisi}}_b$ is then generated:

  $$\begin{array}{cc}\hfill {\mathrm{eisi}}_b& ={\mathrm{S}}_{b1}\parallel {\mathrm{S}}_{b2}\parallel D_{b1,1}\parallel D_{b2,1}\parallel D_{b1,2}\parallel D_{b2,2}\parallel D_{b1,3}\parallel D_{b2,3}\hfill \end{array}$$

  $$\begin{array}{cc}\hfill & \parallel D_{b1,4}\parallel D_{b2,4}\parallel D_{b1,5}\parallel D_{b2,5}\parallel D_{b1,6}\parallel D_{b2,6}\parallel R_b\parallel {\overline{d}}_b\hfill \end{array}$$

  (16)

  $$\begin{array}{cc}\hfill R_b& =\underset{i}{max}{g}_{b,i}-\underset{i}{min}{g}_{b,i},i\in \{1,\dots ,16\}\hfill \end{array}$$

  (17)

  $$\begin{array}{cc}\hfill {\mathrm{S}}_{b1}& ={\sum }_{ϵ=1}^8{\Delta }_{b1,ϵ},{\mathrm{S}}_{b2}={\sum }_{ϵ=1}^8{\Delta }_{b2,ϵ}\hfill \end{array}$$

  (18)

  where $\parallel$ denotes concatenation of integer fields into a single index. Here, the pixel difference terms ${\Delta }_{b1,ϵ}$ and ${\Delta }_{b2,ϵ}$ (detailed in Step 7) are sorted in ascending order to form $D_{b1,o}$ and $D_{b2,o}$, so that the resulting index is robust to block rotation and flipping.
  To guarantee a unique extraction order, blocks with non-unique EISI values are excluded from embedding; i.e., we keep only the blocks whose ${\mathrm{eisi}}_b$ appears exactly once among all candidate blocks.

  $$\begin{array}{c}\hfill \begin{array}{cccc}\hfill {\Delta }_{b1,1}& =\left|g_{b,2}-g_{b,5}\right|,\hfill & \hfill {\Delta }_{b1,2}& =\left|g_{b,9}-g_{b,14}\right|,\hfill \\ \hfill {\Delta }_{b1,3}& =\left|g_{b,3}-g_{b,8}\right|,\hfill & \hfill {\Delta }_{b1,4}& =\left|g_{b,12}-g_{b,15}\right|,\hfill \\ \hfill {\Delta }_{b1,5}& =\left|g_{b,1}-g_{b,16}\right|,\hfill & \hfill {\Delta }_{b1,6}& =\left|g_{b,4}-g_{b,13}\right|,\hfill \\ \hfill {\Delta }_{b1,7}& =\left|g_{b,6}-g_{b,11}\right|,\hfill & \hfill {\Delta }_{b1,8}& =\left|g_{b,7}-g_{b,10}\right|,\hfill \\ \hfill {\Delta }_{b2,1}& =\left|g_{b,1}-g_{b,11}\right|,\hfill & \hfill {\Delta }_{b2,2}& =\left|g_{b,6}-g_{b,16}\right|,\hfill \\ \hfill {\Delta }_{b2,3}& =\left|g_{b,4}-g_{b,10}\right|,\hfill & \hfill {\Delta }_{b2,4}& =\left|g_{b,7}-g_{b,13}\right|,\hfill \\ \hfill {\Delta }_{b2,5}& =\left|g_{b,2}-g_{b,12}\right|,\hfill & \hfill {\Delta }_{b2,6}& =\left|g_{b,3}-g_{b,9}\right|,\hfill \\ \hfill {\Delta }_{b2,7}& =\left|g_{b,8}-g_{b,14}\right|,\hfill & \hfill {\Delta }_{b2,8}& =\left|g_{b,5}-g_{b,15}\right|.\hfill \end{array}\end{array}$$

  (19)
• Difference Expansion. In ascending order of ${\mathrm{eisi}}_b$, apply difference expansion using t or $\tau$ as shown in Figure 11. The embedding modifies specific diagonal pixels according to their pattern (O or X) and payload bit $w_l$. Specifically:

  $$\begin{array}{cc}\hfill {\widehat{g}}_{{\chi }_l,j}& =\left\{\begin{array}{cc}{g}_{{\chi }_l,j}+{\tau }_{w_l},\hfill & d_{{\chi }_l}=1\mathrm{and}{g}_{{\chi }_l,j}\ge g_{{\chi }_l,j+5}\hfill \\ g_{{\chi }_l,j}-{\tau }_{w_l},\hfill & d_{{\chi }_l}=1\mathrm{and}{g}_{{\chi }_l,j}<g_{{\chi }_l,j+5}\hfill \\ g_{{\chi }_l,j},\hfill & \mathrm{otherwise}\hfill \end{array}\right.,\hfill \end{array}$$

  (20)

  $$\begin{array}{cc}\hfill {\widehat{g}}_{{\chi }_l,k}& =\left\{\begin{array}{cc}{g}_{{\chi }_l,k}+t_{w_l},\hfill & d_{{\chi }_l}\ne 1\mathrm{and}{g}_{{\chi }_l,k}\ge g_{{\chi }_l,k+3}\hfill \\ g_{{\chi }_l,k}-t_{w_l},\hfill & d_{{\chi }_l}\ne 1\mathrm{and}{g}_{{\chi }_l,k}<g_{{\chi }_l,k+3}\hfill \\ g_{{\chi }_l,k},\hfill & \mathrm{otherwise}\hfill \end{array}\right.,\hfill \end{array}$$

  (21)

  $$\begin{array}{cc}\hfill {\widehat{g}}_{{\chi }_l,j+5}& =\left\{\begin{array}{cc}{g}_{{\chi }_l,j+5}-{\tau }_{w_l},\hfill & d_{{\chi }_l}=1\mathrm{and}{g}_{{\chi }_l,j}\ge g_{{\chi }_l,j+5}\hfill \\ g_{{\chi }_l,j+5}+{\tau }_{w_l},\hfill & d_{{\chi }_l}=1\mathrm{and}{g}_{{\chi }_l,j}<g_{{\chi }_l,j+5}\hfill \\ g_{{\chi }_l,j+5},\hfill & \mathrm{otherwise}\hfill \end{array}\right.,\hfill \end{array}$$

  (22)

  $$\begin{array}{cc}\hfill {\widehat{g}}_{{\chi }_l,k+3}& =\left\{\begin{array}{cc}{g}_{{\chi }_l,k+3}-t_{w_l},\hfill & d_{{\chi }_l}\ne 1\mathrm{and}{g}_{{\chi }_l,k}\ge g_{{\chi }_l,k+3}\hfill \\ g_{{\chi }_l,k+3}+t_{w_l},\hfill & d_{{\chi }_l}\ne 1\mathrm{and}{g}_{{\chi }_l,k}<g_{{\chi }_l,k+3}\hfill \\ g_{{\chi }_l,k+3},\hfill & \mathrm{otherwise}\hfill \end{array}\right..\hfill \end{array}$$

  (23)
  

  Figure 11. Expanding diagonal pixel absolute difference (DPAD) to hide data.
  Here, $g_{{\chi }_l,\lambda }$ denotes the group of diagonal pixels in the ${\chi }_l$-th block of ${\mathbf{I}}_{\mathrm{g}}$, where $j\in \{s,u\}$ and $k\in \{w,y\}$.
• Optional Second Embedding Pass. To increase capacity, a second embedding can be performed using the alternate pattern. If no second pass is required, proceed to the next step.
• Reconstruction and Restoration. Combine all blocks to obtain ${\widehat{\mathbf{I}}}_{\mathrm{g}}$, then split into Y, Cb, and Cr channels and convert back to RGB to obtain the final stego image ${\widehat{\mathbf{I}}}_{\mathrm{RGB}}$.

4.3. Image Recovery and Data Extraction

The extraction process reverses the embedding procedure to recover both the embedded data and the original image. Figure 12 illustrates the overall workflow.

Figure 12. Data extraction and image recovery in the proposed scheme.

• Color Space Conversion and Block Partitioning. Convert stego image ${\widehat{\mathbf{I}}}_{\mathrm{RGB}}$ to YCbCr, concatenate channels, and divide ${\widehat{\mathbf{I}}}_{\mathrm{g}}$ into $4\times 4$ blocks.
• Pattern Identification. Identify whether pattern O or X was used. If two embedding passes were performed, reverse the order during extraction (last-in, first-out).
• DPAD and EISI Recomputation. Recompute DPAD values (${\overline{d}}_b,d_b$) and select candidate blocks with $d_b\in \{-1,0,1\}$. For these candidates, recalculate the EISI ${\mathrm{eisi}}_b$ using the encryption-invariant features.
• Bit Extraction and Block Restoration. Processing candidate blocks in ascending order of ${\mathrm{eisi}}_b$, perform inverse difference expansion to recover the embedded bits and restore the original pixel values.
  • If originally $d_{{\chi }_l}=1$, the embedded change used ${\tau }_{w_l}$;
  • If originally $d_{{\chi }_l}\ne 1$, the embedded change used $t_{w_l}$.
  By examining the expanded differences (Figure 13), one can deduce the embedded bit $w_l$ and undo the pixel modifications. Since this step relies only on local block data, it can be executed in parallel threads due to its block-independent design.
  

  Figure 13. Restoring diagonal pixel absolute differences (DPAD) for data extraction and image restoration.
• Data Collection and Image Reconstruction. Append extracted bits to the output payload $\widehat{\mathbf{w}}$, recombine restored blocks into ${\check{\mathbf{I}}}_{\mathrm{g}}$, and finally convert back to RGB format.

Summary. Overall, by embedding only in the Cb/Cr region and using DPAD-based block selection together with EISI-based ordering in a block-independent manner, the proposed scheme enables reliable reversible extraction and perfect restoration under permutation, rotation/reflection, and brightness inversion, while remaining naturally parallelizable for practical grayscale-based EtC deployments.

5. Experimental Results

To evaluate the performance and compatibility of the proposed scheme with the EtC system [6,7], experiments were conducted using 24-bit RGB images from four publicly available datasets—UltraEye [45], USC-SIPI [46], Kodak [47], and CSIQ [48], as shown in Figure 14. Across all four datasets and all tested payload settings (including maximum payload cases), the proposed scheme consistently achieves a 100% extraction success rate (ESR) and 0 bit error rate (BER), where the ESR is defined as the percentage of trials with perfect payload recovery (BER = 0), demonstrating that the DPAD-based cue remains stable across diverse texture characteristics.

Figure 14. Some images from four different datasets with their respective total number of images and image sizes. (a) UltraEye dataset [45]: 38 images, $1920\times 1080\times 3$. (b) USC-SIPI dataset [46]: 50 images, ${256}^2\times 3$ to ${1024}^2\times 3$. (c) Kodak dataset [47]: 24 images, $2048\times 3072\times 3$. (d) CSIQ dataset [48]: 30 images, $512\times 512\times 3$.

• Scope of comparisons

Direct quantitative comparisons with existing RDH/RDHEI methods are not reported here because most representative schemes are developed under ciphertext models and processing assumptions that are not aligned with the target grayscale-based EtC pipeline [6,7]. Since our evaluation requires strict error-free extraction (BER = 0) under the unmodified target pipeline, such methods cannot be meaningfully benchmarked in the same experimental protocol. Instead, Table 1 summarizes the key compatibility factors and clarifies the comparison boundary considered in this work.

Table 1. Compatibility summary with representative related methods under the target grayscale-based EtC setting [6,7].

Method	Supports Color/Serialization	Supports Perm + Rot + Inv	Lightweight	Notes
Ours	✓	✓	✓	Block-local integer ops; block-parallel implementation.
Conventional EtC-RDH [39]	✗	✓	✓	Pipeline mismatch with [6,7]; payload extremely limited.
Representative RDHEI [31,32,33,41,42,43,44]	✗	Partial: [31,32,33] No: [41,42,43,44]	✗	Ciphertext assumptions differ from the target EtC setting.
Yamni et al. [28]	✗	N/A	✓	Plaintext RDH (different objective/pipeline).
Chen et al. [29]	✗	N/A	✓	Secret-sharing ciphertext model (different objective).

In the following subsections, we analyze the impact of data hiding on encryption security, evaluate lossless compression efficiency, investigate embedding capacity, and validate the architecture through an ablation study. Finally, we provide a theoretical complexity analysis to demonstrate the scheme’s suitability for practical EtC-based image processing pipelines.

5.1. Adjacent Pixel Correlation

To confirm that data embedding does not compromise encryption security, we analyze the statistical properties of the encrypted images. Since the EtC system performs encryption on a block-by-block basis with $8\times 8$ blocks, its security can be evaluated by analyzing the correlation between adjacent blocks [38]. High encryption performance leads to low block-to-block correlation.

To calculate block-level correlation, a downsampled image was created by extracting the top-left pixel of each $8\times 8$ block, forming a 1/8-scale image (Figure 15). Figure 16 shows the correlation coefficients computed using the following equation:

$$C={\displaystyle \frac{{\sum }_{i=1}^N\left(x_i-\frac{1}{N}{\sum }_{i=1}^N{x}_i\right)\left(y_i-\frac{1}{N}{\sum }_{i=1}^N{y}_i\right)}{\sqrt{{\sum }_{i=1}^N{\left(x_i-\frac{1}{N}{\sum }_{i=1}^N{x}_i\right)}^2\times {\sum }_{i=1}^N{\left(y_i-\frac{1}{N}{\sum }_{i=1}^N{y}_i\right)}^2}}},$$

(24)

where $\left(x_i,y_i\right)$ are pixel value pairs from adjacent blocks, and N is the total number of such pairs [49].

Figure 15. Illustration of the downsampling process for block-level correlation analysis.

Figure 16. Split violin plot of correlation coefficients between adjacent blocks (horizontal, vertical, and diagonal) for encrypted images with and without embedded data under the condition that the maximum payload is embedded. Since the average absolute value stays well below 0.02, data hiding by the proposed scheme hardly affects the randomness of encrypted images.

The results confirm that the correlation coefficients remain close to zero and that their distribution is essentially preserved even after data embedding. This indicates that the proposed embedding process does not degrade the security strength of the EtC system, as the statistical characteristics of encrypted blocks remain random-like and no detectable anomalies are introduced.

Moreover, EISI is a deterministic per-block descriptor computed solely from within-block local invariant statistics, containing no secret key material or PRNG outputs; it provides no cross-block linkage constraints or relative spatial-position information, and it introduces no additional side information beyond what is already observable from the original EtC ciphertext.

5.2. Lossless Compression Efficiency

The impact of the proposed embedding scheme on lossless compression performance was evaluated using JPEG 2000 [15], JPEG XL [16], and PNG [17]. Compression was applied to three types of images: the original, the encrypted, and the encrypted image with embedded data. The encoder used for JPEG 2000 was OpenJPEG 2.3.1 [50].

As shown in Figure 17, embedding slightly affects the compression ratio. However, this impact is significantly smaller than that introduced by the encryption process itself. This confirms that the proposed scheme preserves the compression efficiency benefits of the EtC framework, which is crucial for bandwidth-constrained secure imaging systems.

Figure 17. Compression ratios using JPEG 2000 [15], JPEG XL [16], and PNG [17] lossless compression, where marked images carry the maximum embeddable payloads.

Because the codecs are used in lossless mode, decompression is bit-exact; hence, DPAD cues and per-block EISI values are preserved after decompression, and the proposed extractor yields ESR = 100% and BER = 0 regardless of the achieved compression ratio. Lossy compression (e.g., low-quality JPEG) is beyond the scope of this paper because quantization perturbs pixel values and local difference statistics.

5.3. Maximum Embeddable Information Capacity

Figure 18 shows the maximum payload size (in bpp) for both single and double embedding scenarios. In single embedding, pattern X often achieves higher capacity due to smaller embedding parameters. For double embedding, the sequence “pattern O followed by pattern X” typically yields the highest capacity. This is because the EISI is updated after the first pass, exposing additional embeddable blocks.

Figure 18. Maximum embeddable information capacity (bpp) of images for evaluation.

It is noted that for perfectly uniform images (e.g., solid backgrounds), all blocks yield identical EISI values, limiting the payload to 2 bits. This is an inherent limitation of EISI-based embedding in texture-less regions, though such cases are rare in natural photographic images.

5.4. Multi-Core Scalability

We benchmarked the proposed framework on an Apple M1 Max (32 GB) using MATLAB R2025a (macOS 26.2). The benchmark reports wall-clock time for processing 142 images (four datasets) with two-pass embedding. The measured runtime covers the forward pipeline, including DPAD/EISI computation, embedding and ordering, grayscale-based EtC encryption, and JPEG 2000 lossless compression (OpenJPEG 2.3.1 [50]), as well as writing output images and result files. No decompression or extraction is included in this benchmark. We used $n_{\mathrm{th}}\in \{1,2,4,8\}$ threads and define $S\left(n_{\mathrm{th}}\right)=T_1/T_{n_{\mathrm{th}}}$ and $E\left(n_{\mathrm{th}}\right)=S\left(n_{\mathrm{th}}\right)/n_{\mathrm{th}}$. As shown in Table 2, the implementation achieves a $6.80\times$ speedup at $n_{\mathrm{th}}=8$ with $84.9\%$ efficiency, demonstrating strong multi-core scalability.

Table 2. Multi-core speedup on Apple M1 Max (142 images, two-pass embedding, forward pipeline including EtC encryption and JPEG 2000 lossless compression). Time/pass is $T_{n_{\mathrm{th}}}/(142\times 2)$.

Threads ${\mathit{n}}_{\mathbf{th}}$	Total Time ${\mathit{T}}_{{\mathit{n}}_{\mathbf{th}}}$ (s)	Time/Pass (s)	Speedup $\mathit{S}\left({\mathit{n}}_{\mathbf{th}}\right)$	Efficiency $\mathit{E}\left({\mathit{n}}_{\mathbf{th}}\right)$
1	340.68	1.200	1.000	1.000
2	173.73	0.612	1.961	0.980
4	91.715	0.323	3.715	0.929
8	50.132	0.177	6.796	0.849

5.5. Ablation Study

To validate the architectural decisions, we conducted an ablation study on two critical components: the embedding domain and the synchronization mechanism.

5.5.1. Necessity of YCbCr Domain Processing

The EtC system involves floating-point arithmetic and rounding during RGB-to-YCbCr conversion. If data were embedded in the RGB domain prior to encryption, these rounding errors would corrupt the data during conversion. We quantified this by measuring the “Unchanged Ratio” of $4\times 4$ blocks after a full RGB→YCbCr→RGB cycle. As shown in Table 3, the unchanged ratio is extremely low (e.g., 0.01% for USC-SIPI). This confirms that embedding must occur in the YCbCr-derived grayscale domain to ensure reversibility.

Table 3. Analysis of block reversibility under color space conversion (RGB↔YCbCr). The low unchanged ratio demonstrates why embedding must occur in the YCbCr domain.

Dataset	Avg. Unchanged Blocks	Avg. Unchanged Ratio (%)
UltraEye	20,039.32	15.46
Kodak	6783.00	1.73
CSIQ	27.53	0.17
USC-SIPI	0.40	0.01

5.5.2. Necessity of EISI

EtC encryption applies a random block permutation, which destroys the spatial order of blocks. As shown in Table 4, over 10 independent encryption rounds, the unchanged ratio is near zero; hence, spatial positions cannot be used to reproduce the embedding order.

Table 4. Block position stability and ablation on EISI-based synchronization over 10 independent encryption rounds. ESR is the percentage of trials with perfect payload recovery (BER = 0).

Dataset	Avg. Unchanged Blocks	Ratio (%)	ESR w/ EISI (%)	ESR w/o EISI (%)
UltraEye	1.29	0.0013	100	0
CSIQ	1.00	0.0081	100	0
Kodak	0.83	0.0003	100	0
USC-SIPI	0.96	0.0092	100	0

We further provide an ablation in terms of the ESR. Without EISI, the extractor reads bits from a permuted block sequence and fails to recover the payload (ESR $\approx 0\%$); with EISI, the embedding order is deterministically reconstructed, yielding ESR = 100%.

5.6. Block-Level Structural Complexity

This analysis is provided to clarify the structural and algorithmic properties of the proposed framework; practical execution time depends on the implementation platform and is beyond the scope of this study.

To characterize the block-level computational structure of the proposed framework, we analyze the computational complexity of both the host EtC pipeline and the proposed RDH procedure. Let $M\times N$ denote the resolution of the input RGB image. After YCbCr conversion and component serialization, the grayscale image has size $3M\times N$. Let B be the total number of $4\times 4$ blocks in the serialized grayscale image; thus $B={\displaystyle \frac{3MN}{16}}$.

5.6.1. Complexity of the EtC System

The grayscale-based EtC pipeline consists of color space transformation, channel serialization, and three block-based encryption operations.

• Color Transformation and Serialization: RGB-to-YCbCr conversion requires a constant number of arithmetic operations per pixel, and serialization is a linear memory operation. Therefore, the overall complexity is $\mathcal{O}\left(MN\right)$.
• Block-wise Encryption: Block permutation, rotation/flipping, and brightness inversion are performed independently per $8\times 8$ encryption block in [6,7]. Each operation takes constant time per block, yielding $\mathcal{O}\left(B_{\mathrm{enc}}\right)$, where $B_{\mathrm{enc}}\propto MN$. Hence, the overall encryption complexity is $\mathcal{O}\left(MN\right)$.

5.6.2. Complexity of the Proposed RDH Scheme

The proposed RDH procedure is designed to be lightweight and mainly consists of block-local operations:

• Target Block Selection: Embedding is restricted to the Cb/Cr regions, so at most ${\displaystyle \frac{2}{3}}B$ blocks are processed for candidate selection.
• Per-block Feature Computation: For each candidate block, DPAD and EISI are computed using a constant number of integer operations. In particular, EISI requires sorting two fixed-length sets of 8 difference values; sorting a constant-size array is $\mathcal{O}\left(1\right)$ per block.
• Embedding/Extraction: Difference expansion and its inverse involve only a constant number of comparisons and integer additions/subtractions per selected block, i.e., $\mathcal{O}\left(1\right)$.

Therefore, excluding the synchronization stage, the RDH computation over all blocks is linear in the number of pixels, i.e., $\mathcal{O}\left(MN\right)$. In addition, the self-synchronization stage requires (i) counting EISI occurrences to remove non-unique indices and (ii) ordering blocks by EISI for deterministic embedding/extraction. These two steps can be implemented as $\mathcal{O}\left(B\right)$ counting plus $\mathcal{O}(BlogB)$ sorting (or near-linear time using radix sort for fixed-width integer keys). Importantly, all per-block computations are embarrassingly parallel, and the synchronization stage is also amenable to parallel implementations (e.g., parallel counting and parallel/radix sorting). As a result, the proposed framework is practically suitable for parallel execution on multi-core CPUs or GPUs, while maintaining overall linear-to-near-linear complexity with respect to image size.

6. Conclusions and Outlooks

This paper presents a parallelizable and lightweight reversible data hiding (RDH) framework tailored to grayscale-based encryption-then-compression (EtC) systems [6,7]. Rather than introducing new embedding primitives, the proposed framework integrates previously established DPAD-based embedding and EISI into a component-serialized grayscale EtC pipeline, achieving full compatibility with YCbCr color space transformation and robustness against block permutation, rotation/reflection, and brightness inversion. Experimental results confirm that the embedding process preserves the statistical characteristics required for secure EtC operation (adjacent block correlation coefficients in the encrypted domain remain close to zero) while achieving practical embedding capacity under strict compatibility constraints; moreover, dual embedding patterns enable flexible payload enhancement without sacrificing reversibility or compression behavior. Since DPAD computation, synchronization, and difference expansion are all performed independently at the block level, the framework is structurally compatible with block-wise parallel implementations and enables recovery of an embedding-consistent block order directly from the encrypted image without auxiliary side information. The framework is therefore most suitable for lossless EtC workflows that require auxiliary-free synchronization and bit-exact recovery, while robustness under aggressive lossy compression or adversarial modifications remains outside the present scope, as commonly encountered in cloud-based content delivery/storage, lossless medical archiving, and secure forensics/mission communications.

Overall, this work establishes a system-compatible and system-oriented RDH framework for advanced grayscale-based EtC pipelines, emphasizing compatibility, robustness, and architectural clarity. Future work will explore extensions to additional operating conditions, such as small-sized images and robustness under lossy compression or adversarial modifications, as well as alternative block-level organization strategies to further enhance payload flexibility while preserving EtC compatibility.