foo_vis_spectrum_analyzer/MemoryStream.h at master · stuerp/foo_vis_spectrum_analyzer · 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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

/** $VER: MemoryStream.h (2026.03.22) P. Stuer - Implements a memory stream using the foobar2000 API **/

#pragma once

#include <CppCoreCheck/Warnings.h>

#pragma warning(disable: 4100 4625 4626 4710 4711 4738 5045 ALL_CPPCORECHECK_WARNINGS)

#define NOMINMAX

#include <sdk/foobar2000.h>

using namespace foobar2000_io;

/// <summary>
/// Implements a memory stream using the foobar2000 API.
/// </summary>
class memory_stream_t : public file
{
public:
    memory_stream_t(const void * data, t_size size) noexcept : _Data((const uint8_t *) data), _Size(size) { }

    memory_stream_t(const memory_stream_t &) = delete;
    memory_stream_t & operator=(const memory_stream_t &) = delete;

    memory_stream_t(memory_stream_t &&) = delete;
    memory_stream_t & operator=(memory_stream_t &&) = delete;

    virtual ~memory_stream_t() noexcept = default;

    #pragma region stream_reader interface

    t_size read(void * data, t_size size, abort_callback & abortHandler) override final
    {
        abortHandler.check();

        const t_size BytesToRead = std::min(size, (t_size) (_Size - _Position));

        if (BytesToRead > 0)
        {
            std::memcpy(data, _Data + _Position, BytesToRead);

            _Position += BytesToRead;
        }

        return BytesToRead;
    }

    #pragma endregion

    #pragma region stream_writer interface

    void write(const void *, t_size, abort_callback &) override final
    {
        throw exception_io_denied_readonly();
    }

    #pragma endregion

    #pragma region file interface

    t_filesize get_size(abort_callback &) override final
    {
        return _Size;
    }

    t_filesize get_position(abort_callback &) override final
    {
        return _Position;
    }

    void resize(t_filesize, abort_callback &) override final
    {
        throw exception_io_denied_readonly();
    }

    void seek(t_filesize offset, abort_callback & abortHandler) override final
    {
        abortHandler.check();

        if (offset > _Size)
            throw exception_io_seek_out_of_range();

        _Position = offset;
    }

    bool can_seek() override final
    {
        return true;
    }

    bool get_content_type(pfc::string_base & text) override final
    {
        text = "application/octet-stream";

        return true;
    }

    void reopen(abort_callback & abortHandler) override final
    {
        abortHandler.check();

        _Position = 0;
    }

    bool is_remote() override final
    {
        return false;
    }

    #pragma endregion

private:
    const uint8_t * _Data { };
    t_filesize _Size { };
    t_filesize _Position { };
};