git.haldean.org qb / b340f54 qb.hpp
b340f54

Tree @b340f54 (Download .tar.gz)

qb.hpp @b340f54 — raw · history · 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
#ifndef qb_hpp
#define qb_hpp

#include <memory>
#include <string>
#include <vector>

#include "AudioFile/AudioFile.h"

namespace qb {
  enum class node_type {
    audio,
    midi,
    osc,
  };

  struct load_state {
    enum stage_kind {
      loading,
      loaded,
      failed,
    };
    stage_kind stage;
    std::string message;

    load_state(stage_kind s) : stage(s), message("") {};
    load_state(stage_kind s, const std::string &m) : stage(s), message(m) {};
  };

  struct context;

  struct node {
    node(const node&) = delete;
    node(node&&) = delete;
    node &operator=(const node&) = delete;
    node &operator=(node&&) = delete;

    virtual ~node() = default;

    const std::string &name() const { return _name; }
    node_type type() const { return _type; }
    const context* ctx() const { return _c; }

    virtual int minframe() const = 0;
    virtual int maxframe() const = 0;

  protected:
    node(const context *c, const std::string &n, node_type t);
    const context *_c;

  private:
    std::string _name;
    node_type _type;
  };
  using node_ptr = std::shared_ptr<node>;

  using audio_file = AudioFile<float>;
  using audio_file_ptr = std::shared_ptr<audio_file>;
  using audio_file_cptr = std::shared_ptr<const audio_file>;

  struct audio_node : public node {
    audio_node(const context *c, const std::string &path);
    ~audio_node() override;

    const std::string &path() const { return _path; }
    load_state loadstate() const { return _loadstate; }
    const audio_file_cptr data() const { return _data; }

    const std::vector<float>& rendered() const;
    // number of render samples per frame
    double rsamplerate() const;

    // samples packed the way saudio likes them
    const std::vector<float>& packed() const;

    int minframe() const override;
    int maxframe() const override;

  private:
    void load_async();
    std::vector<float> render_samples(double rsamplerate);

    const std::string _path;
    audio_file_ptr _data;
    std::vector<float> _rhi;
    std::vector<float> _rlo;
    std::vector<float> _packed;
    load_state _loadstate;
  };

  struct context
  {
    context();
    ~context() = default;

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

    int framerate() const { return _framerate; }
    void framerate(int fr) { _framerate = fr; }

    void frame(int width, int height);
    void shutdown();

    int frame2pixel(double frame);

    bool playing = false;

    double playhead = 0;
    double visrad = 240;
    int width = 0;
    int height = 0;

    // for ui animations
    uint32_t spinstep = 0;

  private:
    void initaudio();
    void pushaudio();

    bool audioinit = false;
    int playedframe = -1;
    int64_t pushedsample = -1;

    const audio_node *audiosource = nullptr;

    int _framerate = 24;
    std::vector<qb::node_ptr> _nodes;
  };

}

#endif