summaryrefslogtreecommitdiff
path: root/src/jpg/segment.zig
blob: ec1346ad1d82bb5614ebfb51969ea10a9c6716f5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
const std = @import("std");
const jpg = @import("root.zig");

pub const Segment = union(jpg.Marker.Kind) {
    temporary: void,
    reset: void,
    start_of_image: void,
    end_of_image: void,
    start_of_frame: void,
    define_quantization_table: void,
    define_huffman_table: void,
    define_restart_interval: void,
    define_number_of_lines: void,
    define_hierarchy_progression: void,
    extend_huffman_table: void,
    application_segment: void,
    comment: void,
    start_of_scan: void,

    const Self = @This();

    pub fn read(gpa: std.mem.Allocator, reader: *std.Io.Reader) !Self {
        if (try reader.peekByte() != 0xff) {
            return error.InvalidMarkerHeader;
        }
        reader.toss(1);

        const marker  = jpg.Marker.from_u8(try reader.peekByte())
            catch return error.InvalidMarkerByte;
        reader.toss(1);

        return switch (marker) {
            .temporary => .{ .temporary = void{} },
            .reset => .{ .reset = void{} },
            .start_of_image => .{ .start_of_image = void{} },
            .end_of_image => .{ .end_of_image = void{} },
            .start_of_frame => data: {
                const buffer = try read_data_with_length(gpa, reader);
                defer gpa.free(buffer);
                break :data .{ .start_of_frame = void{} };
            },
            .application_segment => data: {
                const buffer = try read_data_with_length(gpa, reader);
                defer gpa.free(buffer);
                break :data .{ .application_segment = void{} };
            },
            else => {
                std.debug.panic("unimplemented tag '{s}'\n", .{@tagName(marker)});
            },
        };
    }

    fn read_data_with_length(gpa: std.mem.Allocator, reader: *std.Io.Reader) ![]u8 {
        const length = try reader.takeInt(u16, .big);
        return try reader.readAlloc(gpa, @intCast(length));
    }
};


test "file" {
    const buffer = @embedFile("../testing/rgb.jpg");
    var reader: std.Io.Reader = .fixed(buffer);

    var segment: Segment = try .read(std.testing.allocator, &reader);
    try std.testing.expectEqual(.start_of_image, std.meta.activeTag(segment));

    segment = try .read(std.testing.allocator, &reader);
    try std.testing.expectEqual(.application_segment, std.meta.activeTag(segment));
}