ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-06-13 01:21:38 -07:00
Code Issues Packages Projects Releases Wiki Activity

image/jpeg: implement jpeg decoding for baseline and extended sequential jpegs

Browse Source
This commit is contained in:
Hisham Aburaqibah
2025-01-16 11:11:39 +02:00
committed by Jeroen van Rijn
parent d704c45c24
commit a6f18c3367
5 changed files with 1089 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/image/common.odin
+133 -2
View File
@@ -64,6 +64,7 @@ Image_Metadata :: union #shared_nil {
^QOI_Info,
^TGA_Info,
^BMP_Info,
^JPEG_Info,
}
@@ -112,8 +113,7 @@ Image_Option:
`.alpha_drop_if_present`
If the image has an alpha channel, drop it.
You may want to use `.alpha_
tiply` in this case.
You may want to use `.alpha_premultiply` in this case.
NOTE: For PNG, this also skips handling of the tRNS chunk, if present,
unless you select `alpha_premultiply`.
@@ -163,6 +163,7 @@ Error :: union #shared_nil {
PNG_Error,
QOI_Error,
BMP_Error,
JPEG_Error,
compress.Error,
compress.General_Error,
@@ -575,6 +576,136 @@ TGA_Info :: struct {
extension: Maybe(TGA_Extension),
}
/*
JPEG-specific
*/
JFIF_Magic := [?]byte{0x4A, 0x46, 0x49, 0x46} // "JFIF"
JFXX_Magic := [?]byte{0x4A, 0x46, 0x58, 0x58} // "JFXX"
JPEG_Error :: enum {
None = 0,
Duplicate_SOI_Marker,
Invalid_JFXX_Extension_Code,
Encountered_SOS_Before_SOF,
Invalid_Quantization_Table_Precision,
Invalid_Quantization_Table_Index,
Invalid_Huffman_Coefficient_Type,
Invalid_Huffman_Table_Index,
Unsupported_Frame_Type,
Invalid_Frame_Bit_Depth_Combo,
Invalid_Sampling_Factor,
Unsupported_12_Bit_Depth,
Multiple_SOS_Markers,
Encountered_RST_Marker_Outside_ECS,
Extra_Data_After_SOS, // Image seemed to have decoded okay, but there's more data after SOS
Invalid_Thumbnail_Size,
}
JFIF_Unit :: enum byte {
None = 0,
Dots_Per_Inch = 1,
Dots_Per_Centimeter = 2,
}
JFIF_APP0 :: struct {
version: u16be,
units: JFIF_Unit,
x_density: u16be,
y_density: u16be,
x_thumbnail: byte,
y_thumbnail: byte,
thumbnail: []RGB_Pixel `fmt:"-"`,
greyscale_thumbnail: bool,
}
JFXX_APP0 :: struct {
extension_code: JFXX_Extension_Code,
x_thumbnail: int,
y_thumbnail: int,
thumbnail: []byte `fmt:"-"`,
}
JFXX_Extension_Code :: enum u8 {
Thumbnail_JPEG = 0x10,
Thumbnail_1_Byte_Palette = 0x11,
Thumbnail_3_Byte_RGB = 0x13,
}
JPEG_Marker :: enum u8 {
SOF0 = 0xC0,
SOF1 = 0xC1,
SOF2 = 0xC2,
SOF3 = 0xC3,
DHT = 0xC4,
SOF5 = 0xC5,
SOF6 = 0xC6,
SOF7 = 0xC7,
JPG = 0xC8,
SOF9 = 0xC9,
SOF10 = 0xCA,
SOF11 = 0xCB,
DAC = 0xCC,
SOF13 = 0xCD,
SOF14 = 0xCE,
SOF15 = 0xCF,
RST0 = 0xD0,
RST1 = 0xD1,
RST2 = 0xD2,
RST3 = 0xD3,
RST4 = 0xD4,
RST5 = 0xD5,
RST6 = 0xD6,
RST7 = 0xD7,
SOI = 0xD8,
EOI = 0xD9,
SOS = 0xDA,
DQT = 0xDB,
DNL = 0xDC,
DRI = 0xDD,
DHP = 0xDE,
EXP = 0xDF,
APP0 = 0xE0,
APP1 = 0xE1,
APP2 = 0xE2,
APP3 = 0xE3,
APP4 = 0xE4,
APP5 = 0xE5,
APP6 = 0xE6,
APP7 = 0xE7,
APP8 = 0xE8,
APP9 = 0xE9,
APP10 = 0xEA,
APP11 = 0xEB,
APP12 = 0xEC,
APP13 = 0xED,
APP14 = 0xEE,
APP15 = 0xEF,
JPG0 = 0xF0,
JPG1 = 0xF1,
JPG2 = 0xF2,
JPG3 = 0xF3,
JPG4 = 0xF4,
JPG5 = 0xF5,
JPG6 = 0xF6,
JPG7 = 0xF7,
JPG8 = 0xF8,
JPG9 = 0xF9,
JPG10 = 0xFA,
JPG11 = 0xFB,
JPG12 = 0xFC,
JPG13 = 0xFD,
COM = 0xFE,
TEM = 0x01,
}
JPEG_Info :: struct {
jfif_app0: Maybe(JFIF_APP0),
jfxx_app0: Maybe(JFXX_APP0),
comments: [dynamic]string,
//exif: Maybe(Exif),
}
// Function to help with image buffer calculations
compute_buffer_size :: proc(width, height, channels, depth: int, extra_row_bytes := int(0)) -> (size: int) {
size = ((((channels * width * depth) + 7) >> 3) + extra_row_bytes) * height
core/image/jpeg/jpeg.odin
+928
View File
@@ -0,0 +1,928 @@
package jpeg
import "core:bytes"
import "core:compress"
import "core:fmt"
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 :: 162
HUFFMAN_MAX_BITS :: 16
// 768 bytes of 24-bit RGB values.
THUMBNAIL_PALETTE_SIZE :: 768
BLOCK_SIZE :: 8
COEFFICIENT_COUNT :: BLOCK_SIZE * BLOCK_SIZE
Coefficient :: enum u8 {
DC,
AC,
}
Component :: enum u8 {
Y = 1,
Cb = 2,
Cr = 3,
}
HuffmanTable :: struct {
symbols: [HUFFMAN_MAX_SYMBOLS]byte,
codes: [HUFFMAN_MAX_SYMBOLS]u32,
offsets: [HUFFMAN_MAX_BITS + 1]byte,
}
QuantizationTable :: [COEFFICIENT_COUNT]u16be
ColorComponent :: 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 {
next := u64(z.input_data[1])
if b == 0xFF {
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
b = u64(z.input_data[2])
z.input_data = z.input_data[3:]
}
} else {
z.input_data = z.input_data[1:]
}
} 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: HuffmanTable) -> 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}
}
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
huffman: [Coefficient][4]HuffmanTable
quantization: [4]QuantizationTable
color_components: [Component]ColorComponent
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 {
first = compress.read_u8(ctx) or_return
if first == 0xFF {
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)
}
if slice.equal(ident[:], image.JFIF_Magic[:]) {
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,
units,
x_density,
y_density,
cast(u8)x_thumbnail,
cast(u8)y_thumbnail,
thumbnail,
greyscale_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,
x_thumbnail,
y_thumbnail,
thumbnail,
}
img.metadata = info
}
case .Thumbnail_1_Byte_Palette: // NOTE: 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,
x_thumbnail,
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: // Exif metadata
// unimplemented("APP1")
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 {
if info.comments == nil {
info.comments = make([dynamic]string, 0, 8, allocator) or_return
}
append(&info.comments, strings.clone(comment))
}
}
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 := 0
for length, i in lengths {
num_symbols += cast(int)length
huffman[type][index].offsets[i + 1] = cast(u8)num_symbols
}
symbols := compress.read_slice(ctx, 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 width == 0 || height == 0 {
return img, .Invalid_Image_Dimensions
}
// 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
}
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
// TODO: some images write zero-based IDs for the components, which violates the spec, but most (if not all)
// decoders handle them just fine. Should we support that too?
// 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 {
fmt.println("Found unknown component ID:", id)
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
unimplemented("SOF2")
case .SOF3: // Lossless (sequential)
fallthrough
case .SOF5: // Differential sequential DCT
fallthrough
case .SOF6: // Differential progressive DCT
fallthrough
case .SOF7: // Differential lossless (sequential)
fallthrough
case .SOF9: // Extended sequential DCT, Arithmetic coding
fallthrough
case .SOF10: // Progressive DCT, Arithmetic coding
fallthrough
case .SOF11: // Lossless (sequential), Arithmetic coding
fallthrough
case .SOF13: // Differential sequential DCT, Arithmetic coding
fallthrough
case .SOF14: // Differential progressive DCT, Arithmetic coding
fallthrough
case .SOF15: // Differential lossless (sequential), Arithmetic coding
fmt.println(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 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
cbcrPixelRow := j / luma_v_sampling_factor + 4 * v
cbcrPixelColumn := k / luma_h_sampling_factor + 4 * h
cbcrPixel := cbcrPixelRow * BLOCK_SIZE + cbcrPixelColumn
r := cast(i16)math.clamp(cast(f32)y_blk[.Y][i] + 1.402 * cast(f32)cbcr_blk[.Cr][cbcrPixel] + 128, 0, 255)
g := cast(i16)math.clamp(cast(f32)y_blk[.Y][i] - 0.344 * cast(f32)cbcr_blk[.Cb][cbcrPixel] - 0.714 * cast(f32)cbcr_blk[.Cr][cbcrPixel] + 128, 0, 255)
b := cast(i16)math.clamp(cast(f32)y_blk[.Y][i] + 1.772 * cast(f32)cbcr_blk[.Cb][cbcrPixel] + 128, 0, 255)
y_blk[.Y][i] = r
y_blk[.Cb][i] = g
y_blk[.Cr][i] = b
}
}
}
}
}
}
if resize(&img.pixels.buf, img.width * img.height * img.channels) != nil {
return img, .Unable_To_Allocate_Or_Resize
}
out := mem.slice_data_cast([]image.RGB_Pixel, img.pixels.buf[:])
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
if img.channels == 3 {
out[y * img.width + x] = {
cast(byte)blocks[mcu_idx][.Y][pixel_idx],
cast(byte)blocks[mcu_idx][.Cb][pixel_idx],
cast(byte)blocks[mcu_idx][.Cr][pixel_idx],
}
} else {
img.pixels.buf[y * img.width + x] = cast(byte)blocks[mcu_idx][.Y][pixel_idx]
}
}
}
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)
free(v)
}
free(img)
}
@(init, private)
_register :: proc() {
image.register(.JPEG, load_from_bytes, destroy)
}
core/image/jpeg/jpeg_js.odin
+3
View File
@@ -0,0 +1,3 @@
package jpeg
load :: proc{load_from_bytes, load_from_context}
core/image/jpeg/jpeg_os.odin
+18
View File
@@ -0,0 +1,18 @@
package jpeg
import "core:os"
load :: proc{load_from_file, load_from_bytes, load_from_context}
load_from_file :: proc(filename: string, options := Options{}, allocator := context.allocator) -> (img: ^Image, err: Error) {
context.allocator = allocator
data, ok := os.read_entire_file(filename)
defer delete(data)
if ok {
return load_from_bytes(data, options)
} else {
return nil, .Unable_To_Read_File
}
}
examples/all/all_main.odin
+7 -6
View File
@@ -76,12 +76,13 @@ package all
@(require) import "core:hash"
@(require) import "core:hash/xxhash"
@(require) import "core:image"
@(require) import "core:image/bmp"
@(require) import "core:image/netpbm"
@(require) import "core:image/png"
@(require) import "core:image/qoi"
@(require) import "core:image/tga"
import image "core:image"
import bmp "core:image/bmp"
import netpbm "core:image/netpbm"
import png "core:image/png"
import qoi "core:image/qoi"
import tga "core:image/tga"
import jpeg "core:image/jpeg"
@(require) import "core:io"
@(require) import "core:log"