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
// Copyright (c) 2012-2017 VideoStitch SAS
// Copyright (c) 2018 stitchEm
#pragma once
#include "config.hpp"
#include "status.hpp"
#include <memory>
namespace VideoStitch {
namespace GPU {
class Overlayer;
}
namespace Core {
class SourceRenderer;
class PanoRenderer;
class PanoOpenGLSurface;
class VS_EXPORT SourceSurface : public std::enable_shared_from_this<SourceSurface> {
public:
class Pimpl;
virtual ~SourceSurface();
size_t getWidth() const;
size_t getHeight() const;
size_t sourceId;
void acquire();
void release();
Pimpl* const pimpl;
explicit SourceSurface(Pimpl*);
virtual void accept(std::shared_ptr<SourceRenderer>, mtime_t);
void accept(const std::shared_ptr<GPU::Overlayer>&, std::shared_ptr<PanoOpenGLSurface>, mtime_t) {}
private:
SourceSurface(const SourceSurface&);
const SourceSurface& operator=(const SourceSurface&);
};
class VS_EXPORT PanoSurface : public std::enable_shared_from_this<PanoSurface> {
public:
class Pimpl;
virtual ~PanoSurface();
size_t getWidth() const;
size_t getHeight() const;
void acquire();
void release();
Pimpl* const pimpl;
explicit PanoSurface(Pimpl*);
virtual void accept(std::shared_ptr<PanoRenderer>, mtime_t);
virtual void accept(const std::shared_ptr<GPU::Overlayer>&, std::shared_ptr<PanoOpenGLSurface>, mtime_t);
private:
PanoSurface(const PanoSurface&);
const PanoSurface& operator=(const PanoSurface&);
};
class VS_EXPORT SourceOpenGLSurface : public SourceSurface {
public:
class Pimpl;
int texture;
explicit SourceOpenGLSurface(Pimpl*);
virtual ~SourceOpenGLSurface();
virtual void accept(std::shared_ptr<SourceRenderer>, mtime_t);
private:
SourceOpenGLSurface(const SourceOpenGLSurface&);
const SourceOpenGLSurface& operator=(const SourceOpenGLSurface&);
};
class VS_EXPORT PanoOpenGLSurface : public PanoSurface {
public:
class Pimpl;
int pixelbuffer;
explicit PanoOpenGLSurface(Pimpl*);
virtual ~PanoOpenGLSurface();
virtual void accept(std::shared_ptr<PanoRenderer>, mtime_t);
virtual void accept(const std::shared_ptr<GPU::Overlayer>&, std::shared_ptr<PanoOpenGLSurface>, mtime_t);
private:
PanoOpenGLSurface(const PanoOpenGLSurface&);
const PanoOpenGLSurface& operator=(const PanoOpenGLSurface&);
};
enum Layout { YOUTUBE = 0, ROT = 1 };
class VS_EXPORT CubemapSurface : public PanoSurface {
public:
class Pimpl;
explicit CubemapSurface(Pimpl*);
virtual ~CubemapSurface();
size_t getLength() const;
virtual void accept(std::shared_ptr<PanoRenderer>, mtime_t);
virtual void accept(const std::shared_ptr<GPU::Overlayer>&, std::shared_ptr<PanoOpenGLSurface>, mtime_t);
private:
CubemapSurface(const CubemapSurface&);
const CubemapSurface& operator=(const CubemapSurface&);
};
class VS_EXPORT CubemapOpenGLSurface : public CubemapSurface {
public:
class Pimpl;
int faces[6];
CubemapOpenGLSurface(Pimpl*, int* faces);
virtual ~CubemapOpenGLSurface();
virtual void accept(std::shared_ptr<PanoRenderer>, mtime_t);
virtual void accept(const std::shared_ptr<GPU::Overlayer>&, std::shared_ptr<PanoOpenGLSurface>, mtime_t);
private:
CubemapOpenGLSurface(const CubemapOpenGLSurface&);
const CubemapOpenGLSurface& operator=(const CubemapOpenGLSurface&);
};
class VS_EXPORT OffscreenAllocator {
public:
static Potential<SourceSurface> createAlphaSurface(size_t width, size_t height, const char* name);
static Potential<SourceSurface> createSourceSurface(size_t width, size_t height, const char* name);
static Potential<SourceSurface> createDepthSurface(size_t width, size_t height, const char* name);
static Potential<SourceSurface> createCoordSurface(size_t width, size_t height, const char* name);
static Potential<PanoSurface> createPanoSurface(size_t width, size_t height, const char* name);
static Potential<CubemapSurface> createCubemapSurface(size_t width, const char* name, bool equiangular);
};
class VS_EXPORT OpenGLAllocator {
public:
enum class BufferAllocType { ReadWrite, ReadOnly, WriteOnly };
static Potential<SourceOpenGLSurface> createSourceSurface(size_t width, size_t height);
static Potential<PanoOpenGLSurface> createPanoSurface(size_t width, size_t height,
BufferAllocType flag = BufferAllocType::WriteOnly);
static Potential<CubemapOpenGLSurface> createCubemapSurface(size_t width, bool equiangular,
BufferAllocType flag = BufferAllocType::WriteOnly);
};
class VS_EXPORT SourceRenderer {
public:
virtual std::string getName() const = 0;
virtual void render(std::shared_ptr<SourceOpenGLSurface>, mtime_t) = 0;
};
class VS_EXPORT PanoRenderer {
public:
virtual std::string getName() const = 0;
virtual void render(std::shared_ptr<PanoOpenGLSurface>, mtime_t) = 0;
virtual void renderCubemap(std::shared_ptr<CubemapOpenGLSurface>, mtime_t) = 0;
virtual void renderEquiangularCubemap(std::shared_ptr<CubemapOpenGLSurface>, mtime_t) = 0;
};
} // namespace Core
} // namespace VideoStitch