# Real-Time Error-Free Reversible Data Hiding in Encrypted Images Using (7, 4) Hamming Code and Most Significant Bit Prediction

^{1}

^{2}

^{*}

## Abstract

**:**

## 1. Introduction

- We proposed a (7, 4) Hamming code-based encoding scheme to embed secret bits into the LSBs of the encrypted image. The scheme can modify only 0–2 LSBs to embed 3 secret bits. Therefore, after data embedding, the visual quality of the marked decrypted image is high.
- We introduced an MSB prediction scheme with an error prediction map to implement error-free recovery of a portion of the MSBs. Therefore, these MSBs become reversible and modifiable. The information for recovering the modified LSBs can be embedded into the modifiable MSBs.
- We proposed a novel RDHEI method by using the (7, 4) Hamming coding-based encoding scheme and the MSB prediction scheme.

- (a)
- The method is a separable method. The receiver can obtain the secret data from the encrypted image without decryption and image recovery.
- (b)
- The method is free of errors. The extracted secret data have no incorrect bits. The recovered image is totally the same as the original image.
- (c)
- The method has high fidelity of the marked decrypted image.
- (d)
- The method is efficient from the standpoint of computation. It can use less execution time for embedding secret data than the existing RDHEI methods. Therefore, it is suitable for real-time applications of RDHEI in the cloud.

## 2. (7, 4) Hamming Code-Based Encoding and MSB Prediction

#### 2.1. The Hamming Code

**G**and the parity check matrix,

**H**. An example of the two matrices is shown as:

**G**, to generate the $1\times 7$ vector in which the first four elements are the same as the four message bits and the last three elements are the parity check code. For example, from the four message bits M = (1110)

_{2}, the 7-bit Hamming codeword, C, is generated:

_{2}.

**H**, is multiplied by the vector using modulo-2 matrix multiplication. If the result of the multiplication is an all-zero $3\times 1$ vector, the codeword has no single bit error. Otherwise, the result is equal to one of the matrix columns of

**H**, denoted as the ith column and the receiver can detect that the ith bit is incorrect and correct it. For example, if the codeword C = (1110000)

_{2}generated by

**G**is transformed into C

_{err}= (1010000)

_{2}due to the single bit error, the error can be detected by:

**H**, the receiver can detect the second bit of the codeword is an incorrect bit and correct the bit, so that C

_{err}is recovered to C. Notice that the single bit error can be detected in either message bits or parity-check bits.

#### 2.2. Hamming Code-Based Encoding

**H**, any 7-bit Hamming codeword can be classified as a ‘non-bit-error codeword’ or an ‘ith-bit-error codeword’ ($1\le i\le 7$) according to Equation (2). The ith-bit-error codeword is the codeword of which the ith bit is detected as an incorrect bit by using the parity check matrix

**H**and the non-bit-error codeword is the codeword of which no bit is detected as an incorrect bit by the

**H**. In the Hamming code-based encoding scheme, the non-bit-error codeword is used to represent the three secret bits (000)

_{2}and the 1st-bit-error codeword, 2nd-bit-error codeword, …, 7th-bit-error codeword are used to represent the three secret bits (001)

_{2}, (010)

_{2}, …, (111)

_{2}.

_{1}, P

_{2}, …, P

_{7}}, the LSBs of all the pixels in the group can be extracted as a 7-bit Hamming codeword C = (b

_{1}, b

_{2}, b

_{3}, b

_{4}, b

_{5}, b

_{6}, b

_{7}). To embed three secret bits in C, the Hamming code-based encoding scheme can encode C into a non-bit-error codeword or an ith-bit-error codeword ($1\le i\le 7$) to represent three secret bits by modifying at most 2 bits of C. The detailed procedure of the Hamming code-based encoding is given as follow:

**Step 1**- For the 7-bit codeword C = (b
_{1}, b_{2}, b_{3}, b_{4}, b_{5}, b_{6}, b_{7}), we calculate $R=\mathit{H}\times {C}^{\mathrm{T}}$ according to Equation (2), where**H**is the parity check matrix. If R is an all-zero vector, C is a non-bit-error codeword. Otherwise, R must be identical to one column of**H**. Denoting the index of the column as i, C is an ith-bit-error codeword. **Step 2**- If C is the codeword which represents the three secret bits to be embedded, nothing needs to be done. Otherwise, go to
**Step 3**. **Step 3**- If C is a non-bit-error codeword, C can be encoded into any kth-bit-error codeword by flipping its kth bit b
_{k}($1\le k\le 7$). If C is an ith-bit-error codeword ($1\le i\le 7$), C can be encoded into a non-bit-error codeword by flipping the ith bit b_{i}or a kth-bit-error codeword by flipping the ith and kth bits. Therefore, by flipping at most 2 bits, C can be encoded into the Hamming codeword which represents the three secret bits to be embedded.

**H**, to embed the secret bits (010)

_{2}, the codeword C1 is the 2nd-bit-error codeword which represents (010)

_{2}, so nothing needs to be done. To embed the secret bits (111)

_{2}, the codeword C2 is the 4th-bit-error codeword, so the 4th bit and the 7th bit of C2 are flipped to encode C2 into a 7th-bit-error codeword which represents (111)

_{2}.

#### 2.3. MSB Prediction

_{f}(i, j), where P

_{f}(i, j) is calculated by flipping the MSB of P(i, j), are calculated by:

#### 2.4. Error Prediction Map

**Step 1**- For the original modifiable pixel, P, use Equation (3) to calculate the estimated value, P
_{e}. **Step 2**- Flip the MSB of P to generate the value of the flipped pixel, P
_{f}. **Step 3**- Calculate the prediction error, PE, of P and the PE
_{f}of P_{f}using Equations (4) and (5), respectively. **Step 4**- If PE > PE
_{f}or PE = PE_{f}and the MSB of the estimated value P_{e}is the same as P_{f}, the MSB of P cannot be recovered correctly after MSB has been modified. Denote P as the ‘Error prediction pixel’ by recording the coordinate of P. **Step 5**- Repeat Steps 1–4 until all the error prediction pixels in the original image have been recorded.

_{f}(i, j) which is generated by flipping the MSB of P(i, j), if the coordinate (i, j) is recorded as the error prediction pixel in the error prediction map, the original pixel value of P(i, j) is recovered by:

## 3. The Proposed Method

#### 3.1. Image Encryption

**Step 1**- Generate the error prediction map from the original image, I.
**Step 2**- For each non-modifiable pixel, eight pseudo-random bits, that is, $r{b}_{ij0}$–$r{b}_{ij7}$, are generated by using the image encryption key and all of the bits of the pixel are encrypted by:$${e}_{ijk}={b}_{ijk}\oplus r{b}_{ijk},\text{}k=0,\text{}1,\text{}\dots ,\text{}7.$$
**Step 3**- For each modifiable pixel, six pseudo-random bits, that is, $r{b}_{ij2}$–$r{b}_{ij7}$, are generated by using the image encryption key and the six bits, ${b}_{ij2}$–${b}_{ij7}$, of the pixel are encrypted by:$${e}_{ijk}={b}_{ijk}\oplus r{b}_{ijk},\text{}k=2,\text{}3,\text{}\dots ,\text{}7.$$

**Step 4**- To encrypt the n-bit error prediction map, generate n pseudo-random bits by using the encryption key and do the bit-XOR encryption.
**Step 5**- Substitute the MSBs of the first l + n modifiable pixels with the l-bit size information of the error prediction map and the n-bit error prediction map.

#### 3.2. Data Embedding

**Step 1**- According to the size information of the error prediction map, all the modifiable pixels in the encrypted image are divided into two sets: the first set, denoted as
**FP**= {FP_{1}, FP_{2}, …, FP_{l+n}}, contains the first l + n modifiable pixels of which the MSBs indicate the information of the error prediction map. The second set, denoted as**RP**= {RP_{1}, RP_{2}, …, RP_{fin}}, contains the rest of the modifiable pixels of which the MSBs can be modified to embed the information for image recovery. **Step 2**- To embed secret bits, all the modifiable pixels are divided into 7-pixel groups as follow:

**FP**and six pixels from

**RP**to form a 7-pixel group, ${\mathit{G}}_{i}=\left\{F{P}_{i1},R{P}_{i2},\dots ,R{P}_{i7}\right\}$, until $\mathit{F}\mathit{P}=\varnothing $ or

**RP**does not have enough pixels.

**RP**still has enough pixels, the data hider uses the data hiding key to pseudo-randomly divide

**RP**into 7-pixel groups as ${\mathit{G}}_{j}=\left\{R{P}_{j1},R{P}_{j2},\dots ,R{P}_{j7}\right\}$.

**Step 3**- For each 7-pixel group, the 7-bit Hamming codeword is extracted from the first LSBs of all the pixels in the group to embed three secret bits. By using the parity check matrix
**H**, the 7-bit Hamming codeword is classified as one of the eight types of 7-bit Hamming codewords (the eight types are the non-bit-error Hamming codeword and the seven ith-bit-error codewords ($1\le i\le 7$)). For image recovery, the MSBs of the 2nd, 3rd and 4th pixels are modified to record the original type of the codeword (As given in Section 2.2, the non-bit-error codeword is represented by (000)_{2}, the 1st-bit-error codeword is represented by (001)_{2}and so on). Finally, the 7-bit Hamming codeword is encoded to represent the three secret bits by using the Hamming code-based encoding scheme in Section 2.2. **Step 4**- After all the groups have been processed in
**Step 3**, the second LSB layer can be used to embed secret bits. For each 7-pixel group, the 7-bit Hamming codeword is extracted from the second LSBs of all the pixels in the group. The procedure of data embedding is the same as the procedure in**Step 3**, except that the original codeword is recorded by the MSBs of the 5th, 6th and 7th pixels.

_{2}into the first LSBs of the pixels, the Hamming codeword consisting of the first LSBs C1 = (1001000)

_{2}is classified as the 5th-bit-error codeword, then the MSBs of the 2nd, 3rd and 4th pixels are modified to (101)

_{2}to record the type of the original C1. Then the 5th bit and the 3rd bit of C1 are flipped to encode C1 into a 3rd-bit-error codeword to represent the secret bits (011)

_{2}. To embed the secret bits (110)

_{2}into the second LSBs of the pixels, the Hamming codeword consisting of the second LSBs C2 = (1110010)

_{2}is classified as the 6th-bit-error codeword, then the MSBs of the 5th, 6th and 7th pixels are modified to (110)

_{2}to record the type of the original C2. Since C2 represents the secret bits (110)

_{2}, nothing needs to be done to encode C2.

**FP**is not larger than one-seven of the number of the modifiable pixels, the number of the 7-pixel groups is at the maximum value $\lfloor MPN/7\rfloor $, where MPN is the number of the modifiable pixels. Therefore, if the size of all the information of the error prediction map is not larger than $\lfloor MPN/7\rfloor $, the error prediction map does not affect the embedding capacity. In most cases, the size of the error prediction map are too small to affect the embedding capacity, due to the precise prediction of the MSBs of the modifiable pixels.

**H**should be shared with the receiver in advance.

#### 3.3. Image Recovery and Data Extraction

#### 3.3.1. Obtain the Marked Decrypted Image

**Step 1**- Extract the l-bit size information from the first l MSBs of the modifiable pixels of the marked encrypted image and then extract the encrypted error prediction map according to the size information.
**Step 2**- Decrypt the marked encrypted image and the error prediction map.
**Step 3**- For each modifiable pixel P, calculate the estimated pixel value P
_{e}by the four neighboring non-modifiable pixels of P according to Equation (3). **Step 4**- Calculate the prediction error $PE=\left|P-{P}_{\mathrm{e}}\right|$.
**Step 5**- Flip the MSB of P to generate a new pixel value P
_{f}and calculate the prediction error $P{E}_{\mathrm{f}}=\left|{P}_{\mathrm{f}}-{P}_{\mathrm{e}}\right|$. **Step 6**- According to the error prediction map, if P is not denoted as the error prediction pixel, the MSB of P is recovered by PE and PE
_{f}according to Equation (6). Otherwise, the MSB of P is recovered by PE and PE_{f}according to Equation (7). **Step 7**- Repeat Steps 3–6 until all the MSBs of the modifiable pixels have been recovered.

_{f}is generated. The four neighboring pixels of P are non-modifiable pixels which cannot be modified in the procedure of data embedding. By the four neighboring pixels, the estimated value P

_{e}is calculated. Then the two prediction errors PE and PE

_{f}are calculated. Since P is not an error prediction pixel according to the error prediction map and PE > PE

_{f}, P

_{f}is the original pixel value according to Equation (6).

#### 3.3.2. Data Extraction

**H**, the receiver can obtain the secret data from the encrypted image or from the marked decrypted image. The procedure for obtaining the secret data is:

**Step 1**- Use the data hiding key to divide all the modifiable pixels into the 7-pixel groups.
**Step 2**- For each 7-pixel group, extract the 7-bit Hamming codeword from the first LSBs of all the pixels in the group. By using the parity check matrix
**H**, the 7-bit Hamming codeword can be classified as a non-bit-error codeword or an ith-bit-error codeword ($1\le i\le 7$). Since the Hamming codeword has been encoded to represent the three secret bits in the procedure of data embedding. Therefore, the three secret bits can be directly obtained according to the Hamming codeword.

_{2}and the 1st-bit-error codeword, 2nd-bit-error codeword, … and 7th-bit-error codeword represent the three secret bits (001)

_{2}, (010)

_{2}, …, (111)

_{2}.

**Step 3**- If all of the groups are processed in Step 2 and not all the embedded bits are extracted, extract the embedded bits from the second LSB layer of each group until all of the embedded bits have been extracted. The process of extraction is the same as
**Step 2**.

**H**, C1 is classified as a 3rd-bit-error codeword. So the embedded secret bits are (011)

_{2}. The codeword C2 is extracted from the second LSBs of all the pixels. C2 is classified as 6th-bit-error codeword and the embedded secret bits are (110)

_{2}.

#### 3.3.3. Image Recovery

**H**, the original version of the marked encrypted image can be recovered without any error. The procedure for recovering the image is:

**Step 1**- Use the data hiding key to divide all the modifiable pixels into the 7-pixel groups.
**Step 2**- For each group, extract the 7-bit Hamming codeword C1 from the first LSBs of all the pixels in the group and use the parity check matrix
**H**to classify C1 into a non-bit-error codeword or an ith-bit-error codeword ($1\le i\le 7$). **Step 3**- Extract the MSBs of the 2nd–4th pixels in the group. The three MSBs represent the original type of C1. If C1 matches the original type represented by the three MSBs, C1 is unmodified and does not need to be recovered. Otherwise, C1 is recovered to its original type as follow:If C1 is a non-bit-error codeword, C1 is recovered to the kth-bit-error codeword by flipping the kth bit of C1 ($1\le k\le 7$).If C1 is an ith-bit-error codeword, C1 is recovered to the non-bit-error codeword by flipping the ith bit of C1 or the kth-bit-error codeword by flipping the ith and kth bits of C1.
**Step 4**- Extract the 7-bit Hamming codeword C2 from the second LSBs of all the pixels in the group and the MSBs of the 5th–7th pixels in the group which represent the original type of C2. Then C2 is recovered to its original version the same as
**Step 3**. **Step 5**- Repeat
**Steps 2**–**4**until all the first and second LSBs have been recovered. **Step 6**- Recover all of the MSBs of the modifiable pixels of the decrypted image. The recovery of the MSBs is the same as the procedure of obtaining the marked decrypted image in Section 3.3.1. Since the LSBs are recovered, all of the modified MSBs can be recovered free of errors. Therefore, the original image has been retrieved with no error.

_{2}is extracted from the first LSBs of all the pixels and its original type information (101)

_{2}is extracted from the MSBs of P2, P3 and P4. By using the parity check matrix

**H**, C1 is classified as a 3rd-bit-error codeword. According to the original type information (101)

_{2}, C1 is a 5th-bit-error codeword, so the 3rd and 5th bits of C1 are flipped to recover the original LSBs. Then, the Hamming code C2 = (1110010)

_{2}is extracted from the second LSBs of all the pixels and its original type information (110)

_{2}is extracted from the MSBs of P5, P6 and P7. Since C2 is a 6th-bit-error codeword which matches the original type information (110)

_{2}, the bits of C2 are unmodified in the procedure of data embedding and do not need to be recovered. After recovering the first and second LSBs, the MSBs of P2, P3, …, P7 are recovered by the neighboring non-modifiable pixels and the error prediction map.

## 4. Experimental Results

## 5. Conclusions

## Author Contributions

## Funding

## Conflicts of Interest

## References

- Qin, C.; Chen, X.; Luo, X.; Zhang, X.; Sun, X. Perceptual image hashing via dual-cross pattern encoding and salient structure detection. Inform. Sci.
**2018**, 423, 284–302. [Google Scholar] [CrossRef] - Qin, C.; Ji, P.; Zhang, X.; Dong, J.; Wang, J. Fragile image watermarking with pixel-wise recovery based on overlapping embedding strategy. Signal Process.
**2017**, 138, 280–293. [Google Scholar] [CrossRef] - Qin, C.; Chang, C.C.; Chiu, Y.P. A Novel Joint Data-Hiding and Compression Scheme Based on SMVQ and Image Inpainting. IEEE Trans. Image Process.
**2014**, 23, 969–978. [Google Scholar] [CrossRef] - Shi, Y.Q.; Ni, Z.; Zou, D.; Liang, C.; Xuan, G. Lossless data hiding: Fundamentals, algorithms and applications. In Proceedings of the IEEE International Symposium on Circuits and Systems, Vancouver, BC, Canada, 23–26 May 2004; pp. 33–36. [Google Scholar]
- Tian, J. Reversible data embedding using a difference expansion. IEEE Trans. Circuits Syst. Video Technol.
**2003**, 13, 890–896. [Google Scholar] [CrossRef] - Qiu, Y.; Qian, Z.; Yu, L. Adaptive reversible data hiding by extending the generalized integer transformation. IEEE Signal Process. Lett.
**2016**, 23, 130–134. [Google Scholar] [CrossRef] - Ni, Z.; Shi, Y.Q.; Ansari, N.; Su, W. Reversible data hiding. IEEE Trans. Circuits Syst. Video Technol.
**2006**, 16, 354–362. [Google Scholar] [CrossRef] - Nguyen, T.S.; Chang, C.C.; Huynh, N.T. A novel reversible data hiding scheme based on difference-histogram modification and optimal EMD algorithm. J. Vis. Commun. Image Represent.
**2015**, 33, 389–397. [Google Scholar] [CrossRef] - Li, X.; Li, J.; Li, B.; Yang, B. High-fidelity reversible data hiding scheme based on pixel-value-ordering and prediction-error expansion. Signal Process.
**2013**, 93, 198–205. [Google Scholar] [CrossRef] - Qu, X.; Kim, H.J. Pixel-based pixel value ordering predictor for high-fidelity reversible data hiding. Signal Process.
**2015**, 111, 249–260. [Google Scholar] [CrossRef] - Hong, W.; Chen, T.; Shiu, C. Reversible data hiding for high quality images using modification of prediction errors. J. Syst. Softw.
**2009**, 82, 1833–1842. [Google Scholar] [CrossRef] - Carpentieri, B.; Castiglione, A.; Santis, A.D.; Palmieri, F.; Pizzolante, R. One-pass lossless data hiding and compression of remote sensing data. Future Gener. Comput. Syst.
**2019**, 90, 222–239. [Google Scholar] [CrossRef] - Zhang, X. Reversible data hiding in encrypted images. IEEE Signal Process. Lett.
**2011**, 18, 255–258. [Google Scholar] [CrossRef] - Hong, W.; Chen, T.; Wu, H. An improved reversible data hiding in encrypted images using side match. IEEE Signal Process. Lett.
**2012**, 19, 199–202. [Google Scholar] [CrossRef] - Liao, X.; Shu, C. Reversible data hiding in encrypted images based on absolute mean difference of multiple neighboring pixels. J. Vis. Commun. Image Represent.
**2015**, 28, 21–27. [Google Scholar] [CrossRef] - Qin, C.; Zhang, X. Effective reversible data hiding in encrypted image with privacy protection for image content. J. Vis. Commun. Image Represent.
**2015**, 31, 154–164. [Google Scholar] [CrossRef] - Bhardwaj, R.; Aggarwal, A. An improved block based joint reversible data hiding in encrypted images by symmetric cryptosystem. Pattern Recognit. Lett.
**2018**, in press. [Google Scholar] [CrossRef] - Wu, X.; Sun, W. High-capacity reversible data hiding in encrypted images by prediction error. Signal Process.
**2014**, 104, 387–400. [Google Scholar] [CrossRef] - Dragoi, I.C.; Coanda, H.G.; Coltuc, D. Improved Reversible Data Hiding in Encrypted Images Based on Reserving Room After Encryption and Pixel Prediction. In Proceedings of the 25th European Signal Processing Conference (EUSIPCO), Kos Island, Greece, 28 August–2 September 2017; pp. 2186–2190. [Google Scholar]
- Puteaux, P.; Puech, W. An Efficient MSB Prediction-Based Method for High-Capacity Reversible Data Hiding in Encrypted Images. IEEE Trans. Inf. Forensics Secur.
**2018**, 13, 1670–1681. [Google Scholar] [CrossRef] [Green Version] - Zhang, X. Separable reversible data hiding in encrypted image. IEEE Trans. Inf. Forensics Secur.
**2012**, 7, 826–832. [Google Scholar] [CrossRef] - Qin, C.; Zhang, W.; Cao, F.; Zhang, X.; Chang, C.C. Separable reversible data hiding in encrypted images via adaptive embedding strategy with block selection. Signal Process.
**2018**, 153, 109–122. [Google Scholar] [CrossRef] - Qin, C.; He, Z.; Luo, X.; Dong, J. Reversible data hiding in encrypted image with separable capability and high embedding capacity. Inform. Sci.
**2018**, 465, 285–304. [Google Scholar] [CrossRef] - Qian, Z.; Zhang, X. Reversible data hiding in encrypted image with distributed source encoding. IEEE Trans. Circuits Syst. Video Technol.
**2016**, 26, 636–646. [Google Scholar] [CrossRef] - Zhang, X.; Qian, Z.; Feng, G.; Ren, Y. Efficient reversible data hiding in encrypted images. J. Vis. Commun. Image Represent.
**2014**, 25, 322–328. [Google Scholar] [CrossRef] - Li, M.; Xiao, D.; Zhang, Y.; Nan, H. Reversible data hiding in encrypted images using cross division and additive homomorphism. Signal Process. Image Commun.
**2015**, 39, 234–248. [Google Scholar] [CrossRef] - Xiao, D.; Xiang, Y.; Zheng, H.; Wang, Y. Separable reversible data hiding in encrypted image based on pixel value ordering and additive homomorphism. J. Vis. Commun. Image Represent.
**2017**, 45, 1–10. [Google Scholar] [CrossRef] - Yi, S.; Zhou, Y.; Hua, Z. Reversible data hiding in encrypted images using adaptive block-level prediction-error expansion. Signal Process. Image Commun.
**2018**, 64, 78–88. [Google Scholar] [CrossRef] - Xiong, L.; Xu, Z.; Shi, Y.Q. An integer wavelet transform based scheme for reversible data hiding in encrypted images. Multidimens. Syst. Signal Process.
**2018**, 29, 1191–1202. [Google Scholar] [CrossRef] - Computer Vision Group Test Image Database. Available online: http://decsai.ugr.es/cvg/dbimagenes/g512.php (accessed on 15 October 2018).
- Yi, S.; Zhou, Y. Binary-block embedding for reversible data hiding in encrypted images. Signal Process.
**2017**, 133, 40–51. [Google Scholar] [CrossRef] - Bas, P.; Filler, T.; Pevny, T. “Break our steganographic system”: The ins and outs of organizing BOSS. In Proceedings of the 13th International Workshop on Information Hiding, Prague, Czech Republic, 18–20 May 2011; pp. 59–70. [Google Scholar]

**Figure 8.**The six test images. (

**a**) Airplane; (

**b**) Baboon; (

**c**) Barbara; (

**d**) Lena; (

**e**) Peppers; (

**f**) Zelda.

**Figure 9.**The experimental images. (

**a**) Original image, Lena; (

**b**) Marked encrypted image with bpp = 0.2126; (

**c**) Marked decrypted image with PSNR = 57.79 dB; (

**d**) Recovered image.

**Figure 10.**PSNR of the marked decrypted images. (

**a**) Airplane; (

**b**) Baboon; (

**c**) Barbara; (

**d**) Lena; (

**e**) Peppers; (

**f**) Zelda.

© 2019 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Chen, K.; Chang, C.-C.
Real-Time Error-Free Reversible Data Hiding in Encrypted Images Using (7, 4) Hamming Code and Most Significant Bit Prediction. *Symmetry* **2019**, *11*, 51.
https://doi.org/10.3390/sym11010051

**AMA Style**

Chen K, Chang C-C.
Real-Time Error-Free Reversible Data Hiding in Encrypted Images Using (7, 4) Hamming Code and Most Significant Bit Prediction. *Symmetry*. 2019; 11(1):51.
https://doi.org/10.3390/sym11010051

**Chicago/Turabian Style**

Chen, Kaimeng, and Chin-Chen Chang.
2019. "Real-Time Error-Free Reversible Data Hiding in Encrypted Images Using (7, 4) Hamming Code and Most Significant Bit Prediction" *Symmetry* 11, no. 1: 51.
https://doi.org/10.3390/sym11010051