exr-zig

exr.zig (18069B)

---

 const std = @import("std");
 
 const Version = packed struct(u32) {
     format_version: u8,
     single_part_tiled: bool,
     long_names: bool,
     non_image: bool,
     multipart: bool,
     padding: u20,
 
     pub fn imageType(this: *const Version) !ImageType {
         if (this.single_part_tiled and (this.non_image or this.multipart)) {
             return error.InvalidImageType;
         }
         if (this.single_part_tiled) {
             return .single_part_tile;
         }
         if (this.non_image and this.multipart) {
             return .multi_part_deep;
         }
         if (this.non_image) {
             return .single_part_deep;
         }
         if (this.multipart) {
             return .multi_part;
         }
         return .single_part_scan_line;
     }
 };
 
 const ImageType = enum {
     single_part_scan_line,
     single_part_tile,
     multi_part,
     single_part_deep,
     multi_part_deep,
 };
 
 const AttributeType = enum {
     box2i,
     box2f,
     bytes,
     chlist,
     chromaticities,
     compression,
     double,
     env_map,
     float,
     int,
     key_code,
     line_order,
     m33f,
     m44f,
     preview,
     rational,
     string,
     string_vector,
     tile_desc,
     time_code,
     v2i,
     v2f,
     v3i,
     v3f,
 };
 
 const AttributeValue = union(AttributeType) {
     box2i: Box2i,
     box2f: Box2f,
     bytes: Bytes,
     chlist: []Channel,
     chromaticities: Chromaticities,
     compression: Compression,
     double: f64,
     env_map: EnvMap,
     float: f32,
     int: i32,
     key_code: KeyCode,
     line_order: LineOrder,
     m33f: [9]f32,
     m44f: [16]f32,
     preview: Preview,
     rational: Rational,
     string: String,
     string_vector: []String,
     tile_desc: TileDesc,
     time_code: TimeCode,
     v2i: [2]i32,
     v2f: [2]f32,
     v3i: [3]i32,
     v3f: [3]f32,
 };
 
 const Box2i = packed struct {
     x_min: i32,
     y_min: i32,
     x_max: i32,
     y_max: i32,
 };
 
 const Box2f = packed struct {
     x_min: f32,
     y_min: f32,
     x_max: f32,
     y_max: f32,
 };
 
 const Bytes = struct {
 };
 
 const PixelType = enum(u32) {
     uint = 0,
     half = 1,
     float = 2,
 };
 
 const Channel = struct {
     name: String,
     pixel_type: PixelType,
     p_linear: u8,
     reserved: [3]u8 = .{ 0, 0, 0 },
     x_sampling: u32,
     y_sampling: u32,
 
     pub fn parse(reader: anytype) !?Channel {
         const name_string = try String.parseNullTerminated(reader);
         if (name_string.len == 0) {
             return null;
         }
         const pixel_type_int = try reader.readInt(u32, .little);
         const pixel_type = @as(PixelType, @enumFromInt(pixel_type_int));
         const p_linear = try reader.readInt(u8, .little);
         try reader.skipBytes(3, .{});
         const x_sampling = try reader.readInt(u32, .little);
         const y_sampling = try reader.readInt(u32, .little);
         return .{
             .name = name_string,
             .pixel_type = pixel_type,
             .p_linear = p_linear,
             .x_sampling = x_sampling,
             .y_sampling = y_sampling,
         };
     }
 };
 
 const Chromaticities = struct {
     red_x: f32,
     red_y: f32,
     green_x: f32,
     green_y: f32,
     blue_x: f32,
     blue_y: f32,
     white_x: f32,
     white_y: f32,
 };
 
 const Compression = enum(u8) {
     none = 0,
     rle = 1,
     zips = 2,
     zip = 3,
     piz = 4,
     pxr24 = 5,
     b44 = 6,
     b44a = 7,
     dwaa = 8,
     dwab = 9,
     htj2k = 10,
 };
 
 const EnvMap = enum(u8) {
     lat_long = 0,
     cube = 1,
 };
 
 const KeyCode = struct {
     film_mfc_code: i32,
     film_type: i32,
     prefix: i32,
     count: i32,
     perf_offset: i32,
     perfs_per_frame: i32,
     perfs_per_count: i32,
 };
 
 const LineOrder = enum(u8) {
     increasing_y = 0,
     decreasing_y = 1,
     random_y = 2,
 };
 
 const Preview = struct {
     width: u32,
     height: u32,
     pixels: []const u8,
 };
 
 const Rational = struct {
     integer: i32,
     fraction: u32,
 };
 
 const String = struct {
     len: u32,
     buf: [255]u8,
 
     pub fn parseNullTerminated(reader: anytype) !String {
         var string = String{ .len = 0, .buf = undefined };
         var stream = std.io.fixedBufferStream(&string.buf);
         const writer = stream.writer();
         try reader.streamUntilDelimiter(writer, 0, string.buf.len);
         string.len = @intCast(stream.pos);
         return string;
     }
 
     pub fn parseLength(reader: anytype, len: u32) !String {
         var string = String{ .len = len, .buf = undefined };
         try reader.readNoEof(string.buf[0..string.len]);
         return string;
     }
 
     pub fn slice(string: *const String) []const u8 {
         return string.buf[0..string.len];
     }
 };
 
 const LevelMode = enum(u4) {
     one = 0,
     mipmap = 1,
     ripmap = 2,
 };
 
 const RoundingMode = enum(u4) {
     down = 0,
     up = 1,
 };
 
 const TileDesc = packed struct {
     x_size: u32,
     y_size: u32,
     level_mode: LevelMode,
     rounding_mode: RoundingMode,
 };
 
 const TimeCode = struct {
     time_and_flags: u32,
     user_data: u32,
 };
 
 const Attribute = struct {
     name: String,
     value: AttributeValue,
 
     pub fn parse(reader: anytype, allocator: std.mem.Allocator) !?Attribute {
         const name_string = try String.parseNullTerminated(reader);
         if (name_string.len == 0) {
             return null;
         }
         const type_string = try String.parseNullTerminated(reader);
         const size = try reader.readInt(u32, .little);
         const value = try Attribute.parseValue(
             type_string.slice(),
             size,
             reader,
             allocator,
         );
         return .{
             .name = name_string,
             .value = value,
         };
     }
 
     fn parseValue(
         type_str: []const u8,
         size: u32,
         reader: anytype,
         allocator: std.mem.Allocator,
     ) !AttributeValue {
         if (std.mem.eql(u8, type_str, "box2i")) {
             const value = try reader.readStruct(Box2i);
             return .{ .box2i = value };
         }
         else if (std.mem.eql(u8, type_str, "box2f")) {
             const value = try reader.readStruct(Box2f);
             return .{ .box2f = value };
         }
         else if (std.mem.eql(u8, type_str, "bytes")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "chlist")) {
             var list = std.ArrayList(Channel).init(allocator);
             errdefer list.deinit();
             while (try Channel.parse(reader)) |*channel| {
                 try list.append(channel.*);
             }
             const channels = try list.toOwnedSlice();
             return .{ .chlist = channels };
         }
         else if (std.mem.eql(u8, type_str, "chromaticities")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "compression")) {
             const value_as_int = try reader.readInt(u8, .little);
             const value = @as(Compression, @enumFromInt(value_as_int));
             return .{ .compression = value };
         }
         else if (std.mem.eql(u8, type_str, "double")) {
             var bytes: [8]u8 = undefined;
             try reader.readNoEof(&bytes);
             const value = std.mem.bytesToValue(f32, &bytes);
             return .{ .double = value };
         }
         else if (std.mem.eql(u8, type_str, "envmap")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "float")) {
             var bytes: [4]u8 = undefined;
             try reader.readNoEof(&bytes);
             const value = std.mem.bytesToValue(f32, &bytes);
             return .{ .float = value };
         }
         else if (std.mem.eql(u8, type_str, "int")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "keycode")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "lineOrder")) {
             const value_as_int = try reader.readInt(u8, .little);
             const value = @as(LineOrder, @enumFromInt(value_as_int));
             return .{ .line_order = value };
         }
         else if (std.mem.eql(u8, type_str, "m33f")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "m44f")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "preview")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "rational")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "string")) {
             const string = try String.parseLength(reader, size);
             return .{ .string = string };
         }
         else if (std.mem.eql(u8, type_str, "stringvector")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "tiledesc")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "timecode")) {
             return error.NotImplemented;
         }
         else if (std.mem.eql(u8, type_str, "v2i")) {
             const value0 = try reader.readInt(i32, .little);
             const value1 = try reader.readInt(i32, .little);
             return .{ .v2i = .{ value0, value1 } };
         }
         else if (std.mem.eql(u8, type_str, "v2f")) {
             var bytes: [8]u8 = undefined;
             try reader.readNoEof(&bytes);
             const value0 = std.mem.bytesToValue(f32, &bytes[0..4]);
             const value1 = std.mem.bytesToValue(f32, &bytes[4..8]);
             return .{ .v2f = .{ value0, value1 } };
         }
         else if (std.mem.eql(u8, type_str, "v3i")) {
             const value0 = try reader.readInt(i32, .little);
             const value1 = try reader.readInt(i32, .little);
             const value2 = try reader.readInt(i32, .little);
             return .{ .v3i = .{ value0, value1, value2 } };
         }
         else if (std.mem.eql(u8, type_str, "v3f")) {
             var bytes: [12]u8 = undefined;
             try reader.readNoEof(&bytes);
             const value0 = std.mem.bytesToValue(f32, &bytes[0..4]);
             const value1 = std.mem.bytesToValue(f32, &bytes[4..8]);
             const value2 = std.mem.bytesToValue(f32, &bytes[8..12]);
             return .{ .v3f = .{ value0, value1, value2 } };
         }
         else {
             return error.InvalidAttributeType;
         }
     }
 };
 
 const AttributeSet = packed struct(u32) {
     channels: bool = false,
     compression: bool = false,
     data_window: bool = false,
     display_window: bool = false,
     line_order: bool = false,
     pixel_aspect_ratio: bool = false,
     screen_window_center: bool = false,
     screen_window_width: bool = false,
     _padding: u24 = 0,
 };
 
 const required_attributes = AttributeSet{
     .channels = true,
     .compression = true,
     .data_window = true,
     .display_window = true,
     .line_order = true,
     .pixel_aspect_ratio = true,
     .screen_window_center = true,
     .screen_window_width = true,
 };
 
 // TODO: decide on a strategy for handling attributes for non-scanline types
 const Header = struct {
     channels: []Channel,
     compression: Compression,
     data_window: Box2i,
     display_window: Box2i,
     line_order: LineOrder,
     pixel_aspect_ratio: f32,
     screen_window_center: [2]f32,
     screen_window_width: f32,
 
     pub fn parse(reader: anytype, allocator: std.mem.Allocator) !Header {
         var attrib_set = AttributeSet{};
         var header: Header = undefined;
         while (try Attribute.parse(reader, allocator)) |*attrib| {
             if (std.mem.eql(u8, attrib.name.slice(), "channels")) {
                 if (attrib_set.channels) {
                     return error.DuplicateAttribute;
                 }
                 header.channels = attrib.value.chlist;
                 attrib_set.channels = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "compression")) {
                 if (attrib_set.compression) {
                     return error.DuplicateAttribute;
                 }
                 header.compression = attrib.value.compression;
                 attrib_set.compression = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "dataWindow")) {
                 if (attrib_set.data_window) {
                     return error.DuplicateAttribute;
                 }
                 header.data_window = attrib.value.box2i;
                 attrib_set.data_window = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "displayWindow")) {
                 if (attrib_set.display_window) {
                     return error.DuplicateAttribute;
                 }
                 header.display_window = attrib.value.box2i;
                 attrib_set.display_window = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "lineOrder")) {
                 if (attrib_set.line_order) {
                     return error.DuplicateAttribute;
                 }
                 header.line_order = attrib.value.line_order;
                 attrib_set.line_order = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "pixelAspectRatio")) {
                 if (attrib_set.pixel_aspect_ratio) {
                     return error.DuplicateAttribute;
                 }
                 header.pixel_aspect_ratio = attrib.value.float;
                 attrib_set.pixel_aspect_ratio = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "screenWindowCenter")) {
                 if (attrib_set.screen_window_center) {
                     return error.DuplicateAttribute;
                 }
                 header.screen_window_center = attrib.value.v2f;
                 attrib_set.screen_window_center = true;
             }
             else if (std.mem.eql(u8, attrib.name.slice(), "screenWindowWidth")) {
                 if (attrib_set.screen_window_width) {
                     return error.DuplicateAttribute;
                 }
                 header.screen_window_width = attrib.value.float;
                 attrib_set.screen_window_width = true;
             }
         }
         if (attrib_set != required_attributes) {
             return error.MissingAttributes;
         }
         return header;
     }
 };
 
 fn scanLinesPerBlock(compression: Compression) u32 {
     return switch (compression) {
         .none => 1,
         .rle => 1,
         .zips => 1,
         .zip => 16,
         .piz => 32,
         .pxr24 => 16,
         .b44 => 32,
         .b44a => 32,
         .dwaa => 32,
         .dwab => 256,
         .htj2k => 256,
     };
 }
 
 pub fn loadFile(path: []const u8, allocator: std.mem.Allocator) !void {
     var file = try std.fs.cwd().openFile(path, .{ .mode = .read_only });
     defer file.close();
 
     var source = std.io.StreamSource{ .file = file };
     var reader = std.io.bufferedReader(source.reader());
     var stream = reader.reader();
 
     const magic = try stream.readInt(u32, .little);
 
     std.debug.print("magic = {}\n", .{magic});
 
     const version = try stream.readStruct(Version);
 
     const image_type = version.imageType();
 
     std.debug.print("version = {}\n", .{version});
     std.debug.print("type = {any}\n", .{image_type});
 
     // TODO: multipart files have a list of headers
     const header = try Header.parse(stream, allocator);
     std.debug.print("header = {}\n", .{header});
     std.debug.print("data window = {}\n", .{header.data_window});
 
     const num_scan_lines = @as(u32, @intCast(header.data_window.y_max - header.data_window.y_min + 1));
     const num_scan_lines_per_block = scanLinesPerBlock(header.compression);
     const num_scan_line_blocks = num_scan_lines / num_scan_lines_per_block;
     std.debug.print("num scan lines = {}\n", .{num_scan_lines});
     std.debug.print("num scan lines per block = {}\n", .{num_scan_lines_per_block});
     std.debug.print("num scan line blocks = {}\n", .{num_scan_line_blocks});
 
     const num_pixels_per_scan_line = @as(u32, @intCast(header.data_window.x_max - header.data_window.x_min + 1));
 
     const offsets = try allocator.alloc(u64, num_scan_line_blocks);
     defer allocator.free(offsets);
     for (offsets) |*offset| {
         offset.* = try stream.readInt(u64, .little);
         std.debug.print("offset = {}\n", .{offset.*});
     }
 
     const pixel_buffers = try allocator.alloc([]u8, header.channels.len);
     for (0.., header.channels) |i, *channel| {
         const pixel_size: u32 = switch (channel.pixel_type) {
             .uint => 4,
             .half => 2,
             .float => 4,
         };
         const num_samples_y = num_scan_lines / channel.y_sampling;
         const num_samples_x = num_pixels_per_scan_line / channel.x_sampling;
         const num_samples = num_samples_x * num_samples_y;
         const channel_size = num_samples * pixel_size;
         const buf = try allocator.alloc(u8, channel_size);
         pixel_buffers[i] = buf;
     }
 
     // can't use buffered reader when seeking (will this be changed?)
     var source_reader = source.reader();
     for (offsets) |offset| {
         try source.seekTo(offset);
         const y_coord = try source_reader.readInt(u32, .little);
         const pixel_data_size = try source_reader.readInt(u32, .little);
 
         for (0.., header.channels) |i, *channel| {
             if (y_coord % channel.y_sampling != 0) {
                 continue;
             }
             const pixel_size: u32 = switch (channel.pixel_type) {
                 .uint => 4,
                 .half => 2,
                 .float => 4,
             };
             const num_samples_x = num_pixels_per_scan_line / channel.x_sampling;
             const num_bytes = num_samples_x * pixel_size;
             const buf_offset = (y_coord / channel.y_sampling) * num_bytes;
             const buf = pixel_buffers[i];
             try source_reader.readNoEof(buf[buf_offset..buf_offset + num_bytes]);
         }
         std.debug.print("y = {}    size = {}\n", .{y_coord, pixel_data_size});
     }
     std.debug.print("g = {any}\n", .{std.mem.bytesAsSlice(f16, pixel_buffers[0])});
     std.debug.print("z = {any}\n", .{std.mem.bytesAsSlice(f32, pixel_buffers[1])});
 }