mirror of
https://github.com/odin-lang/Odin.git
synced 2026-04-19 21:10:30 +00:00
1097 lines
32 KiB
Odin
1097 lines
32 KiB
Odin
// Reader for baseline `JPEG` images.
|
|
package jpeg
|
|
|
|
import "core:bytes"
|
|
import "core:compress"
|
|
import "core:math"
|
|
import "core:mem"
|
|
import "core:image"
|
|
import "core:slice"
|
|
import "core:strings"
|
|
|
|
Image :: image.Image
|
|
Error :: image.Error
|
|
Options :: image.Options
|
|
|
|
HUFFMAN_MAX_SYMBOLS :: 176
|
|
HUFFMAN_MAX_BITS :: 16
|
|
// 768 bytes of 24-bit RGB values.
|
|
THUMBNAIL_PALETTE_SIZE :: 768
|
|
BLOCK_SIZE :: 8
|
|
COEFFICIENT_COUNT :: BLOCK_SIZE * BLOCK_SIZE
|
|
SEGMENT_MAX_SIZE :: 65533
|
|
|
|
Coefficient :: enum u8 {
|
|
DC,
|
|
AC,
|
|
}
|
|
|
|
Component :: enum u8 {
|
|
Y = 1,
|
|
Cb = 2,
|
|
Cr = 3,
|
|
}
|
|
|
|
Huffman_Table :: struct {
|
|
symbols: [HUFFMAN_MAX_SYMBOLS]byte,
|
|
codes: [HUFFMAN_MAX_SYMBOLS]u32,
|
|
offsets: [HUFFMAN_MAX_BITS + 1]byte,
|
|
}
|
|
|
|
Quantization_Table :: [COEFFICIENT_COUNT]u16be
|
|
|
|
Color_Component :: struct {
|
|
dc_table_idx: u8,
|
|
ac_table_idx: u8,
|
|
quantization_table_idx: u8,
|
|
v_sampling_factor: int,
|
|
h_sampling_factor: int,
|
|
}
|
|
|
|
// 8x8 block of pixels
|
|
Block :: [Component][COEFFICIENT_COUNT]i16
|
|
|
|
@(private="file")
|
|
zigzag := [?]byte{
|
|
0, 1, 8, 16, 9, 2, 3, 10,
|
|
17, 24, 32, 25, 18, 11, 4, 5,
|
|
12, 19, 26, 33, 40, 48, 41, 34,
|
|
27, 20, 13, 6, 7, 14, 21, 28,
|
|
35, 42, 49, 56, 57, 50, 43, 36,
|
|
29, 22, 15, 23, 30, 37, 44, 51,
|
|
58, 59, 52, 45, 38, 31, 39, 46,
|
|
53, 60, 61, 54, 47, 55, 62, 63,
|
|
}
|
|
|
|
@(optimization_mode="favor_size", private="file")
|
|
refill_msb :: #force_inline proc(z: ^compress.Context_Memory_Input, width := i8(48)) {
|
|
refill := u64(width)
|
|
b := u64(0)
|
|
|
|
if z.num_bits > refill {
|
|
return
|
|
}
|
|
|
|
for {
|
|
if len(z.input_data) != 0 {
|
|
b = u64(z.input_data[0])
|
|
|
|
if len(z.input_data) > 1 && b == 0xFF {
|
|
next := u64(z.input_data[1])
|
|
|
|
if next == 0x00 {
|
|
// 0x00 is used as a stuffing to indicate that the 0xFF is part of the data and not
|
|
// the beginning of a marker
|
|
z.input_data = z.input_data[2:]
|
|
} else if next >= cast(u64)image.JPEG_Marker.RST0 && next <= cast(u64)image.JPEG_Marker.RST7 {
|
|
// Skip any RSTn markers if we encounter them
|
|
if len(z.input_data) > 2 {
|
|
b = u64(z.input_data[2])
|
|
z.input_data = z.input_data[3:]
|
|
} else {
|
|
b = 0
|
|
}
|
|
}
|
|
} else {
|
|
z.input_data = z.input_data[1:]
|
|
}
|
|
} else {
|
|
b = 0
|
|
}
|
|
|
|
z.code_buffer |= ((b << 56) >> u8(z.num_bits))
|
|
z.num_bits += 8
|
|
if z.num_bits > refill {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
@(optimization_mode="favor_size", private="file")
|
|
consume_bits_msb :: #force_inline proc(z: ^compress.Context_Memory_Input, width: u8) {
|
|
z.code_buffer <<= width
|
|
z.num_bits -= u64(width)
|
|
}
|
|
|
|
@(private="file")
|
|
byte_align :: #force_inline proc(z: ^compress.Context_Memory_Input) {
|
|
skip := z.num_bits % 8
|
|
consume_bits_msb(z, cast(u8)skip)
|
|
}
|
|
|
|
@(optimization_mode="favor_size", private="file")
|
|
peek_bits_msb :: #force_inline proc(z: ^compress.Context_Memory_Input, width: u8) -> u32 {
|
|
if z.num_bits < u64(width) {
|
|
refill_msb(z)
|
|
}
|
|
return u32((z.code_buffer &~ (max(u64) >> width)) >> (64 - width))
|
|
}
|
|
|
|
@(optimization_mode="favor_size", private="file")
|
|
read_bits_msb :: #force_inline proc(z: ^compress.Context_Memory_Input, width: u8) -> u32 {
|
|
k := #force_inline peek_bits_msb(z, width)
|
|
#force_inline consume_bits_msb(z, width)
|
|
return k
|
|
}
|
|
|
|
load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {
|
|
ctx := &compress.Context_Memory_Input{
|
|
input_data = data,
|
|
}
|
|
|
|
img, err = load_from_context(ctx, options, allocator)
|
|
return img, err
|
|
}
|
|
|
|
@(private="file")
|
|
get_symbol :: proc(ctx: ^$C, huffman_table: Huffman_Table) -> byte {
|
|
possible_code: u32 = 0
|
|
|
|
for i in 0..<HUFFMAN_MAX_BITS {
|
|
bit := read_bits_msb(ctx, 1)
|
|
possible_code = (possible_code << 1) | bit
|
|
|
|
for j := huffman_table.offsets[i]; j < huffman_table.offsets[i + 1]; j += 1 {
|
|
if possible_code == huffman_table.codes[j] {
|
|
return huffman_table.symbols[j]
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {
|
|
context.allocator = allocator
|
|
options := options
|
|
|
|
// Precalculate IDCT scaling factors
|
|
m0 := 2.0 * math.cos_f32(1.0 / 16.0 * 2.0 * math.PI)
|
|
m1 := 2.0 * math.cos_f32(2.0 / 16.0 * 2.0 * math.PI)
|
|
m3 := 2.0 * math.cos_f32(2.0 / 16.0 * 2.0 * math.PI)
|
|
m5 := 2.0 * math.cos_f32(3.0 / 16.0 * 2.0 * math.PI)
|
|
m2 := m0 - m5
|
|
m4 := m0 + m5
|
|
|
|
s0 := math.cos_f32(0.0 / 16.0 * math.PI) / math.sqrt_f32(8.0)
|
|
s1 := math.cos_f32(1.0 / 16.0 * math.PI) / 2.0
|
|
s2 := math.cos_f32(2.0 / 16.0 * math.PI) / 2.0
|
|
s3 := math.cos_f32(3.0 / 16.0 * math.PI) / 2.0
|
|
s4 := math.cos_f32(4.0 / 16.0 * math.PI) / 2.0
|
|
s5 := math.cos_f32(5.0 / 16.0 * math.PI) / 2.0
|
|
s6 := math.cos_f32(6.0 / 16.0 * math.PI) / 2.0
|
|
s7 := math.cos_f32(7.0 / 16.0 * math.PI) / 2.0
|
|
|
|
if .info in options {
|
|
options += {.return_metadata, .do_not_decompress_image}
|
|
options -= {.info}
|
|
}
|
|
|
|
if .return_header in options && .return_metadata in options {
|
|
options -= {.return_header}
|
|
}
|
|
|
|
if .do_not_expand_channels in options || .do_not_expand_grayscale in options {
|
|
return img, .Unsupported_Option
|
|
}
|
|
|
|
first := compress.read_u8(ctx) or_return
|
|
soi := cast(image.JPEG_Marker)compress.read_u8(ctx) or_return
|
|
if first != 0xFF && soi != .SOI {
|
|
return img, .Invalid_Signature
|
|
}
|
|
|
|
img = new(Image) or_return
|
|
img.which = .JPEG
|
|
|
|
expect_EOI := false
|
|
zero_based_components := false
|
|
huffman: [Coefficient][4]Huffman_Table
|
|
quantization: [4]Quantization_Table
|
|
color_components: [Component]Color_Component
|
|
restart_interval: int
|
|
// Image width and height in MCUs
|
|
mcu_width: int
|
|
mcu_height: int
|
|
// Image width and height in blocks
|
|
block_width: int
|
|
block_height: int
|
|
blocks: []Block
|
|
defer delete(blocks)
|
|
|
|
loop: for {
|
|
// Loop until we find 0xFF.
|
|
first = compress.read_u8(ctx) or_return
|
|
(first == 0xFF) or_continue
|
|
|
|
marker := cast(image.JPEG_Marker)compress.read_u8(ctx) or_return
|
|
if expect_EOI && marker != .EOI {
|
|
return img, .Extra_Data_After_SOS
|
|
}
|
|
#partial switch marker {
|
|
case cast(image.JPEG_Marker)0xFF:
|
|
// If we encounter multiple FF bytes then just skip them
|
|
continue
|
|
case .SOI:
|
|
return img, .Duplicate_SOI_Marker
|
|
case .APP0:
|
|
ident := make([dynamic]byte, 0, 16, context.temp_allocator) or_return
|
|
length := cast(int)((compress.read_data(ctx, u16be) or_return) - 2)
|
|
for {
|
|
b := compress.read_u8(ctx) or_return
|
|
if b == 0x00 {
|
|
break
|
|
}
|
|
append(&ident, b) or_return
|
|
}
|
|
if slice.equal(ident[:], image.JFIF_Magic[:]) {
|
|
if length != 14 {
|
|
// Malformed APP0. Skip it
|
|
compress.read_slice(ctx, length - len(ident) - 1) or_return
|
|
continue
|
|
}
|
|
|
|
version := compress.read_data(ctx, u16be) or_return
|
|
units := cast(image.JFIF_Unit)(compress.read_u8(ctx) or_return)
|
|
x_density := compress.read_data(ctx, u16be) or_return
|
|
y_density := compress.read_data(ctx, u16be) or_return
|
|
x_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
y_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
thumbnail: []image.RGB_Pixel
|
|
|
|
if x_thumbnail * y_thumbnail != 0 {
|
|
greyscale_thumbnail := false
|
|
thumbnail_size := x_thumbnail * y_thumbnail * 3
|
|
// According to the JFIF spec, the thumbnail should always be made of RGB pixels.
|
|
// But some jpegs encode single-channel thumbnails.
|
|
if thumbnail_size != length - 14 && thumbnail_size / 3 == length - 14 {
|
|
thumbnail_size = x_thumbnail * y_thumbnail
|
|
greyscale_thumbnail = true
|
|
} else {
|
|
return img, .Invalid_Thumbnail_Size
|
|
}
|
|
thumb_pixels := slice.reinterpret([]image.RGB_Pixel, compress.read_slice_from_memory(ctx, x_thumbnail * y_thumbnail) or_return)
|
|
|
|
if .return_metadata in options {
|
|
thumbnail = make([]image.RGB_Pixel, x_thumbnail * y_thumbnail) or_return
|
|
copy(thumbnail, thumb_pixels)
|
|
|
|
info: ^image.JPEG_Info
|
|
if img.metadata == nil {
|
|
info = new(image.JPEG_Info) or_return
|
|
} else {
|
|
info = img.metadata.(^image.JPEG_Info)
|
|
}
|
|
info.jfif_app0 = image.JFIF_APP0{
|
|
version,
|
|
x_density,
|
|
y_density,
|
|
units,
|
|
cast(u8)x_thumbnail,
|
|
cast(u8)y_thumbnail,
|
|
greyscale_thumbnail,
|
|
thumbnail,
|
|
}
|
|
img.metadata = info
|
|
}
|
|
}
|
|
} else if slice.equal(ident[:], image.JFXX_Magic[:]) {
|
|
extension_code := cast(image.JFXX_Extension_Code)compress.read_u8(ctx) or_return
|
|
thumbnail: []byte
|
|
|
|
switch extension_code {
|
|
// We return the JPEG-compressed bytes for this type of thumbnail.
|
|
// It's up to the user if they want to decode it by checking the extension code
|
|
// and calling image.load() on the thumbnail.
|
|
// Not sure where to document that though, maybe it's better if the thumbnail is always raw pixel data.
|
|
case .Thumbnail_JPEG:
|
|
// +1 for the NUL byte
|
|
thumbnail_len := length - (size_of(image.JFXX_Magic) + 1 + size_of(image.JFXX_Extension_Code))
|
|
thumbnail_jpeg := compress.read_slice(ctx, thumbnail_len) or_return
|
|
|
|
if .return_metadata in options {
|
|
thumbnail = make([]byte, thumbnail_len) or_return
|
|
copy(thumbnail, thumbnail_jpeg)
|
|
|
|
info: ^image.JPEG_Info
|
|
if img.metadata == nil {
|
|
info = new(image.JPEG_Info) or_return
|
|
} else {
|
|
info = img.metadata.(^image.JPEG_Info)
|
|
}
|
|
info.jfxx_app0 = image.JFXX_APP0{
|
|
extension_code,
|
|
0,
|
|
0,
|
|
thumbnail,
|
|
}
|
|
img.metadata = info
|
|
}
|
|
case .Thumbnail_3_Byte_RGB:
|
|
x_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
y_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
pixels := compress.read_slice(ctx, x_thumbnail * y_thumbnail * 3) or_return
|
|
|
|
if .return_metadata in options {
|
|
thumbnail = make([]byte, x_thumbnail * y_thumbnail * 3) or_return
|
|
copy(thumbnail, pixels)
|
|
|
|
info: ^image.JPEG_Info
|
|
if img.metadata == nil {
|
|
info = new(image.JPEG_Info) or_return
|
|
} else {
|
|
info = img.metadata.(^image.JPEG_Info)
|
|
}
|
|
info.jfxx_app0 = image.JFXX_APP0{
|
|
extension_code,
|
|
cast(u8)x_thumbnail,
|
|
cast(u8)y_thumbnail,
|
|
thumbnail,
|
|
}
|
|
img.metadata = info
|
|
}
|
|
case .Thumbnail_1_Byte_Palette: // NOTE(illusionman1212): NOT TESTED. Couldn't find a jpeg to test this with.
|
|
x_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
y_thumbnail := cast(int)compress.read_u8(ctx) or_return
|
|
palette := slice.reinterpret([]image.RGB_Pixel, compress.read_slice(ctx, THUMBNAIL_PALETTE_SIZE / 3) or_return)
|
|
old_pixels := compress.read_slice(ctx, x_thumbnail * y_thumbnail) or_return
|
|
|
|
if .return_metadata in options {
|
|
pixels := make([]byte, x_thumbnail * y_thumbnail * 3) or_return
|
|
for i in 0..<x_thumbnail*y_thumbnail {
|
|
pixel := palette[old_pixels[i]]
|
|
pixels[i] = pixel.r
|
|
pixels[i + 1] = pixel.g
|
|
pixels[i + 2] = pixel.b
|
|
}
|
|
|
|
info: ^image.JPEG_Info
|
|
if img.metadata == nil {
|
|
info = new(image.JPEG_Info) or_return
|
|
} else {
|
|
info = img.metadata.(^image.JPEG_Info)
|
|
}
|
|
info.jfxx_app0 = image.JFXX_APP0{
|
|
extension_code,
|
|
cast(u8)x_thumbnail,
|
|
cast(u8)y_thumbnail,
|
|
pixels,
|
|
}
|
|
img.metadata = info
|
|
}
|
|
case:
|
|
return img, .Invalid_JFXX_Extension_Code
|
|
}
|
|
} else {
|
|
// - 1 for the NUL byte
|
|
compress.read_slice(ctx, length - len(ident) - 1) or_return
|
|
continue
|
|
}
|
|
case .APP1: // Metadata
|
|
length := cast(int)((compress.read_data(ctx, u16be) or_return) - 2)
|
|
if .return_metadata not_in options {
|
|
compress.read_slice(ctx, length) or_return
|
|
continue
|
|
}
|
|
info: ^image.JPEG_Info
|
|
if img.metadata == nil {
|
|
info = new(image.JPEG_Info) or_return
|
|
} else {
|
|
info = img.metadata.(^image.JPEG_Info)
|
|
}
|
|
|
|
ident := make([dynamic]byte, 0, 16, context.temp_allocator) or_return
|
|
for {
|
|
b := compress.read_u8(ctx) or_return
|
|
if b == 0x00 {
|
|
break
|
|
}
|
|
append(&ident, b) or_return
|
|
}
|
|
|
|
if slice.equal(ident[:], image.Exif_Magic[:]) {
|
|
// Padding byte according to section 4.7.2.2 in Exif spec 3.0
|
|
compress.read_u8(ctx) or_return
|
|
|
|
exif: image.Exif
|
|
peek := compress.peek_data(ctx, [4]byte) or_return
|
|
if peek[0] == 'M' && peek[1] == 'M' {
|
|
exif.byte_order = .big_endian
|
|
if peek[2] != 0 || peek[3] != 42 {
|
|
// - 2 for the NUL byte and padding byte
|
|
compress.read_slice(ctx, length - len(ident) - 2) or_return
|
|
continue
|
|
}
|
|
} else if peek[0] == 'I' && peek[1] == 'I' {
|
|
exif.byte_order = .little_endian
|
|
if peek[2] != 42 || peek[3] != 0 {
|
|
compress.read_slice(ctx, length - len(ident) - 2) or_return
|
|
continue
|
|
}
|
|
} else {
|
|
// If we can't determine the endianness then this Exif data is likely a continuation of the previous
|
|
// APP1 Exif data
|
|
|
|
// We only treat it as such if a previous Exif entry exists and its data length is the max
|
|
if len(info.exif) > 0 && len(info.exif[len(info.exif) - 1].data) == SEGMENT_MAX_SIZE - len(ident) - 2 {
|
|
exif.byte_order = info.exif[len(info.exif) - 1].byte_order
|
|
} else {
|
|
compress.read_slice(ctx, length - len(ident) - 2) or_return
|
|
continue
|
|
}
|
|
}
|
|
|
|
// - 2 for the NUL byte and padding byte
|
|
data := compress.read_slice(ctx, length - len(ident) - 2) or_return
|
|
exif.data = make([]byte, len(data)) or_return
|
|
copy(exif.data, data)
|
|
|
|
append(&info.exif, exif) or_return
|
|
img.metadata = info
|
|
} else {
|
|
// - 1 for the NUL byte
|
|
compress.read_slice(ctx, length - len(ident) - 1) or_return
|
|
continue
|
|
}
|
|
case .COM:
|
|
length := (compress.read_data(ctx, u16be) or_return) - 2
|
|
comment := string(compress.read_slice(ctx, cast(int)length) or_return)
|
|
if .return_metadata in options {
|
|
if info, ok := img.metadata.(^image.JPEG_Info); ok {
|
|
append(&info.comments, strings.clone(comment)) or_return
|
|
}
|
|
}
|
|
case .DQT:
|
|
length := cast(int)(compress.read_data(ctx, u16be) or_return) - 2
|
|
|
|
for length > 0 {
|
|
precision_and_index := compress.read_u8(ctx) or_return
|
|
precision := precision_and_index >> 4
|
|
index := precision_and_index & 0xF
|
|
|
|
if precision != 0 && precision != 1 {
|
|
return img, .Invalid_Quantization_Table_Precision
|
|
}
|
|
|
|
if index < 0 || index > 3 {
|
|
return img, .Invalid_Quantization_Table_Index
|
|
}
|
|
|
|
// When precision is 0, we read 64 u8s.
|
|
// when it's 1, we read 64 u16s.
|
|
table_bytes := 64
|
|
if precision == 1 {
|
|
table_bytes = 128
|
|
table := compress.read_slice(ctx, table_bytes) or_return
|
|
for v, i in slice.reinterpret([]u16be, table) {
|
|
quantization[index][i] = v
|
|
}
|
|
} else {
|
|
table := compress.read_slice(ctx, table_bytes) or_return
|
|
for v, i in table {
|
|
quantization[index][i] = cast(u16be)v
|
|
}
|
|
}
|
|
|
|
length -= table_bytes + 1
|
|
}
|
|
case .DHT:
|
|
length := (compress.read_data(ctx, u16be) or_return) - 2
|
|
|
|
for length > 0 {
|
|
type_index := compress.read_u8(ctx) or_return
|
|
type := cast(Coefficient)((type_index >> 4) & 0xF)
|
|
index := type_index & 0xF
|
|
|
|
if type != .DC && type != .AC {
|
|
return img, .Invalid_Huffman_Coefficient_Type
|
|
}
|
|
|
|
if index < 0 || index > 3 {
|
|
return img, .Invalid_Huffman_Table_Index
|
|
}
|
|
|
|
lengths := compress.read_slice(ctx, HUFFMAN_MAX_BITS) or_return
|
|
num_symbols: u8 = 0
|
|
for length, i in lengths {
|
|
num_symbols += length
|
|
huffman[type][index].offsets[i + 1] = num_symbols
|
|
}
|
|
|
|
if num_symbols > HUFFMAN_MAX_SYMBOLS {
|
|
return img, .Huffman_Symbols_Exceeds_Max
|
|
}
|
|
|
|
symbols := compress.read_slice(ctx, cast(int)num_symbols) or_return
|
|
copy(huffman[type][index].symbols[:], symbols)
|
|
|
|
length -= cast(u16be)(1 + HUFFMAN_MAX_BITS + num_symbols)
|
|
|
|
code: u32 = 0
|
|
for i in 0..<HUFFMAN_MAX_BITS {
|
|
for j := huffman[type][index].offsets[i]; j < huffman[type][index].offsets[i + 1]; j += 1 {
|
|
huffman[type][index].codes[j] = code
|
|
code += 1
|
|
}
|
|
code <<= 1
|
|
}
|
|
}
|
|
case .EOI:
|
|
break loop
|
|
case .DRI:
|
|
// Length
|
|
compress.read_data(ctx, u16be) or_return
|
|
restart_interval = cast(int)compress.read_data(ctx, u16be) or_return
|
|
case .RST0..=.RST7: // Handled by the bit reader. These shouldn't appear outside the entropy coded stream.
|
|
return img, .Encountered_RST_Marker_Outside_ECS
|
|
case .SOF0, .SOF1: // Baseline sequential DCT, and extended sequential DCT
|
|
if img.channels != 0 {
|
|
return img, .Multiple_SOS_Markers
|
|
}
|
|
|
|
// Length
|
|
compress.read_data(ctx, u16be) or_return
|
|
precision := compress.read_u8(ctx) or_return
|
|
height := compress.read_data(ctx, u16be) or_return
|
|
width := compress.read_data(ctx, u16be) or_return
|
|
components := compress.read_u8(ctx) or_return
|
|
img.width = cast(int)width
|
|
img.height = cast(int)height
|
|
img.depth = cast(int)precision
|
|
img.channels = cast(int)components
|
|
|
|
// TODO: 12-bit precision is valid too but we don't support it.
|
|
if precision == 12 {
|
|
return img, .Unsupported_12_Bit_Depth
|
|
}
|
|
if precision != 8 {
|
|
return img, .Invalid_Frame_Bit_Depth_Combo
|
|
}
|
|
|
|
// TODO: spec allows for the height to be 0 on the condition that a DNL marker MUST exist to define
|
|
// how many lines in the frame we have.
|
|
// ISO/IEC 10918-1: 1993.
|
|
// Section B.2.5
|
|
if img.width == 0 || img.height == 0 {
|
|
return img, .Invalid_Image_Dimensions
|
|
}
|
|
|
|
if u128(img.width) * u128(img.height) > image.MAX_DIMENSIONS {
|
|
return img, .Image_Dimensions_Too_Large
|
|
}
|
|
|
|
// TODO: Some JPEGs use CMYK as the color model which means there will be 4 components
|
|
if components != 1 && components != 3 {
|
|
return img, .Invalid_Number_Of_Channels
|
|
}
|
|
|
|
if img.metadata != nil {
|
|
info := img.metadata.(^image.JPEG_Info)
|
|
info.frame_type = marker
|
|
}
|
|
|
|
mcu_width = (img.width + 7) / BLOCK_SIZE
|
|
mcu_height = (img.height + 7) / BLOCK_SIZE
|
|
block_width = mcu_width
|
|
block_height = mcu_height
|
|
|
|
for _ in 0..<components {
|
|
id := cast(Component)compress.read_u8(ctx) or_return
|
|
|
|
if id == Component(0) {
|
|
zero_based_components = true
|
|
}
|
|
|
|
if zero_based_components {
|
|
id += Component(1)
|
|
}
|
|
|
|
// TODO: while others that use CMYK have these IDs 67, 77, 89, 75 which are CMYK in ASCII
|
|
// TODO: even more weird ids. 82, 71, 66 which is RGB in ASCII
|
|
if id < .Y || id > .Cr {
|
|
return img, .Image_Does_Not_Adhere_to_Spec
|
|
}
|
|
|
|
h_v_factors := compress.read_u8(ctx) or_return
|
|
horizontal_sampling := h_v_factors >> 4
|
|
vertical_sampling := h_v_factors & 0xF
|
|
|
|
// TODO: spec says the range for the sampling factors is 1-4
|
|
// We only support 1,2 for now.
|
|
if horizontal_sampling < 1 || horizontal_sampling > 2 {
|
|
return img, .Invalid_Sampling_Factor
|
|
}
|
|
if vertical_sampling < 1 || vertical_sampling > 2 {
|
|
return img, .Invalid_Sampling_Factor
|
|
}
|
|
|
|
if id == .Y {
|
|
if horizontal_sampling == 2 && mcu_width % 2 == 1 {
|
|
block_width += 1
|
|
}
|
|
if vertical_sampling == 2 && mcu_height % 2 == 1 {
|
|
block_height += 1
|
|
}
|
|
} else {
|
|
if horizontal_sampling != 1 && vertical_sampling != 1 {
|
|
return img, .Invalid_Sampling_Factor
|
|
}
|
|
}
|
|
|
|
quantization_table_idx := compress.read_u8(ctx) or_return
|
|
|
|
if quantization_table_idx < 0 || quantization_table_idx > 3 {
|
|
return img, .Invalid_Quantization_Table_Index
|
|
}
|
|
|
|
color_components[id].quantization_table_idx = quantization_table_idx
|
|
color_components[id].v_sampling_factor = cast(int)vertical_sampling
|
|
color_components[id].h_sampling_factor = cast(int)horizontal_sampling
|
|
}
|
|
case .SOF2, // Progressive DCT
|
|
.SOF3, // Lossless (sequential)
|
|
.SOF5, // Differential sequential DCT
|
|
.SOF6, // Differential progressive DCT
|
|
.SOF7, // Differential lossless (sequential)
|
|
.SOF9, // Extended sequential DCT, Arithmetic coding
|
|
.SOF10, // Progressive DCT, Arithmetic coding
|
|
.SOF11, // Lossless (sequential), Arithmetic coding
|
|
.SOF13, // Differential sequential DCT, Arithmetic coding
|
|
.SOF14, // Differential progressive DCT, Arithmetic coding
|
|
.SOF15: // Differential lossless (sequential), Arithmetic coding
|
|
if img.metadata != nil {
|
|
info := img.metadata.(^image.JPEG_Info)
|
|
info.frame_type = marker
|
|
}
|
|
return img, .Unsupported_Frame_Type
|
|
case .SOS:
|
|
if img.channels == 0 && img.depth == 0 && img.width == 0 && img.height == 0 {
|
|
return img, .Encountered_SOS_Before_SOF
|
|
}
|
|
|
|
if .do_not_decompress_image in options {
|
|
return img, nil
|
|
}
|
|
|
|
// Length
|
|
compress.read_data(ctx, u16be) or_return
|
|
num_components := compress.read_u8(ctx) or_return
|
|
if num_components != 1 && num_components != 3 {
|
|
return img, .Invalid_Number_Of_Channels
|
|
}
|
|
|
|
for _ in 0..<num_components {
|
|
component_id := cast(Component)compress.read_u8(ctx) or_return
|
|
if zero_based_components {
|
|
component_id += Component(1)
|
|
}
|
|
if component_id < .Y || component_id > .Cr {
|
|
return img, .Image_Does_Not_Adhere_to_Spec
|
|
}
|
|
|
|
// high 4 is DC, low 4 is AC
|
|
coefficient_indices := compress.read_u8(ctx) or_return
|
|
dc_table_idx := coefficient_indices >> 4
|
|
ac_table_idx := coefficient_indices & 0xF
|
|
|
|
if (dc_table_idx < 0 || dc_table_idx > 3) || (ac_table_idx < 0 || ac_table_idx > 3) {
|
|
return img, .Invalid_Huffman_Table_Index
|
|
}
|
|
|
|
color_components[component_id].dc_table_idx = dc_table_idx
|
|
color_components[component_id].ac_table_idx = ac_table_idx
|
|
}
|
|
// TODO: These aren't used for sequential DCT, only progressive and lossless.
|
|
Ss := compress.read_u8(ctx) or_return
|
|
_ = Ss
|
|
Se := compress.read_u8(ctx) or_return
|
|
_ = Se
|
|
Ah_Al := compress.read_u8(ctx) or_return
|
|
_ = Ah_Al
|
|
|
|
blocks = make([]Block, block_height * block_width) or_return
|
|
|
|
previous_dc: [Component]i16
|
|
|
|
luma_v_sampling_factor := color_components[.Y].v_sampling_factor
|
|
luma_h_sampling_factor := color_components[.Y].h_sampling_factor
|
|
|
|
restart_interval *= luma_v_sampling_factor * luma_h_sampling_factor
|
|
#no_bounds_check for y := 0; y < mcu_height; y += luma_v_sampling_factor {
|
|
for x := 0; x < mcu_width; x += luma_h_sampling_factor {
|
|
blk := y * block_width + x
|
|
|
|
if restart_interval != 0 && blk % restart_interval == 0 {
|
|
previous_dc[.Y] = 0
|
|
previous_dc[.Cb] = 0
|
|
previous_dc[.Cr] = 0
|
|
byte_align(ctx)
|
|
}
|
|
for c in 1..=img.channels {
|
|
c := cast(Component)c
|
|
for v in 0..<color_components[c].v_sampling_factor {
|
|
h_loop:
|
|
for h in 0..<color_components[c].h_sampling_factor {
|
|
mcu := &blocks[(y + v) * block_width + (h + x)][c]
|
|
dc_table := huffman[.DC][color_components[c].dc_table_idx]
|
|
ac_table := huffman[.AC][color_components[c].ac_table_idx]
|
|
quantization_table := quantization[color_components[c].quantization_table_idx]
|
|
|
|
length := get_symbol(ctx, dc_table)
|
|
|
|
if length > 11 {
|
|
return img, .Corrupt
|
|
}
|
|
|
|
dc_coeff := cast(i16)read_bits_msb(ctx, length)
|
|
|
|
if length != 0 && dc_coeff < (1 << (length - 1)) {
|
|
dc_coeff -= (1 << length) - 1
|
|
}
|
|
mcu[0] = (dc_coeff + previous_dc[c]) * cast(i16)quantization_table[0]
|
|
previous_dc[c] = dc_coeff + previous_dc[c]
|
|
|
|
for i := 1; i < COEFFICIENT_COUNT; i += 1 {
|
|
// High nibble is amount of 0s to skip.
|
|
// Low nibble is length of coeff.
|
|
symbol := get_symbol(ctx, ac_table)
|
|
|
|
// Special symbol used to indicate
|
|
// that the rest of the MCU is filled with 0s
|
|
if symbol == 0x00 {
|
|
continue h_loop
|
|
}
|
|
|
|
amnt_zeros := int(symbol >> 4)
|
|
ac_coeff_len := symbol & 0xF
|
|
ac_coeff: i16 = 0
|
|
|
|
if i + amnt_zeros >= COEFFICIENT_COUNT || ac_coeff_len > 10 {
|
|
return img, .Corrupt
|
|
}
|
|
|
|
i += amnt_zeros
|
|
|
|
ac_coeff = cast(i16)read_bits_msb(ctx, ac_coeff_len)
|
|
if ac_coeff < (1 << (ac_coeff_len - 1)) {
|
|
ac_coeff -= (1 << ac_coeff_len) - 1
|
|
}
|
|
|
|
mcu[zigzag[i]] = ac_coeff * cast(i16)quantization_table[i]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for c in 1..=img.channels {
|
|
c := cast(Component)c
|
|
|
|
for v in 0..<color_components[c].v_sampling_factor {
|
|
for h in 0..< color_components[c].h_sampling_factor {
|
|
mcu := &blocks[(y + v) * block_width + (x + h)][c]
|
|
for i in 0..<BLOCK_SIZE {
|
|
g0 := cast(f32)mcu[0 * BLOCK_SIZE + i] * s0
|
|
g1 := cast(f32)mcu[4 * BLOCK_SIZE + i] * s4
|
|
g2 := cast(f32)mcu[2 * BLOCK_SIZE + i] * s2
|
|
g3 := cast(f32)mcu[6 * BLOCK_SIZE + i] * s6
|
|
g4 := cast(f32)mcu[5 * BLOCK_SIZE + i] * s5
|
|
g5 := cast(f32)mcu[1 * BLOCK_SIZE + i] * s1
|
|
g6 := cast(f32)mcu[7 * BLOCK_SIZE + i] * s7
|
|
g7 := cast(f32)mcu[3 * BLOCK_SIZE + i] * s3
|
|
|
|
f4 := g4 - g7
|
|
f5 := g5 + g6
|
|
f6 := g5 - g6
|
|
f7 := g4 + g7
|
|
|
|
e0 := g0
|
|
e1 := g1
|
|
e2 := g2 - g3
|
|
e3 := g2 + g3
|
|
e4 := f4
|
|
e5 := f5 - f7
|
|
e6 := f6
|
|
e7 := f5 + f7
|
|
e8 := f4 + f6
|
|
|
|
d0 := e0
|
|
d1 := e1
|
|
d2 := e2 * m1
|
|
d3 := e3
|
|
d4 := e4 * m2
|
|
d5 := e5 * m3
|
|
d6 := e6 * m4
|
|
d7 := e7
|
|
d8 := e8 * m5
|
|
|
|
c0 := d0 + d1
|
|
c1 := d0 - d1
|
|
c2 := d2 - d3
|
|
c3 := d3
|
|
c4 := d4 + d8
|
|
c5 := d5 + d7
|
|
c6 := d6 - d8
|
|
c7 := d7
|
|
c8 := c5 - c6
|
|
|
|
b0 := c0 + c3
|
|
b1 := c1 + c2
|
|
b2 := c1 - c2
|
|
b3 := c0 - c3
|
|
b4 := c4 - c8
|
|
b5 := c8
|
|
b6 := c6 - c7
|
|
b7 := c7
|
|
|
|
mcu[0 * BLOCK_SIZE + i] = cast(i16)(b0 + b7)
|
|
mcu[1 * BLOCK_SIZE + i] = cast(i16)(b1 + b6)
|
|
mcu[2 * BLOCK_SIZE + i] = cast(i16)(b2 + b5)
|
|
mcu[3 * BLOCK_SIZE + i] = cast(i16)(b3 + b4)
|
|
mcu[4 * BLOCK_SIZE + i] = cast(i16)(b3 - b4)
|
|
mcu[5 * BLOCK_SIZE + i] = cast(i16)(b2 - b5)
|
|
mcu[6 * BLOCK_SIZE + i] = cast(i16)(b1 - b6)
|
|
mcu[7 * BLOCK_SIZE + i] = cast(i16)(b0 - b7)
|
|
}
|
|
|
|
for i in 0..<BLOCK_SIZE {
|
|
g0 := cast(f32)mcu[i * BLOCK_SIZE + 0] * s0
|
|
g1 := cast(f32)mcu[i * BLOCK_SIZE + 4] * s4
|
|
g2 := cast(f32)mcu[i * BLOCK_SIZE + 2] * s2
|
|
g3 := cast(f32)mcu[i * BLOCK_SIZE + 6] * s6
|
|
g4 := cast(f32)mcu[i * BLOCK_SIZE + 5] * s5
|
|
g5 := cast(f32)mcu[i * BLOCK_SIZE + 1] * s1
|
|
g6 := cast(f32)mcu[i * BLOCK_SIZE + 7] * s7
|
|
g7 := cast(f32)mcu[i * BLOCK_SIZE + 3] * s3
|
|
|
|
f4 := g4 - g7
|
|
f5 := g5 + g6
|
|
f6 := g5 - g6
|
|
f7 := g4 + g7
|
|
|
|
e0 := g0
|
|
e1 := g1
|
|
e2 := g2 - g3
|
|
e3 := g2 + g3
|
|
e4 := f4
|
|
e5 := f5 - f7
|
|
e6 := f6
|
|
e7 := f5 + f7
|
|
e8 := f4 + f6
|
|
|
|
d0 := e0
|
|
d1 := e1
|
|
d2 := e2 * m1
|
|
d3 := e3
|
|
d4 := e4 * m2
|
|
d5 := e5 * m3
|
|
d6 := e6 * m4
|
|
d7 := e7
|
|
d8 := e8 * m5
|
|
|
|
c0 := d0 + d1
|
|
c1 := d0 - d1
|
|
c2 := d2 - d3
|
|
c3 := d3
|
|
c4 := d4 + d8
|
|
c5 := d5 + d7
|
|
c6 := d6 - d8
|
|
c7 := d7
|
|
c8 := c5 - c6
|
|
|
|
b0 := c0 + c3
|
|
b1 := c1 + c2
|
|
b2 := c1 - c2
|
|
b3 := c0 - c3
|
|
b4 := c4 - c8
|
|
b5 := c8
|
|
b6 := c6 - c7
|
|
b7 := c7
|
|
|
|
mcu[i * BLOCK_SIZE + 0] = cast(i16)(b0 + b7)
|
|
mcu[i * BLOCK_SIZE + 1] = cast(i16)(b1 + b6)
|
|
mcu[i * BLOCK_SIZE + 2] = cast(i16)(b2 + b5)
|
|
mcu[i * BLOCK_SIZE + 3] = cast(i16)(b3 + b4)
|
|
mcu[i * BLOCK_SIZE + 4] = cast(i16)(b3 - b4)
|
|
mcu[i * BLOCK_SIZE + 5] = cast(i16)(b2 - b5)
|
|
mcu[i * BLOCK_SIZE + 6] = cast(i16)(b1 - b6)
|
|
mcu[i * BLOCK_SIZE + 7] = cast(i16)(b0 - b7)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert the YCbCr pixel data to RGB
|
|
cbcr_blk := &blocks[y * block_width + x]
|
|
for v := luma_v_sampling_factor - 1; v >= 0; v -= 1 {
|
|
for h := luma_h_sampling_factor - 1; h >= 0; h -= 1 {
|
|
y_blk := &blocks[(y + v) * block_width + (x + h)]
|
|
|
|
for j := BLOCK_SIZE - 1; j >= 0; j -= 1 {
|
|
for k := BLOCK_SIZE - 1; k >= 0; k -= 1 {
|
|
i := j * BLOCK_SIZE + k
|
|
cbcr_pixel_row := j / luma_v_sampling_factor + 4 * v
|
|
cbcr_pixel_column := k / luma_h_sampling_factor + 4 * h
|
|
cbcr_pixel := cbcr_pixel_row * BLOCK_SIZE + cbcr_pixel_column
|
|
|
|
r := cast(i16)clamp(cast(f32)y_blk[.Y][i] + 1.402 * cast(f32)cbcr_blk[.Cr][cbcr_pixel] + 128, 0, 255)
|
|
g := cast(i16)clamp(cast(f32)y_blk[.Y][i] - 0.344 * cast(f32)cbcr_blk[.Cb][cbcr_pixel] - 0.714 * cast(f32)cbcr_blk[.Cr][cbcr_pixel] + 128, 0, 255)
|
|
b := cast(i16)clamp(cast(f32)y_blk[.Y][i] + 1.772 * cast(f32)cbcr_blk[.Cb][cbcr_pixel] + 128, 0, 255)
|
|
|
|
y_blk[.Y][i] = r
|
|
y_blk[.Cb][i] = g
|
|
y_blk[.Cr][i] = b
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
orig_channels := img.channels
|
|
|
|
// We automatically expand grayscale images to RGB
|
|
if img.channels == 1 {
|
|
img.channels += 2
|
|
}
|
|
|
|
if .alpha_add_if_missing in options {
|
|
img.channels += 1
|
|
orig_channels += 1
|
|
}
|
|
|
|
if resize(&img.pixels.buf, img.width * img.height * img.channels) != nil {
|
|
return img, .Unable_To_Allocate_Or_Resize
|
|
}
|
|
|
|
switch orig_channels {
|
|
case 1: // Grayscale JPEG expanded to RGB
|
|
out := mem.slice_data_cast([]image.RGB_Pixel, img.pixels.buf[:])
|
|
out_idx := 0
|
|
for y in 0..<img.height {
|
|
mcu_row := y / BLOCK_SIZE
|
|
pixel_row := y % BLOCK_SIZE
|
|
for x in 0..<img.width {
|
|
mcu_col := x / BLOCK_SIZE
|
|
pixel_col := x % BLOCK_SIZE
|
|
mcu_idx := mcu_row * block_width + mcu_col
|
|
pixel_idx := pixel_row * BLOCK_SIZE + pixel_col
|
|
|
|
luma := cast(byte)blocks[mcu_idx][.Y][pixel_idx]
|
|
out[out_idx] = {luma, luma, luma}
|
|
|
|
out_idx += 1
|
|
}
|
|
}
|
|
|
|
case 2: // Grayscale JPEG expanded to RGBA
|
|
out := mem.slice_data_cast([]image.RGBA_Pixel, img.pixels.buf[:])
|
|
out_idx := 0
|
|
for y in 0..<img.height {
|
|
mcu_row := y / BLOCK_SIZE
|
|
pixel_row := y % BLOCK_SIZE
|
|
|
|
for x in 0..<img.width {
|
|
mcu_col := x / BLOCK_SIZE
|
|
pixel_col := x % BLOCK_SIZE
|
|
mcu_idx := mcu_row * block_width + mcu_col
|
|
pixel_idx := pixel_row * BLOCK_SIZE + pixel_col
|
|
|
|
luma := cast(byte)blocks[mcu_idx][.Y][pixel_idx]
|
|
out[out_idx] = {luma, luma, luma, 255}
|
|
out_idx += 1
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
out := mem.slice_data_cast([]image.RGB_Pixel, img.pixels.buf[:])
|
|
out_idx := 0
|
|
for y in 0..<img.height {
|
|
mcu_row := y / BLOCK_SIZE
|
|
pixel_row := y % BLOCK_SIZE
|
|
|
|
for x in 0..<img.width {
|
|
mcu_col := x / BLOCK_SIZE
|
|
pixel_col := x % BLOCK_SIZE
|
|
mcu_idx := mcu_row * block_width + mcu_col
|
|
pixel_idx := pixel_row * BLOCK_SIZE + pixel_col
|
|
|
|
out[out_idx] = {
|
|
cast(byte)blocks[mcu_idx][.Y][pixel_idx],
|
|
cast(byte)blocks[mcu_idx][.Cb][pixel_idx],
|
|
cast(byte)blocks[mcu_idx][.Cr][pixel_idx],
|
|
}
|
|
out_idx += 1
|
|
}
|
|
}
|
|
|
|
case 4:
|
|
out := mem.slice_data_cast([]image.RGBA_Pixel, img.pixels.buf[:])
|
|
out_idx := 0
|
|
for y in 0..<img.height {
|
|
mcu_row := y / BLOCK_SIZE
|
|
pixel_row := y % BLOCK_SIZE
|
|
|
|
for x in 0..<img.width {
|
|
mcu_col := x / BLOCK_SIZE
|
|
pixel_col := x % BLOCK_SIZE
|
|
mcu_idx := mcu_row * block_width + mcu_col
|
|
pixel_idx := pixel_row * BLOCK_SIZE + pixel_col
|
|
|
|
out[out_idx] = {
|
|
cast(byte)blocks[mcu_idx][.Y][pixel_idx],
|
|
cast(byte)blocks[mcu_idx][.Cb][pixel_idx],
|
|
cast(byte)blocks[mcu_idx][.Cr][pixel_idx],
|
|
255, // Alpha
|
|
}
|
|
out_idx += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
expect_EOI = true
|
|
|
|
case .TEM:
|
|
// TEM doesn't have a length, continue to next marker
|
|
case:
|
|
length := (compress.read_data(ctx, u16be) or_return) - 2
|
|
compress.read_slice_from_memory(ctx, cast(int)length) or_return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
destroy :: proc(img: ^Image) {
|
|
if img == nil {
|
|
return
|
|
}
|
|
|
|
bytes.buffer_destroy(&img.pixels)
|
|
|
|
if v, ok := img.metadata.(^image.JPEG_Info); ok {
|
|
if jfxx, jfxx_ok := v.jfxx_app0.?; jfxx_ok {
|
|
delete(jfxx.thumbnail)
|
|
}
|
|
if jfif, jfif_ok := v.jfif_app0.?; jfif_ok {
|
|
delete(jfif.thumbnail)
|
|
}
|
|
|
|
for comment in v.comments {
|
|
delete(comment)
|
|
}
|
|
delete(v.comments)
|
|
|
|
for exif in v.exif {
|
|
delete(exif.data)
|
|
}
|
|
delete(v.exif)
|
|
|
|
free(v)
|
|
}
|
|
free(img)
|
|
}
|
|
|
|
@(init, private)
|
|
_register :: proc "contextless" () {
|
|
image.register(.JPEG, load_from_bytes, destroy)
|
|
} |