AptEncode/WavAptEncoder.cpp at main · warp32767/AptEncode · GitHub

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include "WavAptEncoder.h"
#include <cmath>
#include <fstream>
#include <algorithm>
#include <iostream>


void generateSyncA(std::vector<float>& line, int offset) {
    for (int i = 0; i < APT_SYNC_A_WIDTH; i++) {
        if((i==4) || (i==5) || (i==8) || (i==9) || (i==12) || (i==13) || (i==16)) {
            line[offset + i] = SYNC_HIGH_LEVEL;
        } else if((i==17) || (i==20) || (i==21) || (i==24) || (i==25) || (i==28) || (i==29)) {
            line[offset + i] = SYNC_HIGH_LEVEL;
        } else {
            line[offset + i] = SYNC_LOW_LEVEL;
        }
    }
}

void generateSpaceMinuteMarker(std::vector<float>& line, int offset, int line_index, bool isChannelA) {
    int minute_flag = ((line_index % APT_LINES_PER_MINUTE == 0) || (line_index % APT_LINES_PER_MINUTE == 1)) ? 1 : 0;

    float marker_value;
    if (isChannelA) {
        marker_value = (minute_flag == 1) ? MARKER_HIGH_LEVEL : MARKER_LOW_LEVEL;
    } else {
        marker_value = (minute_flag == 1) ? MARKER_LOW_LEVEL : MARKER_HIGH_LEVEL;
    }

    std::fill(line.begin() + offset, line.begin() + offset + APT_SPACE_A_WIDTH, marker_value);
}

void generateTelemetry(std::vector<float>& line, int offset, int line_index) {
    int frame_index_in_cycle = line_index % APT_FRAME_LINES;
    float telemetry_value = 0.0f;

    const int telemetry_values[] = {
        APT_TEL_WEDGE1, APT_TEL_WEDGE2, APT_TEL_WEDGE3, APT_TEL_WEDGE4,
        APT_TEL_WEDGE5, APT_TEL_WEDGE6, APT_TEL_WEDGE7, APT_TEL_WEDGE8,
        APT_TEL_ZEROMODREF, APT_TEL_TEMP1, APT_TEL_TEMP2, APT_TEL_TEMP3,
        APT_TEL_TEMP4, APT_TEL_PATCHTEMP, APT_TEL_BACKSCAN, APT_TEL_CHANNELID
    };

    int group_index = frame_index_in_cycle / 8;

    if (group_index >= 0 && group_index < 16) {
        telemetry_value = static_cast<float>(telemetry_values[group_index]) / 255.0f;
    }

    std::fill(line.begin() + offset, line.begin() + offset + APT_TELEMETRY_WIDTH, telemetry_value);
}

void generateSyncB(std::vector<float>& line, int offset) {
    for (int i = 0; i < APT_SYNC_B_WIDTH; i++) {
        if((i==4) || (i==5) || (i==6) || (i==9) || (i==10) || (i==11) || (i==14)) {
            line[offset + i] = SYNC_HIGH_LEVEL;
        } else if((i==15) || (i==16) || (i==19) || (i==20) || (i==21) || (i==24) || (i==25)) {
            line[offset + i] = SYNC_HIGH_LEVEL;
        } else if((i==26) || (i==29) || (i==30) || (i==31) || (i==34) || (i==35) || (i==36)) {
            line[offset + i] = SYNC_HIGH_LEVEL;
        } else {
            line[offset + i] = SYNC_LOW_LEVEL;
        }
    }
}

void generateImageData(std::vector<float>& line, int offset, const unsigned char* image_data,
                       int img_width, int img_height, int line_index, int channel) {
    for (int i = 0; i < APT_IMAGE_WIDTH; i++) {
        int img_x = i;
        int img_y = std::min(img_height - 1, std::max(0, line_index));

        float pixel_value = static_cast<float>(image_data[static_cast<size_t>(img_y) * img_width + img_x]) / 255.0f;

        line[offset + i] = pixel_value;
    }
}

void writeWavFile(const std::string& filename, const std::vector<int16_t>& audio_data, int sample_rate) {
    std::ofstream file(filename, std::ios::binary);
    if (!file) {
        std::cerr << "Failed to open output file for writing: " << filename << std::endl;
        return;
    }

    WavHeader header;
    header.sample_rate = static_cast<uint32_t>(sample_rate);
    header.byte_rate = static_cast<uint32_t>(sample_rate * header.num_channels * header.bit_depth / 8);
    header.data_bytes = static_cast<uint32_t>(audio_data.size() * sizeof(int16_t));
    header.wav_size = header.data_bytes + sizeof(WavHeader) - 8;

    file.write(reinterpret_cast<const char*>(&header), sizeof(WavHeader));
    file.write(reinterpret_cast<const char*>(audio_data.data()), header.data_bytes);
    file.close();
}