git.haldean.org qb / main qb.hpp
main

Tree @main (Download .tar.gz)

qb.hpp @main — 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
#ifndef qb_hpp
#define qb_hpp

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

namespace qb {
  enum class node_type {
    audio,
    cue,
  };

  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>;

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

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

    // get/set the playback framerate (not the UI frame rate!)
    int framerate() const { return _framerate; }
    void framerate(int fr) { _framerate = fr; }

    // visible radius around playhead
    double visrad() const { return _visrad; }
    // location of the playhead (in playback frames)
    double playhead() const { return _playhead; }

    // for ui animations, incremented (with wraparound) on every UI frame.
    uint32_t spinstep() const { return _spinstep; }

    // width and height of the qb window
    int width() const { return _width; }
    int height() const { return _height; }

    // draws a frame at the given width and height
    void frame(int width, int height);

    // kills the event loop
    void shutdown();

    // translates a playback frame to a UI x-coordinate
    int frame2pixel(double frame) const;

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

    bool _playing = false;

    double _playhead = 0;
    double _visrad = 240;
    int _width = 0;
    int _height = 0;

    uint32_t _spinstep = 0;

    bool _audioinit = false;
    int _playedframe = -1;
    int64_t _pushedsample = -1;

    const node *_audiosource = nullptr;

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

}

#endif