1. Introduction

Transmitting compressed images over heterogeneous networks such as the Internet requires that the compression algorithm be quality and resolution scalable. A quality scalable image compression system creates a bit-stream in which the data is arranged in such a way that the bits that have the higher quality improvement are placed before the other bits. As such, the image can be decompressed at any bit rate while the (full-size) image quality is the best at this rate. In this way, a low bandwidth user can reconstruct a low-quality image while a user that has high bandwidth may reconstruct the image at high quality. On the other hand, a resolution scalable compression creates a bit-stream which consists of several subsets. The first subset contains the data that belong to the lowest resolution (size) image. The next subset (and all the next subsets) contains the necessary data that is required to reconstruct the image at a larger resolution. Therefore, if only the first subset is received, then the image can be reconstructed at the lowest size. If larger image size is desired, the decoder utilizes this subset and the next received subsets. Resolution scalability is useful for users that have diverse display resolutions, such as smartphones, tablets, laptops, desktop computers, and TV. Resolution scalability is also useful for image browsing. For image browsing, the user first receives a fingernail image (a small and rough approximation of the original image) that is ample for deciding if the image must be received fully or not. Just in case of needing the total size image, the user downloads the rest needed information. It is advantageous to combine both types of scalabilities to create a highly or full scalable bit-stream which is both resolution and quality scalable (^{Al-Janabi, 2019}; ^{Rüefenacht et al., 2019}).

Scalability imposes an important restriction on the encoder. Specifically, it must operate without any earlier information about the quality and the size at which the image will be recovered by the users. Thus, the coder has to compress the image at full resolution and quality. After that, the compressed bit-stream is stored on a server. Users with various image quality and display resolution requirements send requests to the server, which delivers the appropriate scaled bit-stream to each one of them (^{Cappellari et al., 2011}).

It is well known that the 2-dimensional discrete wavelet transform (2D-DWT) is an indispensable tool for the scalable compression of images. Its local spatiality feature simplifies quality scalability while its multi-resolution nature easily provides resolution scalability. Briefly, the forward 2D-DWT starts by decomposing the original image into four subbands referred to as LL₁, HL₁, LH₁, and HH₁. Next, the LL₁ subband is also decomposed into another four subbands referred to as LL₂, HL₂, LH₂, and HH₂. The LL_x subband may be decomposed M times resulting in 3M+1 subbands. At any decomposition stage, the LL_m subband, m = 1,2 … M, represents a good approximation copy of the original image at reduced resolution with a size equal to 1/2^2m the original image size.

The inverse 2D-DWT starts by combining the LL_M subband with the HL_M, LH_M,and HH_M subbands to reconstruct the LL_M-1 subband. The inverse process can be done up to M times to obtain a replica of the original image. Figure 1 shows the effect of the 2D-DWT on the test image "Camera Man" for two decomposition levels (M = 2). The first decomposition level splits the image into LL₁, HL₁, LH₁, and HH₁ subbands and the second level splits the LL₁ subband into LL₂, HL₂, LH2, and HH₂ subbands. As seen, the LL₁ and the LL₂ subbands are good approximated copies of the original image with sizes equal to 1/2² = 1/4 and to 1/2⁴ = 1/16 the original image size respectively (^{Van Fleet, 2019}; ^{Vetterli, 2001}).

Figure 1 The effect of two levels of 2D-DWT on the "Camera Man". 

The wavelet subbands are arranged into M+1 resolution levels labeled R₀, R₁ … R_M. The lowermost resolution level, R₀, consists of the LL_M subband only. Each o ne of the next levels R_m, 1 ≤ m ≤ M, consists of the three subbands HL_M-m+1, LH_M-m+1, and HH_M-m+1 that are necessary to reconstruct the LL_M-m subband during the inverse 2D-DWT process. Refer to Figure 1, the wavelet image has three resolution levels (R₀, R₁ and R₂) that are represented by the yellow colour located at the down-right corner boundary of the corresponding resolution level. At the decoder, an image at the lowest resolution (1/16 the image size) can be obtained directly from the LL₂ subband. The image may be recovered at higher resolution by combining the LL₂ subband with the three subbands of R₁ (HL₂, LH₂, and HH₂), and performing one stage of inverse 2D-DWT to obtain LL₁ (1/4 the image size). Finally, the image may be recovered at the biggest resolution (the entire image size) by combining the LL₁ subband with the 3 subbands of R₂ (HL₁, LH₁, and HH₁), and carry out another stage of inverse 2D-DWT to get a replica of the original image. Therefore, a resolution scalable bit-stream can be easily achieved if the resolution levels are encoded successively and are identifiable within the compressed bit-stream (^{Taubman et al., 2002}).

The set partitioning in hierarchical trees (SPIHT) (^{Said & Pearlman, 1996}) is a powerful wavelet-based image compression algorithm. Its main pros are it has reasonable complexity, good PSNR (peak signal to noise ratio) vs. the bit rate performance, and it creates a quality scalable bit-stream. At its invention time, the last feature was very interesting as it adds freedom to the user to select the desired quality of the received image very easily. However, this feature is not sufficient nowadays for users that have devices with diverse display resolution capabilities such as laptops smartphones, tablet PCs, etc. As such, adding resolution scalability to SPIHT to generate a highly (rate and resolution) scalable bit-stream is very valuable (^{Cappellari et al., 2011}; ^{Wu et al., 2013}). The second important weakness of SPIHT is its massive memory consumption, and complex memory management, which are caused by the use of three linked lists to save the image pixels’ coordinates. These lists consume memory about 2.5 times the DWT image (^{Chew et al., 2009}; ^{Singh & Butola, 2015}) which represents a true constraint for low memory devices such as wireless sensors (^{Deepthi et al., 2018}; ZainEldin et al., 2015) or for compressing volumetric medical images (^{Kamargaonkar & Sharma, 2016}; ^{Panjavamam & Bhuvaneswari, 2017}). In addition, in the case of compressing multi-components images such as RGB colour images in parallel, the algorithm would need a memory of about 3x2.5 = 7.5 times the DWT image which represents a very serious obstacle. Finally, from the scalability point of view, using the linked lists prohibits resolution scalability due to the recurrent process of removing/adding pixels from/to lists, which makes the stored pixels in these lists not ordered according to the resolution levels (^{Cappellari et al., 2011}; ^{Taubman et al., 2002}).

The SPIHT starts by applying the octave 2D-DWT to the image for M decomposition levels (normally M = 5). Next, every DWT coefficient c ij is quantized to cij, where x is the closest integer ≤ x. Then, every ⌊cij⌋ is represented using K bits (typically 16 bits), where the first bit is the sign bit (e.g., 1 for negative and 0 for positive coefficient), and the remaining K - 1 bits are the magnitude bits. SPIHT creates a quality scalable bit-stream using a power of two threshold coding combined with bit-plane coding by which the DWT coefficients are coded on a per-bit basis starting from the first non-zero MSB (most significant bit) to the LSB (least significant bit). The first non-zero MSB is determined if the threshold TH is selected to be:

where c_max is the magnitude of the pixel that has the maximum value in the DWT image, and x is the absolute value of x. The next bit(s) is encoded by decremented TH to TH/2 until TH equals 1. TH is sent to the decoder to identify the first non-zero MSB. At each bit-plane coding pass, a DWT coefficient equals to or greater than TH is deemed significant (SG); otherwise, it is deemed insignificant (ISG). Similarly, a set consisting of several coefficients is deemed SG if it contains one or more SG coefficients.

A closer look at Figure 1 reveals that there exists a shadow for the DWT image in all subbands. This means that if a coefficient located at a given position in the LL_M subband is ISG, then the coefficients located at the other subbands that have the same position (with respect to their subbands), are also expected to be ISG. SPIHT exploits this feature to collect as many ISG coefficients as possible and coding them by one symbol. This is attained by combining these ISG coefficients together to build trees referred to as spatial orientation trees (SOTs). The primary roots of these SOTs are the pixels of the LL_M subband excluding the top-left pixel in every set of (2×2) pixels. Every one of the three roots in each (2×2) set is considered a parent for four offspring located at HL_M, LH_M, and HH_M respectively according to its orientation. That is, the top-right pixel is linked to HL_M, the down-left pixel is linked to LH_M, and the down-right pixel is linked to HH_M. Then every pixel in subbands HL_m, LH_m, and HH_m, M ≥ m ≥ 2, is considered a root (parent) to four offspring located at HL_m-1, LH_m-1, and H_m-1 respectively. Notice that the pixels in the HL₁, LH₁, and HH₁ subbands have no offspring as they are the leaves of the trees. Figure 2 describes the SOTs of the first set of size (2×2) pixels in the subband LL₂ for an image decomposed to two 2D-DWT levels, where each numbered colour represents a root of an entire SOT that extends across several resolution levels, and the unnumbered colour represent the leaves of these SOTs.

Figure 2 The spatial orientation trees for a 2D-DWT image with two decomposition levels. 

SPIHT utilizes three linked lists referred to as the list of insignificant pixels (LIP), the list of insignificant sets (LIS), and the list of significant pixels (LSP). The LIP and LSP keep the (i,j) coordinates of the ISG, and SG pixels respectively while the LIS keeps the (i,j) coordinates of the roots of the SOTs. SPIHT makes use of two type of roots. A root of type A represents the parent of a whole SOT, while a root of type B represents the parent of a partial SOT, which is a whole SOT excluding its four direct offspring (children). The LSP is initialized empty, the LIP is initialized by the (i,j) coordinates of the pixels in the LL_M subband, and the LIS is initialized by the (i,j) coordinates of the primary parent roots of SOTs, which are the pixels in the LL_M subband excluding the top-left pixel in every (2×2) set.

The first coding pass consists of the sorting sub-pass while the next coding passes consist of the sorting and the refinement sub-passes. Over the sorting sub-pass, every pixel c_ij in LIP is examined for the current threshold TH. If c_ij is ISG, a 0 is sent to the output bit-stream. If c_ij is SG, a 1 and its sign bit are sent to the bit-stream, and the pixel’s coordinates are transferred to LSP for refinement in the next passes. Next, each root r_ij in LIS is examined. if r_ij is of type A, its entire SOT is constructed and examined. If the SOT is still ISG, a 0 is sent to the bit-stream. Conversely, if the SOT is SG, then a 1 is sent to the bit-stream, and the four direct offspring of r_ij are examined. If an offspring is ISG, a 0 is sent to the bit-stream and its (i,j) coordinates are added to LIP to be tested in the next coding passes. If the offspring is SG, a 1, and its sign bit are sent to the bit-stream, and its (i,j) coordinates are added to LSP for refinement during the next passes. Finally, if r_ij is of type A and has grandchildren (i.e., it lies in LL_M to HH₂ subbands), then r_ij is removed from current position and added to the end of LIS as a type B root to be examined later on at the same pass. Alternatively, if r_ij is of type B, so a partial SOT that excludes its direct four offspring is constructed and examined again. If this partial SOT is SG, then a 1 is sent to the bit-stream, r_ij is removed from LIS, and each one of its four offspring is added to the end of LIS as a type A root to be examined later on at the same pass. If the partial SOT is ISG, then a 0 is sent to the bit-stream and r_ij is kept in LIS to be examined again in the following coding pass.

All pixels in LSP are refined during the refinement sub-pass, with the exception of those added during the current pass. A pixel c_ij is refined by sending its n_th MSB to the bit-stream. After finishing the sorting and refinement sub-passes, the threshold TH is halved to begin a new coding pass. This process is repeated till the threshold is equal to 1, which means that all the pixels are encoded.

Several works interested in increasing the PSNR vs. the bit rate performance of SPIHT are presented cf. (^{Çekli & Akman, 2017}; ^{Çekli & Akman, 2019}; ^{Lee & Hung, 2018}; ^{Li & Liu, 2017}; ^{Sri & Sahu, 2019}). The modified SPIHT (MSPIHT) algorithm presented by ^{Rema et al. (2015)} is one of the most efficient algorithms found in the literature. The MSPIHT algorithm used modified SOTs that ensure that the algorithm codes the more significant information in the initial bit-planes. It enhanced the PSNR at very low bit rates (less than 0.5 bpp) but gave approximately the same PSNR for bit rates greater than 0.5 bpp. Furthermore, MSPIHT has the same limitations as SPIHT regarding memory consumption and management. ^{Al-Janabi (2013)} proposed an efficient, low complexity, and low memory algorithm termed the Single List SPIHT (SLS). It reduced the memory consumption of SPIHT to about 80% by using one list of size equal to 1/4 the image size and two-state marker bits per pixel. At the same time, it preserved the PSNR and the low complexity features of SPIHT.

^{Danyali and Mertins (2004)} focused on solving the scalability problem of SPIHT in their highly scalable-SPIHT (HS-SPIHT) algorithm. The HS-SPIHT algorithm added resolution scalability to SPIHT by utilizing resolution-dependent sorting passes with the related resolution-dependent linked lists. That is, for every resolution level R_m , m = 0, 1…M, a set of LIP, LSP, and LIS lists are employed. Therefore, there are LIP_m, LSP_m, and LIS_m. In each coding pass, the coder starts encoding from resolution level 0 and proceeds to the utmost level M. The algorithm first does the sorting sub-pass for the coefficients within the LIP_m, and then it processes the roots in the LIS_m in the same way as done in SPIHT. In the refinement sub-pass, each pixel in LSP_m is refined by sending its n_th MSB to the bit-stream. After finishing the sorting and refinement sub-passes for resolution R_m, the process is repeated for the lists related to the subsequent resolution levels. Unfortunately, the HS-SPIHT algorithm has also the same weakness of SPIHT regarding memory consumption. Furthermore, it must deal with 3M linked lists instead of 3. This needs extra efforts for memory management and consequently increases the complexity of the algorithm as compared to the SPIHT algorithm.

^{Alam and Khan (2012)} introduced the Listless HS-SPIHT (LHS-SPIHT) algorithm. It utilized the linear indexing technique to convert the DWT image from a 2D array to a 1D array of the same size to simplify the tracking of set partitioning. The functionalities of the lists LIP_m, LSP_m, and LIS_m of HS-SPIHT are performed using fixed-size state marker bits. That is, rather than adding the ISG pixels to LIP_m, the SG pixels to LSP_m, and the roots to LIS_m, the corresponding state marker bit is updated accordingly. For example, updating the marker bit of a pixel c_ij that lies in R_m to 1 is equivalent to adding its coordinates to LIP_m. Consequently, rather than of examining the pixels in every LIP_m only, the algorithm must examine the state marker bit of every pixel within the DWT image and codes the pixels that have a marker bit equals to 1 only. The same thing occurs for the SG pixels in every LSP_m and the roots in every LIS_m. This means that LHS-SPIHT must examine all the image pixels twice, and must examine the roots in subbands LL_M to HH₂ once in each coding pass. As a result, the algorithm's complexity rises when compared to HS-SPIHT, and consequently the complexity rises even more when compared to SPIHT. The average memory of the state marker is 4 bits per pixel. Since each pixel in the DWT image is represented by 16 bits, so the marker bits need additional memory equal to 1/4 the size of the DWT image. More importantly, using the linear indexing technique necessitates either saving the 2D-DWT image into the main memory and then writing it into a 1D array or both 2D-DWT images and the 1D array must be available in memory at the same time. Unfortunately, the former solution is time-consuming while the latter one demands additional memory equals to the DWT image (^{Drozdek, 2012}). So, the actual memory of LHS-SPIHT is equal to 1+1/4 = 1.25 the image size.

2. The proposed algorithms

This section first presents a modified version of the SPIHT algorithm termed the simplified SPIHT (SSPIHT) as it employs one type of roots instead of two. Then, the proposed Highly Scalable Listless SPIHT (HSLS) algorithm that represents the current work's main contribution is introduced. The proposed work reduces the memory of the SLS algorithm presented in (^{Al-Janabi, 2013}) further by replacing the list with state marker bits that consume on average 0.5 bit per pixel. More importantly, it upgrades the SLS algorithm to creates a highly scalable bit-stream that can be decompressed at numerous bit rates and resolutions by processing the resolution levels in each coding pass incrementally. Finally, the Interleaved HSLS (IHSLS) which is a simplified version of HSLS is put forward.

2.2. The HSLS algorithm

The proposed HSLS algorithm benefits from the multi-resolution characteristics of the 2D-DWT to generate a highly scalable bit-stream that can be decompressed at more than one rate (quality) and more than one resolution (size). Like the LHS-SPIHT algorithm (^{Alam & Khan, 2012}), the proposed HSLS algorithm also makes use of state marker bits instead of the linked lists used by SPIHT. However, the HSLS has the following advantages over LHS-SPIHT:

• It doesn’t use the linear indexing technique to avoid the complexity or the memory increment of this technique as clarified previously.

• HSLS utilizes one marker bit termed ( of size 2 bits for every pixel in the DWT image, and two markers termed ( and ( of size 1 bit each for every root in the subbands LL_M to HH₂. Since the total size of these subbands is equal to 1/4 the size of the image, so every root marker needs on average 1/4 bit. So, the total memory consumed by our HSLS algorithm is 2+1/4+1/4 = 2.5 bits per pixel only. In contrast, LHS-SPIHT used an average of 4 bits per pixel (^{Alam & Khan, 2012}).

• Like SSPIHT, it employs one type of roots.

• It eliminates the need to examine all the image pixels twice per pass. The main idea behind this is based on the fact that the pixels stored in the LIP represent the ISG offspring, and the pixels stored in the LSP represent the SG offspring of the roots of the SOTs that are found SG. So, these ISG and SG pixels can be easily deduced from the parent SG roots. In this way, the LIP and LSP can be dispensed by only computing the offspring that belong to the roots of the SG SOTs in each coding pass. Since these roots are located in subbands LL_M to HH₂ which have a size equal to 1/4 the DWT image size, and since only the SG SOTs are processed, then at most only 1/4 the image pixels need to be processed instead of testing all the image pixels two times in each pass as done in LHS- SPIHT (^{Alam & Khan, 2012}). Evidently, this will reduce the algorithm's computational time.

The purpose of the state marker bits δ, α, and β is to indicate the significance status of the corresponding pixel and root as follows:

• δ_ij = 0: the pixel c_ij is ISG.

• δ_ij = 1: c_ij has just become SG in the current coding pass.

• δ_ij = 2: c_ij is found SG in one of the previous coding passes.

• α_ij = 0: the root r_ij has an ISG SOT.

• α_ij = 1: r_ij has a SG SOT.

• β_ij = 0: r_ij is not considered for testing in the current coding pass or it is tested in a previous coding pass.

• βij = 1: rij is considered for testing in the current coding passes.

At initialization, HSLS computes the threshold TH using Eq. 1. Then, it sets the marker bit δ of every pixel in the DWT image to 0 to indicate that all the pixels are still ISG, sets the marker bit α for every root to 0 to indicate that all the roots are still ISG, and finally sets the marker bit β of every root in the LL_M subband to 1, and all other roots to 0. Setting the marker bit β_ij of the root r_ij to 1 is equivalent to adding the (i,j) coordinates of r_ij to LIS in SPIHT.

The first bit-plane coding pass consists of the sorting sub-pass only while the other passes consist of the sorting and refinement sub-passes. To preserve resolution scalability in each coding pass, the algorithm scans the DWT image from the lowest resolution level R₀, which contains the LL_M subband only, to the utmost resolution level R_M, which contains the HL₁, LH₁, and HH₁ subbands. That is, in each coding pass, the algorithm performs the sorting sub-pass for all resolutions incrementally, and then performs the refinement sub-pass for all resolutions incrementally too.

The sorting sub-pass starts by coding each pixel c_ij in resolution R₀ by the code_pixel(c_ij) procedure described next. Then, it will proceed to the next resolutions (R₁ - R_M). For every resolution R_m, 1 ≤ m ≤ M, all the parent roots are examined. It is worth noting that the parent roots of R_m lie in R_m-1 (i.e., the parent roots of R₁ lie in R₀ and so on). So, in fact, the parent roots are located in (R₀ - R_M-1). So, for every resolution, R_m, 0 ≤ m ≤ M -1, each root r_ij that is found SG in a previous coding pass (i.e., with α_ij = 1) is processed by computing its direct four offspring O_k, K = 1,2,3,4. Then, each offspring O_k is coded as a pixel by the code_pixel(O_k). Notice that this step is left out in the first coding pass as all the roots are still ISG. Finally, for every resolution, R_m, 0 ≤ m ≤ M-1, each root r_ij that is considered for testing in the current coding pass (i.e., with β_ij = 1), its SOT is constructed and tested for significance. If r_ij has still an ISG SOT, a 0 is transmitted to the bit-stream, and r_ij will be examined again in the next pass. If r_ij has an SG SOT, a 1 is sent to the bit-stream, α_ij is updated to 1 (i.e., r_ij is marked as a SG root), and β_ij is updated back to 0 (this is equivalent to removing the (i,j) coordinates of r_ij from LIS). Then, each one of the r_ij’s direct four offspring O_k, k = 1, 2, 3, 4 is coded as a pixel by the code_pixel(O_k). Finally, the marker bit of each one of its direct four offspring βOk is updated to 1 in order to be considered for testing as roots at the next resolution in the current pass. However, the last step is not performed for the offspring that lie at the utmost resolution level R_M because they are the leaves of the trees.

The refinement sub-pass firstly sends every pixel c_ij in R₀ that is found SG in the previous passes (i.e., with δ_ij = 2) to the refine_pixel(c_ij) procedure, described shortly, for refining. Next, for every resolution level R_m, 1 ≤ m ≤ M, each one of its SG roots r_ij (i.e., with α_ij=1) that lie in R_m-1, its direct four offspring O_k, k = 1,2,3,4 is coded by the refine_pixel(O_k) procedure to refine its magnitude. Lastly, the threshold TH is updated to TH/2 to proceed to the next coding pass until the threshold is equal to 1 indicating that all the pixels are encoded.

The code_pixel(c_ij) procedure works as follows: If c_ij is yet marked ISG (i.e., δ_ij = 0), c_ij is tested for significance. If cij≥TH, (i.e., c_ij has just become SG), a 1 and the sign bit are transmitted to the bit-stream, δ_ij is set to 1 (this is equivalent to adding the (i,j) coordinates of c_ij to LSP in SPIHT), and finally, c_ij is updated to c_ij - TH if it is positive or to c_ij + TH if it is negative. Conversely, if cij<TH (i.e., c_ij is yet ISG), a 0 is transmitted to the bit-stream. If δ_ij = 1 (i.e., c_ij is found SG at the previous pass, δ_ij is updated to 2 to distinguish c_ij from those pixels that will become SG at the current coding pass.

In the refine_pixel(c_ij) procedure, if cij≥TH), a 1 is transmitted to the bit-stream, and c_ij is updated to c_ij - TH if c_ij > 0 or to c_ij + TH if c_ij > 0. Otherwise, a 0 is sent to the bit-stream.

The pseudocodes of the encoder and decoder of the proposed HSLS are shown in Figure 3a and 3b respectively. The following remarks clarify the operation of the algorithm.

• As mentioned previously, the scalable encoder has to encode the image at the full bit rate (i.e., until TH = 1). On the other hand, the decoder may stop when the target bit rate is reached.

• As mentioned before, for a highly scalable bit-stream, each resolution level within each coding pass must be recognizable in the bit-stream. This is easily attained since these levels are encoded incrementally in each coding pass, by adding a marker at the beginning of each resolution level, that designates the length of corresponding the level.

• The decoder algorithm executes the same four steps of the encoder. The difference is that the decoder works inversely. That is, when it receives 0/1, this indicates that the corresponding pixel or SOT is ISG/SG respectively. Then, the decoder follows the same route as the encoder. Notice that if a pixel c_ij is SG, the decoder recognizes that the magnitude of c_ij is in the range [TH ( 2TH), so c_ij is reconstructed at the midpoint which is equal to ±1.5(TH based on its sign bit. Then every received refinement bit increases the precision of the pixel by ±TH/2 according to the received bit and the sign of the pixel. For example, assume that at the encoder the initial threshold TH = 16 and c_ij = +19. c_ij is SG as +19 ≥ 16. So, at pass#1, the encoder sends 1 and the sign bit 0, and it updates c_ij to 19-16 = 3. At pass#2, the encoder updates TH to TH/2 = 8, and sends 0 as 3 < 8. At pass#3, it updates TH to 4, and sends 0 since 3 < 4. Finally, at pass#4, it updates TH to 2 and sends 1 since 3 ≥ 2. The decoder first receives TH = 16. At pass#1, the received bits are 1 and 0, so it reconstructs c_ij to +1.5×TH = +1.5×16 = +24. At pass#2, TH is updated to 8 and the received bit = 0, so c_ij is updated to +24-4 = +20. At pass#3, TH = 4 and the received bit = 0, then c_ij is set to +20-2 = +18. Finally, at pass#4, TH = 2 and the received bit = 1, then c_ij is updated to +18 +1 = +19 which is equal to the original value.

• The decoder can reconstruct an image at resolution R_m, 0 ≤ m ≤ M by receiving the data that corresponds to R₀ to R_m and bypassing the data of the other resolutions in each coding pass. Then it performs m stages of inverse 2D-DWT only to recover the image with size equal to 1/22m the size of the original image.

Figure 3 The pseudocodes of the proposed HSLS Algorithm. 

2.3. The IHSLS algorithm

The IHSLS algorithm has only one coding pass per bit-plane instead of two. The new coding pass is termed the merging pass. It merges the sorting sub-pass with the refinement sub-pass. However, the code_pixel(c_ij) is modified to code the pixels that are still ISG and to refine the pixels that became SG in the preceding coding passes. The merged mcode_pixel(c_ij) starts by examining the pixel’s status bit δ_ij. If δ_ij = 0 (i.e., c_ij is yet untested), then c_ij is examined for significance and coded exactly as done in the code_pixel(c_ij). On the other hand, if δ_ij = 1 (i.e., c_ij is found SG at a previous pass), then c_ij is refined as given in the refine_pixel(c_ij). Notice that in the adopted coding method, the pixel may be either SG or ISG. Therefore, one marker bit for δ is sufficient: δ_ij = 0 if c_ij is ISG, and δ_ij = 1 if c_ij is SG. The pseudocodes of the merged mcode_pixel(c_ij) and the merged mdecode_pixel(c_ij) procedures are shown in Figure 4. The same notes of the decoding procedure explained previously apply to mdecode_pixel(c_ij).

Figure 4 The pseudocodes of the merged mcode_pixel(c_ij) and mdecode_pixel(c_ij). 

Compared to the HSLS algorithm, the IHSLS algorithm runs slightly faster because it performs one coding pass per bit-plane instead of two. In addition, it has a slightly lower memory requirement as it uses one bit for δ instead of two. So, the total memory of IHSLS is 1.5 bits per pixel instead of the 2.5 bits per pixel that are required by HSLS. However, the cost of these benefits is a slight decrement in PSNR performance as compared to that of HSLS due to the coding pass merging

3. Results and analysis

The proposed algorithms are implemented using Borland C++ v. 5.02 under Intel μprocessor Core i3 PC with 1.8 GHz CPU, and 2 GB RAM. The popular grayscale test images "Lena," "Barbara," "Goldhill," and "Mandrill" of size (512×512) pixels are used in the simulation. As with other algorithms, the image is transformed by the octave 2D-DWT with 5 decomposition levels using the CDF 9/7 wavelet filter (^{Vetterli, 2001}). The PSNR of the algorithm vs. the bit rate, as well as its computational time vs. the bit rate, are used to represent the results. The bit rate is the average number of bits per pixel (bpp) of the compressed image. The PSNR measures how similar the original and recovered images are. It is defined as (^{Al-Janabi, 2015}):

Where p_max is the maximum pixel value in the original image (p_max = 2⁸ = 255) (for grayscale images), and MSE is the mean-squared error between the original image I_o and the recovered image I_r, given by:

where MN is the image size (the number of image pixels). Obviously, for any bit rate, a higher PSNR value is preferred.

3.1. Performance of the proposed SSPIHT algorithm

Table 1 depicts the PSNR vs. bit rate for the proposed SSPIHT, the original SPIHT, and the MSPIHT algorithm (^{Rema et al., 2015}) which is optimized to improve the PSNR at low bit rates. The PSNR of our SSPIHT algorithm is boldfaced where it is higher than that of MSPIHT. As it is clearly shown, the PSNR of SSPIHT is higher for nearly all images at all bit rates. This means that our SSPIHT performs better than SPIHT and MSPIHT. In addition, as will be seen in the next section, the proposed SSPIHT runs faster than the original SPIHT, and therefore it runs also faster than MSPIHT since the latter two algorithms have nearly the same complexity (^{Rema et al., 2015}). Figure 5 shows the original “Lena” image and the decoded ones at several bit rates using SSPIHT

Table 1 PSNR vs. bit rate for the proposed SSPIHT, SPIHT, and MSPIHT algorithms. 

Bit rate (bpp)	PSNR (dB)
	Lena 512×512			Goldhill 512×512			Barbara 512×512
	SPIHT	MSPIHT	Proposed SSPIHT	SPIHT	MSPIHT	Proposed SSPIHT	SPIHT	MSPIHT	Proposed SSPIHT
0.01	11.88	15.31	21.02	11.32	16.32	21.87	11.56	15.29	19.89
0.03	22.31	23.69	23.44	21.99	23.07	23.65	20.34	21.15	21.58
0.05	25.03	25.70	26.49	24.17	24.66	25.60	21.92	22.18	22.88
0.1	28.44	28.68	28.88	26.30	26.51	27.13	23.39	23.55	24.24
0.2	31.74	31.88	31.94	28.40	28.50	29.16	25.64	25.83	26.34
0.5	36.46	36.52	36.27	31.47	31.52	32.30	30.38	30.46	31.11

Figure 5 Original “Lena” image and decoded at several bit rates using the proposed SSPIHT algorithm. 

4. Conclusions

In this paper, we presented a framework of three related scalable image compression algorithms. As demonstrated within the last section, the SSPIHT algorithm has lower complexity and improved performance than that of the original SPIHT. Additionally, at low bit rates, it provided higher PSNR than that of the MSPIHT algorithm, which is optimized for that purpose. The HSLS algorithm solved the dual problems of SPIHT: the scalability and the massive memory resources without paying any noticeable cost concerning its performance and complexity. In contrast, the HS-SPIHT increased the complexity and the memory while the LHS-SPIHT widely increased the complexity as compared to SPIHT. Moreover, our HSLS algorithm performed better than these algorithms when the image is recovered at reduced resolutions. Finally, the IHSLS algorithm is faster and consumes less memory than that of HSLS. As shown, the only price for these additional advantages is the very slight reduction in PSNR.

Conflict of interest

The authors do not have any type of conflict of interest to declare.

Financing

The authors did not receive any sponsorship to carry out the research reported in the present manuscript.