A WIP EDF Pattern for ImHex

edf.hexpat

import std.string;

fn format_date(str date) {
    str day = std::string::substr(date, 0, 2);
    str month = std::string::substr(date, 3, 2);
    str year = std::string::substr(date, 6, 2);
    return year + "-" + month + "-" + day;
};

fn format_time(str time) {
    str hour = std::string::substr(time, 0, 2);
    str minute = std::string::substr(time, 3, 2);
    str sec = std::string::substr(time, 6, 2);
    return hour + ":" + minute + ":" + sec;
};

fn transform_str(str val) {
    // Fix me: Need to only remove spaces at the end of the string
    str new_val = "";
    for (u8 i = 0, i < std::string::length(val), i = i + 1) {
        if (i + 1 < std::string::length(val) && 
            (std::string::at(val, i) == 0x20 && std::string::at(val, i + 1) == 0x20)) {
            break;
        }
        new_val += std::string::at(val, i);
    }
    return new_val;
};

fn transform_int(str num) {
    return std::string::parse_int(transform_str(num), 10);
};

struct Channels {
    char label[16] [[transform("transform_str"), format("transform_str")]];
    char transducerType[80] [[transform("transform_str"), format("transform_str")]];
    char physicalDimension[8] [[transform("transform_str"), format("transform_str")]];
    char physicalMin[8] [[transform("transform_int"), format("transform_str")]];
    char physicalMax[8] [[transform("transform_int"), format("transform_str")]];
    char digitalMin[8] [[transform("transform_int"), format("transform_str")]];
    char digitalMax[8] [[transform("transform_int"), format("transform_str")]];
    char prefiltering[80] [[transform("transform_str"), format("transform_str")]];
    char samplesNum[8] [[transform("transform_int"), format("transform_str")]];
    char reserved[32] [[transform("transform_str"), format("transform_str")]];
};

struct ChannelLabel {
    char label[16] [[transform("transform_str"), format("transform_str")]];
} [[format("transform_channel_label")]];

fn transform_channel_label(ChannelLabel inner) {
    return inner.label;
};

struct ChannelTransducerType {
    char transducerType[80] [[transform("transform_str"), format("transform_str")]];
} [[format("transform_channel_transducer_type")]];

fn transform_channel_transducer_type(ChannelTransducerType inner) {
    return inner.transducerType;
};

struct ChannelPhysicalDimension {
    char physicalDimension[8] [[transform("transform_str"), format("transform_str")]];
} [[format("transform_channel_physical_dimension")]];

fn transform_channel_physical_dimension(ChannelPhysicalDimension inner) {
    return inner.physicalDimension;
};

struct ChannelPhysicalMin {
    char physicalMin[8] [[transform("transform_int"), format("transform_str")]];
} [[format("transform_channel_physical_min")]];

fn transform_channel_physical_min(ChannelPhysicalMin inner) {
    return inner.physicalMin;
};

struct ChannelPhysicalMax {
    char physicalMax[8] [[transform("transform_int"), format("transform_str")]];
} [[format("transform_channel_physical_max")]];

fn transform_channel_physical_max(ChannelPhysicalMax inner) {
    return inner.physicalMax;
};

struct ChannelDigitalMin {
    char digitalMin[8] [[transform("transform_int"), format("transform_str")]];
} [[format("transform_channel_digital_min")]];

fn transform_channel_digital_min(ChannelDigitalMin inner) {
    return inner.digitalMin;
};

struct ChannelDigitalMax {
    char digitalMax[8] [[transform("transform_int"), format("transform_str")]];
} [[format("transform_channel_digital_max")]];

fn transform_channel_digital_max(ChannelDigitalMax inner) {
    return inner.digitalMax;
};

struct ChannelPrefiltering {
    char prefiltering[80] [[transform("transform_str"), format("transform_str")]];
} [[format("transform_channel_prefiltering")]];

fn transform_channel_prefiltering(ChannelPrefiltering inner) {
    return inner.prefiltering;
};

struct ChannelSamplesNum {
    char samplesNum[8] [[transform("transform_int"), format("transform_str")]];
} [[format("transform_channel_samples_num")]];

fn transform_channel_samples_num(ChannelSamplesNum inner) {
    return inner.samplesNum;
};

struct ChannelReserved {
    char reserved[32] [[transform("transform_str"), format("transform_str")]];
};

struct EDFHeader{
    char headMagic[8];
    // local subject id
    char localSubjectId[80] [[transform("transform_str"), format("transform_str")]];
    // local recording id
    char localRecordingId[80];

    //   # parse timestamp
    // (day, month, year) = [int(x) for x in re.findall('(\d+)', f.read(8))]
    // (hour, minute, sec)= [int(x) for x in re.findall('(\d+)', f.read(8))]
    // h['date_time'] = str(datetime.datetime(year + 2000, month, day, hour, minute, sec))
    char date[8] [[format("format_date")]];
    char time[8] [[format("format_time")]];
    
    char headerNumBytes[8] [[transform("transform_int"), format("transform_str")]];

    char subtype[44] [[transform("transform_int"), format("transform_str")]];
    char recordsNum[8] [[transform("transform_int"), format("transform_str")]];
    char recordDuration[8] [[transform("transform_int"), format("transform_str")]];
    char channelNum[4] [[transform("transform_int"), format("transform_str")]];
    
    ChannelLabel labels[channelNum];
    ChannelTransducerType transducerTypes[channelNum];
    ChannelPhysicalDimension physicalDimensions[channelNum];
    ChannelPhysicalMin physicalMins[channelNum];
    ChannelPhysicalMax physicalMaxs[channelNum];
    ChannelDigitalMin digitalMins[channelNum];
    ChannelDigitalMax digitalMaxs[channelNum];
    ChannelPrefiltering prefilterings[channelNum];
    ChannelSamplesNum samplesNums[channelNum];
    ChannelReserved reserveds[channelNum];
};
EDFHeader hdr @ 0x0;