From f74e281efadbbd3c042f2f3aed13f0552cd881dd Mon Sep 17 00:00:00 2001 From: Jeroen van Rijn Date: Sun, 28 Aug 2022 18:25:07 +0200 Subject: [PATCH] Various changes to TGA reader - Style changes - Change ptr usage to slice indexing - Add TGA Footer Also, add `peek_data` with offset to `compress`. --- core/compress/common.odin | 57 +++++++++++++++- core/image/common.odin | 17 ++++- core/image/tga/tga.odin | 139 ++++++++++++++++++++++++-------------- 3 files changed, 159 insertions(+), 54 deletions(-) diff --git a/core/compress/common.odin b/core/compress/common.odin index f4e378269..b42cbefff 100644 --- a/core/compress/common.odin +++ b/core/compress/common.odin @@ -294,6 +294,24 @@ peek_data_from_memory :: #force_inline proc(z: ^Context_Memory_Input, $T: typeid } } +@(optimization_mode="speed") +peek_data_at_offset_from_memory :: #force_inline proc(z: ^Context_Memory_Input, $T: typeid, #any_int offset: int) -> (res: T, err: io.Error) { + size :: size_of(T) + + #no_bounds_check { + if len(z.input_data) >= size + offset { + buf := z.input_data[offset:][:size] + return (^T)(&buf[0])^, .None + } + } + + if len(z.input_data) == 0 { + return T{}, .EOF + } else { + return T{}, .Short_Buffer + } +} + @(optimization_mode="speed") peek_data_from_stream :: #force_inline proc(z: ^Context_Stream_Input, $T: typeid) -> (res: T, err: io.Error) { size :: size_of(T) @@ -321,7 +339,44 @@ peek_data_from_stream :: #force_inline proc(z: ^Context_Stream_Input, $T: typeid return res, .None } -peek_data :: proc{peek_data_from_memory, peek_data_from_stream} +@(optimization_mode="speed") +peek_data_at_offset_from_stream :: #force_inline proc(z: ^Context_Stream_Input, $T: typeid, #any_int offset: int) -> (res: T, err: io.Error) { + size :: size_of(T) + + // Get current position to return to. + cur_pos, e1 := z.input->impl_seek(0, .Current) + if e1 != .None { + return T{}, e1 + } + + // Seek to offset. + pos, e2 := z.input->impl_seek(offset, .Start) + if e2 != .None { + return T{}, e2 + } + + r, e3 := io.to_reader_at(z.input) + if !e3 { + return T{}, .Empty + } + when size <= 128 { + b: [size]u8 + } else { + b := make([]u8, size, context.temp_allocator) + } + _, e4 := io.read_at(r, b[:], pos) + if e4 != .None { + return T{}, .Empty + } + + // Return read head to original position. + z.input->impl_seek(cur_pos, .Start) + + res = (^T)(&b[0])^ + return res, .None +} + +peek_data :: proc{peek_data_from_memory, peek_data_from_stream, peek_data_at_offset_from_memory, peek_data_at_offset_from_stream} diff --git a/core/image/common.odin b/core/image/common.odin index 7caba4fca..c79344445 100644 --- a/core/image/common.odin +++ b/core/image/common.odin @@ -46,7 +46,7 @@ Image :: struct { height: int, channels: int, depth: int, // Channel depth in bits, typically 8 or 16 - pixels: bytes.Buffer, + pixels: bytes.Buffer `fmt:"-"`, /* Some image loaders/writers can return/take an optional background color. For convenience, we return them as u16 so we don't need to switch on the type @@ -380,7 +380,7 @@ QOI_Info :: struct { TGA_Data_Type :: enum u8 { Uncompressed_RGB = 2, - Compressed_RBB = 10, + Compressed_RBB = 10, } TGA_Header :: struct #packed { @@ -397,8 +397,19 @@ TGA_Header :: struct #packed { } #assert(size_of(TGA_Header) == 18) +New_TGA_Signature :: "TRUEVISION-XFILE.\x00" + +TGA_Footer :: struct #packed { + extension_area_offset: u32le, + developer_directory_offset: u32le, + signature: [18]u8 `fmt:"s"`, // Should match signature if New TGA. +} +#assert(size_of(TGA_Footer) == 26) + TGA_Info :: struct { - header: TGA_Header, + header: TGA_Header, + image_id: string, + footer: Maybe(TGA_Footer), } // Function to help with image buffer calculations diff --git a/core/image/tga/tga.odin b/core/image/tga/tga.odin index 6fd65b7d9..d257d06ff 100644 --- a/core/image/tga/tga.odin +++ b/core/image/tga/tga.odin @@ -16,10 +16,12 @@ import "core:image" import "core:bytes" import "core:os" import "core:compress" +import "core:strings" +import "core:fmt" +_ :: fmt // TODO: alpha_premultiply support - Error :: image.Error Image :: image.Image Options :: image.Options @@ -122,6 +124,21 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a options -= {.return_header} } + // First check for a footer. + filesize := compress.input_size(ctx) or_return + + footer: image.TGA_Footer + have_valid_footer := false + + if filesize >= size_of(image.TGA_Header) + size_of(image.TGA_Footer) { + if f, f_err := compress.peek_data(ctx, image.TGA_Footer, filesize - i64(size_of(image.TGA_Footer))); f_err == .None { + if string(f.signature[:]) == image.New_TGA_Signature { + have_valid_footer = true + footer = f + } + } + } + header := image.read_data(ctx, image.TGA_Header) or_return // Header checks @@ -132,14 +149,16 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a case .Uncompressed_RGB: case: return nil, .Unsupported_Format } - if header.bits_per_pixel!=24 && header.bits_per_pixel!=32 { - return nil, .Unsupported_Format - } - if ( header.image_descriptor & IMAGE_DESCRIPTOR_INTERLEAVING_MASK ) != 0 { + + if header.bits_per_pixel != 24 && header.bits_per_pixel != 32 { return nil, .Unsupported_Format } - if (int(header.dimensions[0])*int(header.dimensions[1])) > image.MAX_DIMENSIONS { + if header.image_descriptor & IMAGE_DESCRIPTOR_INTERLEAVING_MASK != 0 { + return nil, .Unsupported_Format + } + + if int(header.dimensions[0]) * int(header.dimensions[1]) > image.MAX_DIMENSIONS { return nil, .Image_Dimensions_Too_Large } @@ -147,88 +166,104 @@ load_from_context :: proc(ctx: ^$C, options := Options{}, allocator := context.a img = new(Image) } + defer if err != nil { + destroy(img) + } + + src_channels := int(header.bits_per_pixel) / 8 + img.which = .TGA + img.channels = 4 if .alpha_add_if_missing in options else src_channels + img.channels = 3 if .alpha_drop_if_present in options else img.channels + + img.depth = 8 + img.width = int(header.dimensions[0]) + img.height = int(header.dimensions[1]) + + // Read Image ID if present + image_id := "" + if _id, e := compress.read_slice(ctx, int(header.id_length)); e != .None { + return nil, .Corrupt + } else { + if .return_metadata in options { + id := strings.trim_right_null(string(_id)) + image_id = strings.clone(id) + } + } + if .return_metadata in options { info := new(image.TGA_Info) - info.header = header + info.header = header + info.image_id = image_id + if have_valid_footer { + info.footer = footer + } img.metadata = info } - src_channels := int(header.bits_per_pixel)/8 - img.which = .TGA - img.channels = .alpha_add_if_missing in options ? 4: src_channels - img.channels = .alpha_drop_if_present in options ? 3: img.channels - - img.depth = 8 - img.width = int(header.dimensions[0]) - img.height = int(header.dimensions[1]) if .do_not_decompress_image in options { return img, nil } - // skip id - if _, e := compress.read_slice(ctx, int(header.id_length)); e!= .None { - destroy(img) - return nil, .Corrupt - } - if !resize(&img.pixels.buf, img.channels * img.width * img.height) { - destroy(img) - return nil, .Unable_To_Allocate_Or_Resize + return img, .Unable_To_Allocate_Or_Resize } - origin_is_topleft := (header.image_descriptor & IMAGE_DESCRIPTOR_TOPLEFT_MASK ) != 0 + origin_is_topleft := header.image_descriptor & IMAGE_DESCRIPTOR_TOPLEFT_MASK != 0 rle_repetition_count := 0 - read_pixel := true - is_packet_rle := false - pixel: [4]u8 - for y in 0..>7) != 0 + is_packet_rle = (rle_cmd >> 7) != 0 rle_repetition_count = 1 + int(rle_cmd & 0x7F) read_pixel = true - } else if is_packet_rle==false { - read_pixel = rle_repetition_count>0 + } else if !is_packet_rle { + read_pixel = rle_repetition_count > 0 } else { read_pixel = false } } // Read pixel if read_pixel { - src, err := compress.read_slice(ctx, src_channels) - if err!=.None { - destroy(img) - return nil, .Corrupt + src, src_err := compress.read_slice(ctx, src_channels) + if src_err != .None { + return img, .Corrupt } + pixel[2] = src[0] pixel[1] = src[1] pixel[0] = src[2] - pixel[3] = src_channels==4 ? src[3] : 255 - if img.channels==4 { - if src_channels==4 { - dst[3] = src[3] + + pixel[3] = src_channels == 4 ? src[3] : 255 + if img.channels == 4 { + if src_channels == 4 { + img.pixels.buf[offset:][3] = src[3] } else { - dst[3] = 255 + img.pixels.buf[offset:][3] = 255 } } } // Write pixel - mem.copy(dst, mem.raw_data(&pixel), img.channels) - dst = mem.ptr_offset(dst, img.channels) + copy(img.pixels.buf[offset:], pixel[:img.channels]) + offset += img.channels rle_repetition_count -= 1 } + line += 1 if origin_is_topleft else -1 } return img, nil } @@ -258,15 +293,19 @@ load_from_file :: proc(filename: string, options := Options{}, allocator := cont load :: proc{load_from_file, load_from_bytes, load_from_context} destroy :: proc(img: ^Image) { - if img == nil { + if img == nil || img.width == 0 || img.height == 0 { return } bytes.buffer_destroy(&img.pixels) if v, ok := img.metadata.(^image.TGA_Info); ok { + delete(v.image_id) free(v) } + // Make destroy idempotent + img.width = 0 + img.height = 0 free(img) }