Momentum-Apps/diskop.c

#include "diskop.h"

#define CFG_FILENAME "settings.cfg"

void save_instrument_inner(Stream *stream, Instrument *inst)
{
    size_t rwops = stream_write(stream, (uint8_t *)inst->name, sizeof(inst->name));
    rwops = stream_write(stream, (uint8_t *)&inst->waveform, sizeof(inst->waveform));
    rwops = stream_write(stream, (uint8_t *)&inst->flags, sizeof(inst->flags));
    rwops = stream_write(stream, (uint8_t *)&inst->sound_engine_flags, sizeof(inst->sound_engine_flags));

    rwops = stream_write(stream, (uint8_t *)&inst->base_note, sizeof(inst->base_note));
    rwops = stream_write(stream, (uint8_t *)&inst->finetune, sizeof(inst->finetune));

    rwops = stream_write(stream, (uint8_t *)&inst->slide_speed, sizeof(inst->slide_speed));

    rwops = stream_write(stream, (uint8_t *)&inst->adsr, sizeof(inst->adsr));
    rwops = stream_write(stream, (uint8_t *)&inst->pw, sizeof(inst->pw));

    if (inst->sound_engine_flags & SE_ENABLE_RING_MOD)
    {
        rwops = stream_write(stream, (uint8_t *)&inst->ring_mod, sizeof(inst->ring_mod));
    }

    if (inst->sound_engine_flags & SE_ENABLE_HARD_SYNC)
    {
        rwops = stream_write(stream, (uint8_t *)&inst->hard_sync, sizeof(inst->hard_sync));
    }

    uint8_t progsteps = 0;

    for (uint8_t i = 0; i < INST_PROG_LEN; i++)
    {
        if ((inst->program[i] & 0x7fff) != TE_PROGRAM_NOP)
        {
            progsteps = i + 1;
        }
    }

    rwops = stream_write(stream, (uint8_t *)&progsteps, sizeof(progsteps));

    if (progsteps > 0)
    {
        rwops = stream_write(stream, (uint8_t *)inst->program, progsteps * sizeof(inst->program[0]));
    }

    rwops = stream_write(stream, (uint8_t *)&inst->program_period, sizeof(inst->program_period));

    if (inst->flags & TE_ENABLE_VIBRATO)
    {
        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_speed, sizeof(inst->vibrato_speed));
        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_depth, sizeof(inst->vibrato_depth));
        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_delay, sizeof(inst->vibrato_delay));
    }

    if (inst->flags & TE_ENABLE_PWM)
    {
        rwops = stream_write(stream, (uint8_t *)&inst->pwm_speed, sizeof(inst->pwm_speed));
        rwops = stream_write(stream, (uint8_t *)&inst->pwm_depth, sizeof(inst->pwm_depth));
        rwops = stream_write(stream, (uint8_t *)&inst->pwm_delay, sizeof(inst->pwm_delay));
    }

    if (inst->sound_engine_flags & SE_ENABLE_FILTER)
    {
        rwops = stream_write(stream, (uint8_t *)&inst->filter_cutoff, sizeof(inst->filter_cutoff));
        rwops = stream_write(stream, (uint8_t *)&inst->filter_resonance, sizeof(inst->filter_resonance));
        rwops = stream_write(stream, (uint8_t *)&inst->filter_type, sizeof(inst->filter_type));
    }

    UNUSED(rwops);
}

bool save_song(FlizzerTrackerApp *tracker, FuriString *filepath)
{
    bool file_removed = storage_simply_remove(tracker->storage, furi_string_get_cstr(filepath)); // just in case
    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);

    uint8_t version = TRACKER_ENGINE_VERSION;
    size_t rwops = stream_write(tracker->stream, (uint8_t *)SONG_FILE_SIG, sizeof(SONG_FILE_SIG) - 1);
    rwops = stream_write(tracker->stream, (uint8_t *)&version, sizeof(uint8_t));

    TrackerSong *song = &tracker->song;

    /*for(uint32_t i = 0; i < 23444; i++)
    {
        rwops = stream_write(tracker->stream, (uint8_t*)&song->loop_end, sizeof(uint8_t));
    }*/

    rwops = stream_write(tracker->stream, (uint8_t *)song->song_name, sizeof(song->song_name));
    rwops = stream_write(tracker->stream, (uint8_t *)&song->loop_start, sizeof(song->loop_start));
    rwops = stream_write(tracker->stream, (uint8_t *)&song->loop_end, sizeof(song->loop_end));
    rwops = stream_write(tracker->stream, (uint8_t *)&song->pattern_length, sizeof(song->pattern_length));

    rwops = stream_write(tracker->stream, (uint8_t *)&song->speed, sizeof(song->speed));
    rwops = stream_write(tracker->stream, (uint8_t *)&song->rate, sizeof(song->rate));

    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_sequence_steps, sizeof(song->num_sequence_steps));

    for (uint16_t i = 0; i < song->num_sequence_steps; i++)
    {
        rwops = stream_write(tracker->stream, (uint8_t *)&song->sequence.sequence_step[i], sizeof(song->sequence.sequence_step[0]));
    }

    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_patterns, sizeof(song->num_patterns));

    for (uint16_t i = 0; i < song->num_patterns; i++)
    {
        rwops = stream_write(tracker->stream, (uint8_t *)song->pattern[i].step, sizeof(TrackerSongPatternStep) * (song->pattern_length));
    }

    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_instruments, sizeof(song->num_instruments));

    for (uint16_t i = 0; i < song->num_instruments; i++)
    {
        save_instrument_inner(tracker->stream, song->instrument[i]);
    }

    file_stream_close(tracker->stream);
    tracker->is_saving = false;
    furi_string_free(filepath);

    UNUSED(file_removed);
    UNUSED(open_file);
    UNUSED(rwops);
    return false;
}

bool load_song_util(FlizzerTrackerApp *tracker, FuriString *filepath)
{
    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);

    bool result = load_song(&tracker->song, tracker->stream);

    tracker->is_loading = false;
    file_stream_close(tracker->stream);
    furi_string_free(filepath);
    UNUSED(open_file);
    return result;
}

void save_config(FlizzerTrackerApp *tracker)
{
    // stream_read_line
    FuriString *filepath = furi_string_alloc();
    FuriString *config_line = furi_string_alloc();
    furi_string_cat_printf(filepath, "%s/%s", FLIZZER_TRACKER_FOLDER, CFG_FILENAME);

    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);
    UNUSED(open_file);

    furi_string_cat_printf(config_line, "%s = %s\n", "external_audio", tracker->external_audio ? "true" : "false");
    stream_write_string(tracker->stream, config_line);

    file_stream_close(tracker->stream);
    furi_string_free(filepath);
    furi_string_free(config_line);
}

void load_config(FlizzerTrackerApp *tracker)
{
    FuriString *filepath = furi_string_alloc();
    FuriString *config_line = furi_string_alloc();
    furi_string_cat_printf(filepath, "%s/%s", FLIZZER_TRACKER_FOLDER, CFG_FILENAME);

    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);
    UNUSED(open_file);

    stream_read_line(tracker->stream, config_line);

    sscanf(furi_string_get_cstr(config_line), "%s%s%s", tracker->param, tracker->eq, tracker->value);

    if (strcmp(tracker->param, "external_audio") == 0)
    {
        if (strcmp(tracker->value, "false") == 0)
        {
            tracker->external_audio = false;
            // strcpy(tracker->value, "false_");
        }

        if (strcmp(tracker->value, "true") == 0)
        {
            tracker->external_audio = true;
            // strcpy(tracker->value, "true_");
        }

        sound_engine_init(&tracker->sound_engine, tracker->sound_engine.sample_rate, tracker->external_audio, tracker->sound_engine.audio_buffer_size);
        // sound_engine_set_audio_output(tracker->external_audio);
    }

    file_stream_close(tracker->stream);
    furi_string_free(filepath);
    furi_string_free(config_line);
}