framework2

1
#include "ofVideoGrabber.h"
2
#include "ofVideoBaseTypes.h"
3
#include "ofGLUtils.h"
4
#include "ofAppRunner.h"
5
#include "ofConstants.h"
6
#include "ofPixels.h"
7

8
#ifdef OF_VIDEO_CAPTURE_IOS
9
	#include "ofxiOSVideoGrabber.h"
10
	#define OF_VID_GRABBER_TYPE ofxiOSVideoGrabber
11
#endif
12

13
#ifdef OF_VIDEO_CAPTURE_QUICKTIME
14
	#include "ofQuickTimeGrabber.h"
15
	#define OF_VID_GRABBER_TYPE ofQuickTimeGrabber
16
#endif
17

18
#ifdef OF_VIDEO_CAPTURE_QTKIT
19
	#include "ofQTKitGrabber.h"
20
	#define OF_VID_GRABBER_TYPE ofQTKitGrabber
21
#endif
22

23
#ifdef OF_VIDEO_CAPTURE_AVF
24
	#include "ofAVFoundationGrabber.h"
25
	#define OF_VID_GRABBER_TYPE ofAVFoundationGrabber
26
#endif
27

28
#ifdef OF_VIDEO_CAPTURE_DIRECTSHOW
29
	#include "ofDirectShowGrabber.h"
30
	#define OF_VID_GRABBER_TYPE ofDirectShowGrabber
31
#endif
32

33
#ifdef OF_VIDEO_CAPTURE_GSTREAMER
34
	#include "ofGstVideoGrabber.h"
35
	#define OF_VID_GRABBER_TYPE ofGstVideoGrabber
36
#endif
37

38
#ifdef OF_VIDEO_CAPTURE_ANDROID
39
	#include "ofxAndroidVideoGrabber.h"
40
	#define OF_VID_GRABBER_TYPE ofxAndroidVideoGrabber
41
#endif
42

43
#ifdef OF_VIDEO_CAPTURE_EMSCRIPTEN
44
	#include "ofxEmscriptenVideoGrabber.h"
45
	#define OF_VID_GRABBER_TYPE ofxEmscriptenVideoGrabber
46
#endif
47

48
using std::shared_ptr;
49
using std::vector;
50

51
//--------------------------------------------------------------------
52
ofVideoGrabber::ofVideoGrabber(){
53
	bUseTexture			= true;
54
	requestedDeviceID	= -1;
55
	internalPixelFormat = OF_PIXELS_RGB;
56
	desiredFramerate 	= -1;
57
	tex.resize(1);
58
}
59

60
//--------------------------------------------------------------------
61
ofVideoGrabber::~ofVideoGrabber(){
62
}
63

64
//--------------------------------------------------------------------
65
void ofVideoGrabber::setGrabber(shared_ptr<ofBaseVideoGrabber> newGrabber){
66
	grabber = std::move(newGrabber);
67
}
68

69
//--------------------------------------------------------------------
70
shared_ptr<ofBaseVideoGrabber> ofVideoGrabber::getGrabber(){
71
	if(!grabber){
72
		setGrabber(std::make_shared<OF_VID_GRABBER_TYPE>());
73
	}
74
	return grabber;
75
}
76

77
const shared_ptr<ofBaseVideoGrabber> ofVideoGrabber::getGrabber() const{
78
	return grabber;
79
}
80

81
//--------------------------------------------------------------------
82
bool ofVideoGrabber::setup(int w, int h, bool setUseTexture){
83

84
#ifndef OF_VID_GRABBER_TYPE
85
#error OF_VID_GRABBER_TYPE is not #defined!
86
#endif
87

88
	if(!grabber){
89
		setGrabber(std::make_shared<OF_VID_GRABBER_TYPE>());
90
	}
91

92
	bUseTexture = setUseTexture;
93

94
	if( requestedDeviceID >= 0 ){
95
		grabber->setDeviceID(requestedDeviceID);
96
	}
97

98
	setPixelFormat(internalPixelFormat); //this safely handles checks for supported format
99

100
	if( desiredFramerate!=-1 ){
101
		grabber->setDesiredFrameRate(desiredFramerate);
102
	}
103

104
	grabber->setup(w, h);
105

106
	if( grabber->isInitialized() && bUseTexture ){
107
		if(!grabber->getTexturePtr()){
108
			for(std::size_t i=0;i<grabber->getPixels().getNumPlanes();i++){
109
				ofPixels plane = grabber->getPixels().getPlane(i);
110
				tex.push_back(ofTexture());
111
				tex[i].allocate(plane);
112
			}
113
		}
114
	}
115

116
	return grabber->isInitialized();
117
}
118

119
//--------------------------------------------------------------------
120
bool ofVideoGrabber::initGrabber(int w, int h, bool setUseTexture){
121
	return setup(w,h,setUseTexture);
122
}
123

124
//--------------------------------------------------------------------
125
bool ofVideoGrabber::setPixelFormat(ofPixelFormat pixelFormat) {
126
	if(grabber){
127
		if( grabber->isInitialized() ){
128
			ofLogWarning("ofVideoGrabber") << "setPixelFormat(): can't set pixel format while grabber is running";
129
			internalPixelFormat = grabber->getPixelFormat(); 
130
			return false;
131
		}else{
132
			if( grabber->setPixelFormat(pixelFormat) ){		
133
				internalPixelFormat = grabber->getPixelFormat();  //we do this as either way we want the grabbers format
134
			}else{
135
				internalPixelFormat = grabber->getPixelFormat();  //we do this as either way we want the grabbers format
136
				return false; 					
137
			}
138
		}
139
	}else{
140
		internalPixelFormat = pixelFormat;	
141
	}
142
	return true;
143
}
144

145
//---------------------------------------------------------------------------
146
ofPixelFormat ofVideoGrabber::getPixelFormat() const{
147
	if(grabber){
148
		internalPixelFormat = grabber->getPixelFormat();
149
	}
150
	return internalPixelFormat;
151
}
152

153
//--------------------------------------------------------------------
154
vector<ofVideoDevice> ofVideoGrabber::listDevices() const{
155
	if(!grabber){
156
		ofVideoGrabber * mutThis = const_cast<ofVideoGrabber*>(this);
157
		mutThis->setGrabber(std::make_shared<OF_VID_GRABBER_TYPE>());
158
	}
159
	return grabber->listDevices();
160
}
161

162
//--------------------------------------------------------------------
163
void ofVideoGrabber::setVerbose(bool bTalkToMe){
164
	if(grabber){
165
		grabber->setVerbose(bTalkToMe);
166
	}
167
}
168

169
//--------------------------------------------------------------------
170
void ofVideoGrabber::setDeviceID(int _deviceID){
171
	requestedDeviceID = _deviceID;
172
	if( grabber && grabber->isInitialized() ){
173
		ofLogWarning("ofVideoGrabber") << "setDeviceID(): can't set device while grabber is running.";
174
	}
175
}
176

177
//--------------------------------------------------------------------
178
void ofVideoGrabber::setDesiredFrameRate(int framerate){
179
	desiredFramerate = framerate;
180
	if(grabber){
181
		grabber->setDesiredFrameRate(framerate);
182
	}
183
}
184

185
//---------------------------------------------------------------------------
186
ofPixels & ofVideoGrabber::getPixels(){
187
	return getGrabber()->getPixels();
188
}
189

190
//---------------------------------------------------------------------------
191
const ofPixels & ofVideoGrabber::getPixels() const{
192
	return getGrabber()->getPixels();
193
}
194

195
//---------------------------------------------------------------------------
196
ofPixels& ofVideoGrabber::getPixelsRef(){
197
	return getGrabber()->getPixels();
198
}
199

200
//---------------------------------------------------------------------------
201
const ofPixels& ofVideoGrabber::getPixelsRef() const{
202
	return getGrabber()->getPixels();
203
}
204

205
//------------------------------------
206
ofTexture & ofVideoGrabber::getTexture(){
207
	if(grabber->getTexturePtr() == nullptr){
208
		return tex[0];
209
	}
210
	else{
211
		return *grabber->getTexturePtr();
212
	}
213
}
214

215
//------------------------------------
216
const ofTexture & ofVideoGrabber::getTexture() const{
217
	if(grabber->getTexturePtr() == nullptr){
218
		return tex[0];
219
	}
220
	else{
221
		return *grabber->getTexturePtr();
222
	}
223
}
224

225
//------------------------------------
226
ofTexture & ofVideoGrabber::getTextureReference(){
227
	return getTexture();
228
}
229

230
//------------------------------------
231
const ofTexture & ofVideoGrabber::getTextureReference() const{
232
	return getTexture();
233
}
234

235
//------------------------------------
236
vector<ofTexture> & ofVideoGrabber::getTexturePlanes(){
237
	if(grabber->getTexturePtr() != nullptr){
238
		tex.clear();
239
		tex.push_back(*grabber->getTexturePtr());
240
	}
241
	return tex;
242
}
243

244
//------------------------------------
245
const vector<ofTexture> & ofVideoGrabber::getTexturePlanes() const{
246
	if(grabber->getTexturePtr() != nullptr){
247
		ofVideoGrabber* mutThis = const_cast<ofVideoGrabber*>(this);
248
		mutThis->tex.clear();
249
		mutThis->tex.push_back(*grabber->getTexturePtr());
250
	}
251
	return tex;
252
}
253

254
//---------------------------------------------------------------------------
255
bool  ofVideoGrabber::isFrameNew() const{
256
	if(grabber){
257
		return grabber->isFrameNew();
258
	}
259
	return false;
260
}
261

262
//--------------------------------------------------------------------
263
void ofVideoGrabber::update(){
264
	if(grabber){
265
		grabber->update();
266
		if( bUseTexture && !grabber->getTexturePtr() && grabber->isFrameNew() ){
267
			if(tex.size()!=grabber->getPixels().getNumPlanes()){
268
				tex.resize(grabber->getPixels().getNumPlanes());
269
			}
270
			for(std::size_t i=0;i<grabber->getPixels().getNumPlanes();i++){
271
				ofPixels plane = grabber->getPixels().getPlane(i);
272
				bool bDiffPixFormat = ( tex[i].isAllocated() && tex[i].texData.glInternalFormat != ofGetGLInternalFormatFromPixelFormat(plane.getPixelFormat()) );
273
				if(bDiffPixFormat || !tex[i].isAllocated() ){
274
					tex[i].allocate(plane);
275
				}else{
276
					tex[i].loadData(plane);
277
				}
278
			}
279
		}
280
	}
281
}
282

283
//--------------------------------------------------------------------
284
void ofVideoGrabber::close(){
285
	if(grabber){
286
		grabber->close();
287
	}
288
	tex.clear();
289
}
290

291
//--------------------------------------------------------------------
292
void ofVideoGrabber::videoSettings(void){
293
	if(grabber){
294
		grabber->videoSettings();
295
	}
296
}
297

298
//------------------------------------
299
void ofVideoGrabber::setUseTexture(bool bUse){
300
	bUseTexture = bUse;
301
}
302

303
//------------------------------------
304
bool ofVideoGrabber::isUsingTexture() const{
305
	return bUseTexture;
306
}
307

308

309
//----------------------------------------------------------
310
void ofVideoGrabber::setAnchorPercent(float xPct, float yPct){
311
	getTexture().setAnchorPercent(xPct, yPct);
312
}
313

314
//----------------------------------------------------------
315
void ofVideoGrabber::setAnchorPoint(float x, float y){
316
	getTexture().setAnchorPoint(x, y);
317
}
318

319
//----------------------------------------------------------
320
void ofVideoGrabber::resetAnchor(){
321
	getTexture().resetAnchor();
322
}
323

324
//------------------------------------
325
void ofVideoGrabber::draw(float _x, float _y, float _w, float _h) const{
326
	ofGetCurrentRenderer()->draw(*this,_x,_y,_w,_h);
327
}
328

329
//------------------------------------
330
void ofVideoGrabber::draw(float _x, float _y) const{
331
	draw(_x, _y,getWidth(),getHeight());
332
}
333

334

335
//------------------------------------
336
void ofVideoGrabber::bind() const{
337
	shared_ptr<ofBaseGLRenderer> renderer = ofGetGLRenderer();
338
	if(renderer){
339
		renderer->bind(*this);
340
	}
341
}
342

343
//------------------------------------
344
void ofVideoGrabber::unbind() const{
345
	shared_ptr<ofBaseGLRenderer> renderer = ofGetGLRenderer();
346
	if(renderer){
347
		renderer->unbind(*this);
348
	}
349
}
350

351
//----------------------------------------------------------
352
float ofVideoGrabber::getHeight() const{
353
	if(grabber){
354
		return grabber->getHeight();
355
	}else{
356
		return 0;
357
	}
358
}
359

360
//----------------------------------------------------------
361
float ofVideoGrabber::getWidth() const{
362
	if(grabber){
363
		return grabber->getWidth();
364
	}else{
365
		return 0;
366
	}
367
}
368

369
//----------------------------------------------------------
370
bool ofVideoGrabber::isInitialized() const{
371
	return grabber && grabber->isInitialized() && (!bUseTexture || tex[0].isAllocated() || grabber->getTexturePtr());
372
}
373