summaryrefslogtreecommitdiffstats
path: root/src/audio_core/hle/pipe.cpp
blob: 24074a514b9606f97604edd50b40658fc20b8f4d (plain) (blame)
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
// Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <array>
#include <vector>
#include "audio_core/hle/dsp.h"
#include "audio_core/hle/pipe.h"
#include "common/assert.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "core/hle/service/dsp_dsp.h"

namespace DSP {
namespace HLE {

static DspState dsp_state = DspState::Off;

static std::array<std::vector<u8>, NUM_DSP_PIPE> pipe_data;

void ResetPipes() {
    for (auto& data : pipe_data) {
        data.clear();
    }
    dsp_state = DspState::Off;
}

std::vector<u8> PipeRead(DspPipe pipe_number, u32 length) {
    const size_t pipe_index = static_cast<size_t>(pipe_number);

    if (pipe_index >= NUM_DSP_PIPE) {
        LOG_ERROR(Audio_DSP, "pipe_number = %zu invalid", pipe_index);
        return {};
    }

    if (length > UINT16_MAX) { // Can only read at most UINT16_MAX from the pipe
        LOG_ERROR(Audio_DSP, "length of %u greater than max of %u", length, UINT16_MAX);
        return {};
    }

    std::vector<u8>& data = pipe_data[pipe_index];

    if (length > data.size()) {
        LOG_WARNING(
            Audio_DSP,
            "pipe_number = %zu is out of data, application requested read of %u but %zu remain",
            pipe_index, length, data.size());
        length = static_cast<u32>(data.size());
    }

    if (length == 0)
        return {};

    std::vector<u8> ret(data.begin(), data.begin() + length);
    data.erase(data.begin(), data.begin() + length);
    return ret;
}

size_t GetPipeReadableSize(DspPipe pipe_number) {
    const size_t pipe_index = static_cast<size_t>(pipe_number);

    if (pipe_index >= NUM_DSP_PIPE) {
        LOG_ERROR(Audio_DSP, "pipe_number = %zu invalid", pipe_index);
        return 0;
    }

    return pipe_data[pipe_index].size();
}

static void WriteU16(DspPipe pipe_number, u16 value) {
    const size_t pipe_index = static_cast<size_t>(pipe_number);

    std::vector<u8>& data = pipe_data.at(pipe_index);
    // Little endian
    data.emplace_back(value & 0xFF);
    data.emplace_back(value >> 8);
}

static void AudioPipeWriteStructAddresses() {
    // These struct addresses are DSP dram addresses.
    // See also: DSP_DSP::ConvertProcessAddressFromDspDram
    static const std::array<u16, 15> struct_addresses = {
        0x8000 + offsetof(SharedMemory, frame_counter) / 2,
        0x8000 + offsetof(SharedMemory, source_configurations) / 2,
        0x8000 + offsetof(SharedMemory, source_statuses) / 2,
        0x8000 + offsetof(SharedMemory, adpcm_coefficients) / 2,
        0x8000 + offsetof(SharedMemory, dsp_configuration) / 2,
        0x8000 + offsetof(SharedMemory, dsp_status) / 2,
        0x8000 + offsetof(SharedMemory, final_samples) / 2,
        0x8000 + offsetof(SharedMemory, intermediate_mix_samples) / 2,
        0x8000 + offsetof(SharedMemory, compressor) / 2,
        0x8000 + offsetof(SharedMemory, dsp_debug) / 2,
        0x8000 + offsetof(SharedMemory, unknown10) / 2,
        0x8000 + offsetof(SharedMemory, unknown11) / 2,
        0x8000 + offsetof(SharedMemory, unknown12) / 2,
        0x8000 + offsetof(SharedMemory, unknown13) / 2,
        0x8000 + offsetof(SharedMemory, unknown14) / 2,
    };

    // Begin with a u16 denoting the number of structs.
    WriteU16(DspPipe::Audio, static_cast<u16>(struct_addresses.size()));
    // Then write the struct addresses.
    for (u16 addr : struct_addresses) {
        WriteU16(DspPipe::Audio, addr);
    }
    // Signal that we have data on this pipe.
    Service::DSP_DSP::SignalPipeInterrupt(DspPipe::Audio);
}

void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
    switch (pipe_number) {
    case DspPipe::Audio: {
        if (buffer.size() != 4) {
            LOG_ERROR(Audio_DSP, "DspPipe::Audio: Unexpected buffer length %zu was written",
                      buffer.size());
            return;
        }

        enum class StateChange {
            Initialize = 0,
            Shutdown = 1,
            Wakeup = 2,
            Sleep = 3,
        };

        // The difference between Initialize and Wakeup is that Input state is maintained
        // when sleeping but isn't when turning it off and on again. (TODO: Implement this.)
        // Waking up from sleep garbles some of the structs in the memory region. (TODO:
        // Implement this.) Applications store away the state of these structs before
        // sleeping and reset it back after wakeup on behalf of the DSP.

        switch (static_cast<StateChange>(buffer[0])) {
        case StateChange::Initialize:
            LOG_INFO(Audio_DSP, "Application has requested initialization of DSP hardware");
            ResetPipes();
            AudioPipeWriteStructAddresses();
            dsp_state = DspState::On;
            break;
        case StateChange::Shutdown:
            LOG_INFO(Audio_DSP, "Application has requested shutdown of DSP hardware");
            dsp_state = DspState::Off;
            break;
        case StateChange::Wakeup:
            LOG_INFO(Audio_DSP, "Application has requested wakeup of DSP hardware");
            ResetPipes();
            AudioPipeWriteStructAddresses();
            dsp_state = DspState::On;
            break;
        case StateChange::Sleep:
            LOG_INFO(Audio_DSP, "Application has requested sleep of DSP hardware");
            UNIMPLEMENTED();
            dsp_state = DspState::Sleeping;
            break;
        default:
            LOG_ERROR(Audio_DSP,
                      "Application has requested unknown state transition of DSP hardware %hhu",
                      buffer[0]);
            dsp_state = DspState::Off;
            break;
        }

        return;
    }
    default:
        LOG_CRITICAL(Audio_DSP, "pipe_number = %zu unimplemented",
                     static_cast<size_t>(pipe_number));
        UNIMPLEMENTED();
        return;
    }
}

DspState GetDspState() {
    return dsp_state;
}

} // namespace HLE
} // namespace DSP