JPEG Compression

Summary: JPEG compresses images by converting to a perceptual colour space, splitting into 8×8 blocks, applying the discrete-cosine-transform, discarding high-frequency DCT coefficients via quantization, and entropy coding the result.

Overview

JPEG (1992) exploits two properties of human vision:

1. We are more sensitive to luminance (brightness/intensity) than chrominance (colour).
2. We are more sensitive to low spatial frequencies (large shapes) than high frequencies (fine detail).
   1. Refers to how frequently a bit of an image changes in intensity of brightness or colour

The algorithm is lossy: the original pixel values cannot be recovered exactly. Loss is entirely concentrated in the quantization step; all other steps are lossless. Chroma downsampling is optional, and also lossy.

Encoder pipeline

Running dimensionality count (illustrative only)

• Imagine an input image with $100\times 100$ pixels split across 3 channels: $R,G,B\in {\mathbb{R}}^{100\times 100}$
• Matrix entry values for $R$, $G$, and $B$ range between $[0,255]$
• Total: $10,000$ values per channel, $30,000$ total

1. Colour space conversion: RGB → YCbCr

Separate the luminosity (brightness) of an image from the chrominance (colour).

$$\left[\begin{array}{c}Y\\ C_b\\ C_r\end{array}\right]=\left[\begin{array}{ccc}0.299& 0.587& 0.114\\ -0.169& -0.331& 0.500\\ 0.500& -0.419& -0.081\end{array}\right]\left[\begin{array}{c}R\\ G\\ B\end{array}\right]+\left[\begin{array}{c}0\\ 128\\ 128\end{array}\right]$$

• $Y$ = luminance (roughly perceived brightness). Coefficients match the eye’s spectral sensitivity (green dominates).
• $C_b$ and $C_r$ = blue-difference (i.e. blueness) and red-difference (i.e. redness) chroma channels

Images: Colour space conversion (RBG → YCbCr)

Note: To human eyes, luminance is easy to perceive, but both chrominances are difficult to perceive.

Image 1:

Image 2:

Chroma downsampling (optional, also lossy!)

Human eyes are not very sensitive to colour ($C_b$ and $C_r$), compared to brightness ($Y^{\prime }$), so downsample the colour information (i.e. reduce colour resolution):

• 4:4:4 - No downsampling

• 4:2:2 - Downsample $C_b$ and $C_r$ by 2× horizontally only.

• 4:2:0 - Downsample $C_b$ and $C_r$ by 2× horizontally and 2× vertically. 4× reduction in total

  • Four $Y$ pixels share one $C_b$ and one $C_r$ value.
  • This quarters the chroma data with minimal visible impact, halving the total data (~2× compression) before any DCT.

  

Images: Chrominance downsampling (4:2:0)

Note: Chrominance matrices are now a quarter of their original size. Luminance is unchanged.

Image 1:

Image 2:

Dimensionality count (illustrative only)

• After conversion: $Y,C_b,C_r\in {\mathbb{R}}^{100\times 100}$ — same shape, different semantics.
• After 4:2:0 subsampling, $C_b$ and $C_r$ are a quarter of their original sizes:
  • Luminance is unchanged: $Y\in {\mathbb{R}}^{100\times 100}$ (i.e. 10k pixels),
  • But chrominance is reduced: $C_b,C_r\in {\mathbb{R}}^{50\times 50}$ (i.e. 2.5k pixels each).
• Total values: $100^2+2\times 50^2=10,000+5,000=15,000$ — already half the original $30,000$.

2. Block splitting and level shift

For each channel $Y$, $C_b$, and $C_r$

1. Block splitting: Divide the channel ($Y$, $C_b$, and $C_r$) into non-overlapping $8\times 8$ pixel blocks, or sub-images.
2. Level shift: Subtract 128 from each value (shift unsigned $[0,255]$ → signed $[-128,127]$).
   1. This centres the data for DCT: $-128$ is black, $127$ is white. This matches the cosine wave’s interval $[-1,1]$

If the image dimensions are not multiples of 8, pad the edges by repeating the boundary pixels (then discard the padding after decoding).

Visualise matrices: Level shift on one sub-image ( $8\times 8$ pixel block)

$$\underset{\text{8}\times \text{8 sub-image: raw pixel values}\in [0,255]}{\underbrace{\left[\begin{array}{cccccccc}52& 55& 61& 66& 70& 61& 64& 73\\ 63& 59& 55& 90& 109& 85& 69& 72\\ 62& 59& 68& 113& 144& 104& 66& 73\\ 63& 58& 71& 122& 154& 106& 70& 69\\ 67& 61& 68& 104& 126& 88& 68& 70\\ 79& 65& 60& 70& 77& 68& 58& 75\\ 85& 71& 64& 59& 55& 61& 65& 83\\ 87& 79& 69& 68& 65& 76& 78& 94\end{array}\right]}}-128=\begin{array}{c}c⟶\\ \underset{\mathbf{x}\text{: level-shifted values}\in [-128,127]}{\underbrace{\left[\begin{array}{cccccccc}-76& -73& -67& -62& -58& -67& -64& -55\\ -65& -69& -73& -38& -19& -43& -59& -56\\ -66& -69& -60& -15& 16& -24& -62& -55\\ -65& -70& -57& -6& 26& -22& -58& -59\\ -61& -67& -60& -24& -2& -40& -60& -58\\ -49& -63& -68& -58& -51& -60& -70& -53\\ -43& -57& -64& -69& -73& -67& -63& -45\\ -41& -49& -59& -60& -63& -52& -50& -34\end{array}\right]}}\end{array}\downarrow r$$

Running example

• 100 is not a multiple of 8, so pad each dimension to 104 (next multiple of 8).
• $Y\in {\mathbb{R}}^{104\times 104}$, $C_b,C_r\in {\mathbb{R}}^{56\times 56}$ after padding.
  • Block counts: $Y$ gives $13\times 13=169$ blocks; $C_b,C_r$ give $7\times 7=49$ blocks each.
• Total: $169+49+49=267$ blocks, each an $8\times 8$ matrix.

3. 2D DCT per block

Analytic calculation

Apply the 2D DCT-II to each 8×8 block, individually for each channel $Y$, $C_b$, and $C_r$. Element-wise formula:

$$X[k_r,k_c]=\sum _{r=0}^{N-1}\sum _{c=0}^{N-1}x[r,c]\cos \left(\frac{\pi (r+\frac{1}{2})k_r}{N}\right)\cos \left(\frac{\pi (c+\frac{1}{2})k_c}{N}\right)$$

• where:
  • $x[r,c]$: pixel value at row $r$, column $c$ in the level-shifted $8\times 8$ block
  • $X[k_r,k_c]$: DCT coefficient at row frequency $k_r$, column frequency $k_c$
  • $r\in \{0,\dots ,7\}$: spatial row index (vertical)
  • $c\in \{0,\dots ,7\}$: spatial column index (horizontal)
  • $k_r\in \{0,\dots ,7\}$: vertical spatial frequency index
  • $k_c\in \{0,\dots ,7\}$: horizontal spatial frequency index
  • $N=8$: block size
• This is the unnormalized DCT-II (see wikipedia for normalized). The 64 pixel values become 64 DCT coefficients:
  • $X[0,0]$: the DC coefficient — equals 8 times the block mean; corresponds to the flat (constant) basis image
  • $X[k_r,k_c]$ for $k_r+k_c>0$: the 63 AC coefficients — capture spatial frequency content at increasing row and column frequencies

Visualise matrices: 2D DCT on one sub-image ( $8\times 8$ pixel block)

$$\downarrow r\begin{array}{c}c⟶\\ \underset{\mathbf{x}\text{: level-shifted pixel values}\in [-128,127]}{\underbrace{\left[\begin{array}{cccccccc}-76& -73& -67& -62& -58& -67& -64& -55\\ -65& -69& -73& -38& -19& -43& -59& -56\\ -66& -69& -60& -15& 16& -24& -62& -55\\ -65& -70& -57& -6& 26& -22& -58& -59\\ -61& -67& -60& -24& -2& -40& -60& -58\\ -49& -63& -68& -58& -51& -60& -70& -53\\ -43& -57& -64& -69& -73& -67& -63& -45\\ -41& -49& -59& -60& -63& -52& -50& -34\end{array}\right]}}\end{array}\stackrel{\text{2D DCT}}{\to }\downarrow k_r\begin{array}{c}{k}_c⟶\\ \underset{\text{X}\text{: Unquantized DCT coefficients (e.g. luminance channel)}}{\underbrace{\left[\begin{array}{cccccccc}-415.38& -30.19& -61.20& 27.24& 56.12& -20.10& -2.39& 0.46\\ 4.47& -21.86& -60.76& 10.25& 13.15& -7.09& -8.54& 4.88\\ -46.83& 7.37& 77.13& -24.56& -28.91& 9.93& 5.42& -5.65\\ -48.53& 12.07& 34.10& -14.76& -10.24& 6.30& 1.83& 1.95\\ 12.12& -6.55& -13.20& -3.95& -1.87& 1.75& -2.79& 3.14\\ -7.73& 2.91& 2.38& -5.94& -2.38& 0.94& 4.30& 1.85\\ -1.03& 0.18& 0.42& -2.42& -0.88& -3.02& 4.12& -0.66\\ -0.17& 0.14& -1.07& -4.19& -1.17& -0.10& 0.50& 1.68\end{array}\right]}}\end{array}$$

Animation: 64 DCT basis images (64 $8\times 8$ px blocks), used to reconstruct a sub-image ($8\times 8$ px block)

• The 64 DCT basis images (each image is an $8\times 8$ pixel block)

• Animation: Reconstructing a sub-image ($8\times 8$ pixel block), but combining a weighted sum of these basis images:

In-practice, dot product with precomputed basis image blocks

1. In practice, the 64 DCT coefficients are just 64 dot products. Each DCT coefficient $X[k_r,k_c]\in \mathbb{R}$ is the dot product of the pixel block $\mathbf{x}\in {\mathbb{R}}^{8\times 8}$ with the corresponding DCT basis image $B_{k_r,k_c}\in {\mathbb{R}}^{8\times 8}$:

$$X[k_r,k_c]=\sum _{r=0}^7\sum _{c=0}^{7}x[r,c]\cdot B_{k_r,k_c}[r,c]$$

• where $B_{k_r,k_c}[r,c]=\cos \left(\frac{\pi (r+\frac{1}{2})k_r}{N}\right)\cos \left(\frac{\pi (c+\frac{1}{2})k_c}{N}\right)$ is an $8\times 8$ array of cosine values that can be precomputed once.

2. To compute, flatten the $8\times 8$ pixel block into a 64-element vector $\mathbf{x}\in {\mathbb{R}}^{8\times 8}$, and each basis image $B_{k_r,k_c}$ likewise. Then:

$$X[k_r,k_c]=\mathbf{x}\cdot {\mathbf{B}}_{k_r,k_c}$$

• Each DCT coefficient $X[k_r,k_c]$ answers: how much of basis image $B_{k_r,k_c}$ is needed to reconstruct this block $\mathbf{x}$?

3. Concatenate all 64 flattened basis images as rows of a matrix $\mathbf{D}\in {\mathbb{R}}^{64\times 64}$, and the entire DCT becomes one matrix multiply:

$$\mathbf{X}=\mathbf{Dx}$$

• Because the basis images are orthonormal, $\mathbf{D}$ is orthogonal and the inverse DCT is simply ${\mathbf{D}}^{\top }$. In practice, $\mathbf{D}$ is precomputed once — no cosines at runtime.

Intuition (for a smooth pixel block)

• Consider a smooth, medium-gray $8\times 8$ block where all Y values are $130$. After the mandatory $-128$ level shift, all pixel values are $2$.
  • $X[0,0]={\sum }_{r,c}2\cdot 1=64\times 2=128$ — high energy, because the flat basis $B_{0,0}$ is all 1s, so every pixel contributes equally
  • $X[7,7]\approx 0$ — the high-frequency basis $B_{7,7}$ is a cosine product that oscillates rapidly between positive and negative values; for a uniform block these contributions cancel in the dot product

Dimensionality count (illustrative only)

• Each $8\times 8$ pixel block $\to$ $8\times 8$ DCT coefficient matrix. Shape unchanged: 267 blocks, each $\in {\mathbb{R}}^{8\times 8}$.
• $X[0,0]$ (DC) ≈ $8\times$ block mean (typically a large value like 500–900 for bright regions).
• $X[7,7]$ (highest frequency AC) ≈ near zero for any smooth block.

4. Quantization — the lossy step

• Divide each DCT coefficient by a quantization value $Q[k_r,k_c]$ and round to the nearest integer:

$$\hat{X}[k_r,k_c]=\text{round}\left(\frac{X[k_r,k_c]}{Q[k_r,k_c]}\right),\text{for }{k}_r,k_c\in \{0,...,7\}$$

• The JPEG standard defines a quantization table where $Q[k_r,k_c]$ increases with frequency. High-frequency coefficients are divided by large numbers → they round to zero. The low-frequency DC coefficient has a small $Q$ value (precise).
• There are separate tables for luminance ($Y$) and chrominance ($C_b$, $C_r$) — the chroma tables use larger quantization values, again exploiting lower sensitivity.
• JPEG Quality factor $q$ (1–100): Scales the quantization table. At $q=50$, the standard tables are used.
  • Higher quality: At $q>50$: $Q_{\text{scaled}}=Q\cdot (100-q)/50$ (smaller $Q$ entries → finer quantization → less loss).
  • Lower quality: At $q<50$: $Q_{\text{scaled}}=Q\cdot 50/q$ (larger $Q$ entries → more loss).

This division and rounding is the only place information is destroyed. Everything else in the pipeline is exactly reversible.

Visualise matrices: Quantize the luminance ( $Y$) DCT coefs for one sub-image ($8\times 8$ pixel block)

$$\underset{\text{X}\text{: Unquantized DCT coefficients (e.g. luminance channel)}}{\underbrace{\left[\begin{array}{cccccccc}-415.38& -30.19& -61.20& 27.24& 56.12& -20.10& -2.39& 0.46\\ 4.47& -21.86& -60.76& 10.25& 13.15& -7.09& -8.54& 4.88\\ -46.83& 7.37& 77.13& -24.56& -28.91& 9.93& 5.42& -5.65\\ -48.53& 12.07& 34.10& -14.76& -10.24& 6.30& 1.83& 1.95\\ 12.12& -6.55& -13.20& -3.95& -1.87& 1.75& -2.79& 3.14\\ -7.73& 2.91& 2.38& -5.94& -2.38& 0.94& 4.30& 1.85\\ -1.03& 0.18& 0.42& -2.42& -0.88& -3.02& 4.12& -0.66\\ -0.17& 0.14& -1.07& -4.19& -1.17& -0.10& 0.50& 1.68\end{array}\right]}}÷\underset{Q\text{: standard luminance JPEG quantization table }}{\underbrace{\left[\begin{array}{cccccccc}16& 11& 10& 16& 24& 40& 51& 61\\ 12& 12& 14& 19& 26& 58& 60& 55\\ 14& 13& 16& 24& 40& 57& 69& 56\\ 14& 17& 22& 29& 51& 87& 80& 62\\ 18& 22& 37& 56& 68& 109& 103& 77\\ 24& 35& 55& 64& 81& 104& 113& 92\\ 49& 64& 78& 87& 103& 121& 120& 101\\ 72& 92& 95& 98& 112& 100& 103& 99\end{array}\right]}}=\underset{\hat{X}\text{: quantized (rounded) DCT coefficients}}{\underbrace{\left[\begin{array}{cccccccc}-26& -3& -6& 2& 2& -1& 0& 0\\ 0& -2& -4& 1& 1& 0& 0& 0\\ -3& 1& 5& -1& -1& 0& 0& 0\\ -3& 1& 2& -1& 0& 0& 0& 0\\ 1& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 0\end{array}\right]}}$$

• Example: The DC coefficient: $\mathrm{round}\left(\frac{-415.38}{16}\right)=\mathrm{round}(-25.96125)=-26$
• Top left quantized coefficients are much larger. Our eyes perceive low frequency patterns well.
• Bottom right quantized coefficients are smaller. Our eyes dont really perceive high frequency patterns anyway.

Dimensionality count (illustrative only)

• Each coefficient divided and rounded: 267 blocks, each $\in {\mathbb{Z}}^{8\times 8}$.
• At quality 50, typically 40–55 of the 63 AC coefficients per sub-image (pixel block) round to zero
  • the zig-zag tail is a long run of $0$s.

5. Serialization: Zig-zag scan

Reorder the 8×8 quantized coefficient block into a 1D array following a zig-zag path:

Image of serialization path

This orders coefficients from low to high 2D frequency. After quantization, the array typically ends with a long run of zeros (high-frequency coefficients that rounded to zero) — ideal for run-length encoding.

Visualise array of serialised DCT coefficients

• Quantized DCT coefficients, now serialized: ${\hat{X}}_s$.
• This is a 1D array of length 64. The format below is only for ease of understanding:

$$\begin{array}{rrrrrrrr}[-26& & & & & & & \\ -3& 0& & & & & & \\ -3& -2& -6& & & & & \\ 2& -4& 1& -3& & & & \\ 1& 1& 5& 1& 2& & & \\ -1& 1& -1& 2& 0& 0& & \\ 0& 0& 0& -1& -1& 0& 0& \\ 0& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& \\ 0& 0& 0& 0& 0& 0& & \\ 0& 0& 0& 0& 0& & & \\ 0& 0& 0& 0& & & & \\ 0& 0& 0& & & & & \\ 0& 0& & & & & & \\ 0& ]& & & & & & \end{array}$$

Dimensionality count (illustrative only)

• Each $8\times 8$ block $\to$ a length-64 integer vector. Order: DC first, then AC from low to high frequency.
• Typical vector for a smooth $Y$ block: $[482,-3,1,0,0,0,\dots ,0]$ — non-zero values cluster at the start.
• Total: $267\times 64=17,088$ integers, before entropy coding.

6. DC coefficient: delta coding

The DC coefficient of each block (the block mean) changes slowly across the image. Rather than encoding it absolutely, encode the difference from the previous block’s DC:

$${\Delta }_{\text{DC}}=D{C}_{\text{current}}-D{C}_{\text{previous}}$$

This reduces the number of bits needed for smooth images.

Visualise: DC delta coding for our running block

• The quantized DC coefficient of the current block is $\hat{X}[0,0]=-26$.
• Suppose the previous $Y$ block had quantized DC $=-15$, then ${\Delta }_{\text{DC}}=-26-(-15)=-11$.
• $-11$ is encoded instead of $-26$ — smaller magnitude → fewer bits under Huffman.
• For the very first block in a channel, the previous DC is defined as $0$, so the raw DC value is sent directly.

Dimensionality count (illustrative only)

• DC sequences (one value per block, per channel):
  • $Y$: 169 DC values $\to$ 169 deltas, e.g. $[482,-12,3,0,5,\dots ]$
  • $C_b,C_r$: 49 deltas each
• Deltas are small for smooth images, compressing well under Huffman.

7. AC coefficients: Run Length Encoding (RLE)

Encode the remaining 63 AC coefficients (after zig-zag) as the following 2 symbols:

Symbol 1	Symbol 2
(RUNLENGTH, SIZE)	(AMPLITUDE)

• $x$: non-zero, quantized AC coefficient
• Symbol 1 (concatenated and Huffman-coded together):
  • RUNLENGTH: number of zeros preceeding the current coefficient (0–15)
  • SIZE: number of bits required to represent $x$: $\lfloor {\log }_2|\text{AMPLITUDE}|\rfloor +1$
  • Special symbols:
    • (0,0) = end-of-block — no AMPLITUDE follows, all remaining coefficients are zero;
    • (15,0) = zero-run-length marker (ZRL) — 16 consecutive zeros, no AMPLITUDE follows.
• Symbol 2:
  • AMPLITUDE: the actual coefficient value (bit representation of $x$)
    • appended as SIZE raw bits, after Huffman code; not Huffman-coded itself

Visualise: AC RLE for our running block

AC values from the serialized zig-zag array (positions 1–63):

$${\hat{X}}_s=[-3,\underset{1\text{ zero}}{\underbrace{0}},-3,-2,-6,2,-4,1,-3,1,1,5,1,2,-1,1,-1,2,\underset{5\text{ zeros}}{\underbrace{0,0,0,0,0}},-1,-1,\underset{38\text{ zeros}}{\underbrace{0,\dots ,0}}]$$

Encoding each non-zero coefficient, $x$, as (RUNLENGTH, SIZE)(AMPLITUDE), we get the following 20 units which encode all 63 AC values.

• The (RUNLENGTH, SIZE) part is Huffman-coded;
• The AMPLITUDE is appended raw.

(RUNLENGTH, SIZE)	AMPLITUDE	Note
(0, 2)	$-3$	0 preceding zeros; SIZE 2 covers $|x|\in \{2,3\}$
(1, 2)	$-3$	1 zero before this value, SIZE 2 to store it
(0, 2)	$-2$
(0, 3)	$-6$	SIZE 3 covers $|x|\in \{4\dots 7\}$
(0, 2)	$2$
(0, 3)	$-4$
(0, 1)	$1$	SIZE 1 covers $|x|=1$
(0, 2)	$-3$
(0, 1)	$1$
(0, 1)	$1$
(0, 3)	$5$
(0, 1)	$1$
(0, 2)	$2$
(0, 1)	$-1$
(0, 1)	$1$
(0, 1)	$-1$
(0, 2)	$2$
(5, 1)	$-1$	5 zeros before this value
(0, 1)	$-1$
(0, 0)	—	EOB: 38 trailing zeros collapsed to one symbol

Dimensionality count (illustrative only)

• A $Y$ block with zig-zag AC values $[-3,1,0,0,0,\dots ,0]$ (60 trailing zeros) encodes as:
• $(0,2)(-3),(0,1)(1),\underset{\text{EOB}}{\underbrace{(0,0)}}$ — 3 units instead of 63 values.
• The end-of-block symbol is the key savings: any block with a long zero tail gets a single terminator.

8. Huffman coding

Encode the (RUNLENGTH, SIZE) and ${\Delta }_{\text{DC}}$ symbols using Huffman codes. The JPEG standard defines default Huffman tables (alternatively, the encoder can derive optimal tables from the image — “optimised Huffman”). The Huffman coder is lossless: it assigns shorter bit sequences to more frequent symbols.

The output is a compressed bitstream with a JPEG File Interchange Format (JFIF/EXIF) header describing the tables used. JFIF is a wrapper holding the compressed data.

Dimensionality count — final tally

Stage	Data size
Raw RGB pixels	$30,000$ values × 8 bits = 240 kbits
After 4:2:0	$15,000$ values × 8 bits = 120 kbits
After DCT + quantization (quality 50)	$267\times \sim 12$ non-zero coefficients × ~4 bits avg ≈ ~51 kbits
After Huffman	typically ~45–60 kbits for a photographic image

Compression ratio: roughly 4:1 at quality 50 for this 100×100 example.

Decoder pipeline

Exactly reverse:

1. Huffman decode → RLE symbols → AC + DC coefficients
2. Zig-zag inverse → 8×8 coefficient matrix
3. Dequantize: multiply by $Q[k_r,k_c]$
4. Inverse 2D DCT → pixel block
5. Add 128 (undo level shift)
6. Upsample chroma channels (bilinear or nearest)
7. YCbCr → RGB

The dequantization step cannot recover the lost precision — if $X[7,7]/Q[7,7]$ rounded to 0, multiplying 0 back by $Q[7,7]$ gives 0, not the original value.

Compression artefacts

Blocking: At low quality, quantization introduces large differences between adjacent blocks. Since DCT is applied independently per block, there is no information across block boundaries → visible 8×8 grid pattern.

Ringing (Gibbs phenomenon): Near sharp edges, the DCT is being asked to represent a discontinuity with a truncated frequency series. This causes oscillation on both sides of the edge, similar to the Gibbs phenomenon in Fourier series.

Colour bleeding: Chroma subsampling plus low-quality chrominance DCT causes colour to bleed across sharp luminance edges.

Typical compression ratios

Quality	Ratio	Use case
95	~3:1	Archival, print
80	~8:1	Web photos
60	~15:1	Thumbnails
30	~30:1	Preview images

JPEG is poorly suited for graphics with sharp edges, text, or flat colour regions — PNG (lossless) is better there. JPEG excels at photographic images where high-frequency DCT coefficients are genuinely small.

Sources

• Direct source: The Ultimate Guide to JPEG including JPEG Compression
• Branch Education: How are Images Compressed? [46MB ↘↘ 4.07MB] JPEG In Depth
• Computerphile:
  • Colourspaces (JPEG Pt0)
  • JPEG ‘files’ & Colour (JPEG Pt1)
  • JPEG DCT, Discrete Cosine Transform (JPEG Pt2)
  • How Huffman Trees Work