framework2

1
#include "ofVideoPlayer.h"
2
#include "ofAppRunner.h"
3
#include "ofGLUtils.h"
4
#include "ofPixels.h"
5
#include <algorithm>
6

7
using std::shared_ptr;
8
using std::vector;
9
using std::string;
10

11

12
#ifdef OF_VIDEO_PLAYER_GSTREAMER
13
	#include "ofGstVideoPlayer.h"
14
	#define OF_VID_PLAYER_TYPE ofGstVideoPlayer
15
#endif
16

17
#ifdef OF_VIDEO_PLAYER_QUICKTIME
18
	#include "ofQuickTimePlayer.h"
19
	#define OF_VID_PLAYER_TYPE ofQuickTimePlayer
20
#endif
21

22
#ifdef OF_VIDEO_PLAYER_QTKIT
23
	#include "ofQTKitPlayer.h"
24
	#define OF_VID_PLAYER_TYPE ofQTKitPlayer
25
#endif
26

27
#ifdef OF_VIDEO_PLAYER_AVFOUNDATION
28
	#include "ofAVFoundationPlayer.h"
29
	#define OF_VID_PLAYER_TYPE ofAVFoundationPlayer
30
#endif
31

32
#ifdef OF_VIDEO_PLAYER_DIRECTSHOW
33
	#include "ofDirectShowPlayer.h"
34
	#define OF_VID_PLAYER_TYPE ofDirectShowPlayer
35
#endif
36

37
#if defined(OF_VIDEO_PLAYER_MEDIA_FOUNDATION)
38
	#include "ofMediaFoundationPlayer.h"
39
	#define OF_VID_PLAYER_TYPE ofMediaFoundationPlayer
40
#endif
41

42
#ifdef OF_VIDEO_PLAYER_IOS
43
	#include "ofxiOSVideoPlayer.h"
44
	#define OF_VID_PLAYER_TYPE ofxiOSVideoPlayer
45
#endif
46

47
#ifdef OF_VIDEO_PLAYER_ANDROID
48
	#include "ofxAndroidVideoPlayer.h"
49
	#define OF_VID_PLAYER_TYPE ofxAndroidVideoPlayer
50
#endif
51

52
#ifdef OF_VIDEO_PLAYER_EMSCRIPTEN
53
	#include "ofxEmscriptenVideoPlayer.h"
54
	#define OF_VID_PLAYER_TYPE ofxEmscriptenVideoPlayer
55
#endif
56

57

58
//---------------------------------------------------------------------------
59
ofVideoPlayer::ofVideoPlayer (){
60
	bUseTexture			= true;
61
	playerTex			= nullptr;
62
	internalPixelFormat = OF_PIXELS_RGB;
63
	tex.resize(1);
64
}
65

66
//---------------------------------------------------------------------------
67
void ofVideoPlayer::setPlayer(shared_ptr<ofBaseVideoPlayer> newPlayer){
68
	player = std::move(newPlayer);
69
	setPixelFormat(internalPixelFormat);	//this means that it will try to set the pixel format you have been using before. 
70
											//if the format is not supported ofVideoPlayer's internalPixelFormat will be updated to that of the player's
71
}
72

73
//---------------------------------------------------------------------------
74
shared_ptr<ofBaseVideoPlayer> ofVideoPlayer::getPlayer(){
75
	if( !player ){
76
		setPlayer(std::make_shared<OF_VID_PLAYER_TYPE>());
77
	}
78
	return player;
79
}
80

81
const shared_ptr<ofBaseVideoPlayer>	ofVideoPlayer::getPlayer() const{
82
	return player;
83
}
84

85
//we only set pixel format on the player if it exists. 
86
//if the movie is already loaded then we can't update the format.
87
//also if the format is not supported we get the format from the player instead.
88
//--------------------------------------------------------------------
89
bool ofVideoPlayer::setPixelFormat(ofPixelFormat pixelFormat) {
90
	if( player ){
91
		if( player->isLoaded() ){
92
			ofLogWarning("ofVideoPlayer") << "setPixelFormat(): can't set pixel format of a loaded movie";
93
			internalPixelFormat = player->getPixelFormat(); 
94
			return false;
95
		}else{
96
			if( player->setPixelFormat(pixelFormat) ){		
97
				internalPixelFormat = player->getPixelFormat();  //we do this as either way we want the players format
98
			}else{
99
				internalPixelFormat = player->getPixelFormat();  //we do this as either way we want the players format
100
				return false; 					
101
			}
102
		}
103
	}else{
104
		internalPixelFormat = pixelFormat;	
105
	}
106
	return true;
107
}
108

109
//---------------------------------------------------------------------------
110
ofPixelFormat ofVideoPlayer::getPixelFormat() const{
111
	if( player ){
112
		internalPixelFormat = player->getPixelFormat();
113
	}
114
	return internalPixelFormat;
115
}
116

117
//---------------------------------------------------------------------------
118
bool ofVideoPlayer::load(string name){
119
	if( !player ){
120
		setPlayer(std::make_shared<OF_VID_PLAYER_TYPE>());
121
		player->setPixelFormat(internalPixelFormat);
122
	}
123
	
124
	bool bOk = player->load(name);
125

126
	if( bOk){
127
        moviePath = name;
128
        if(bUseTexture){
129
        	if(player->getTexturePtr()==nullptr){
130
				if(tex.empty()) {
131
					tex.resize(std::max(player->getPixels().getNumPlanes(),static_cast<size_t>(1)));
132
					for(std::size_t i=0;i<player->getPixels().getNumPlanes();i++){
133
						ofPixels plane = player->getPixels().getPlane(i);
134
						tex[i].allocate(plane);
135
						if(ofIsGLProgrammableRenderer() && plane.getPixelFormat() == OF_PIXELS_GRAY){
136
							tex[i].setRGToRGBASwizzles(true);
137
						}
138
					}
139
				}
140
        	}else{
141
        		playerTex = player->getTexturePtr();
142
        	}
143
        }
144
		setLoopState(OF_LOOP_NORMAL);
145
    }
146
	
147
	return bOk;
148
}
149

150
//---------------------------------------------------------------------------
151
void ofVideoPlayer::loadAsync(string name){
152
	if( !player ){
153
		setPlayer(std::make_shared<OF_VID_PLAYER_TYPE>());
154
		player->setPixelFormat(internalPixelFormat);
155
	}
156
	
157
	player->loadAsync(name);
158
	moviePath = name;
159
}
160

161
//---------------------------------------------------------------------------
162
bool ofVideoPlayer::loadMovie(string name){
163
	return load(name);
164
}
165

166
//---------------------------------------------------------------------------
167
string ofVideoPlayer::getMoviePath() const{
168
    return moviePath;	
169
}
170

171
//---------------------------------------------------------------------------
172
ofPixels & ofVideoPlayer::getPixels(){
173
	return getPlayer()->getPixels();
174
}
175

176
//---------------------------------------------------------------------------
177
const ofPixels&	ofVideoPlayer::getPixels() const{
178
	return getPlayer()->getPixels();
179
}
180

181
//---------------------------------------------------------------------------
182
ofPixels& ofVideoPlayer::getPixelsRef(){
183
	return getPlayer()->getPixels();
184
}
185

186
//---------------------------------------------------------------------------
187
const ofPixels& ofVideoPlayer::getPixelsRef() const{
188
	return getPlayer()->getPixels();
189
}
190

191
//---------------------------------------------------------------------------
192
ofTexture & ofVideoPlayer::getTexture(){
193
	if(playerTex == nullptr){
194
		return tex[0];
195
	}else{
196
		return *playerTex;
197
	}
198
}
199

200
//---------------------------------------------------------------------------
201
const ofTexture & ofVideoPlayer::getTexture() const{
202
	if(playerTex == nullptr){
203
		return tex[0];
204
	}else{
205
		return *playerTex;
206
	}
207
}
208

209
//---------------------------------------------------------------------------
210
ofTexture & ofVideoPlayer::getTextureReference(){
211
	return getTexture();
212
}
213

214
//---------------------------------------------------------------------------
215
const ofTexture & ofVideoPlayer::getTextureReference() const{
216
	return getTexture();
217
}
218

219
//---------------------------------------------------------------------------
220
vector<ofTexture> & ofVideoPlayer::getTexturePlanes(){
221
	if(playerTex != nullptr){
222
		tex.clear();
223
		tex.push_back(*playerTex);
224
	}
225
	return tex;
226
}
227

228
//---------------------------------------------------------------------------
229
const vector<ofTexture> & ofVideoPlayer::getTexturePlanes() const{
230
	if(playerTex != nullptr){
231
		ofVideoPlayer * mutThis = const_cast<ofVideoPlayer*>(this);
232
		mutThis->tex.clear();
233
		mutThis->tex.push_back(*playerTex);
234
	}
235
	return tex;
236
}
237

238
//---------------------------------------------------------------------------
239
bool ofVideoPlayer::isFrameNew() const{
240
	if( player ){
241
		return player->isFrameNew();
242
	}
243
	return false;
244
}
245

246
//--------------------------------------------------------------------
247
void ofVideoPlayer::update(){
248
	if( player ){
249

250
		player->update();
251
		
252
		if( bUseTexture && player->isFrameNew() ) {
253
			
254
			playerTex = player->getTexturePtr();
255
			
256
			if(playerTex == nullptr){
257
				if(tex.size()!=player->getPixels().getNumPlanes()){
258
					tex.resize(std::max(player->getPixels().getNumPlanes(),static_cast<std::size_t>(1)));
259
				}
260
				if(std::size_t(player->getWidth()) != 0 && std::size_t(player->getHeight()) != 0) {
261
					for(std::size_t i=0;i<player->getPixels().getNumPlanes();i++){
262
						ofPixels plane = player->getPixels().getPlane(i);
263
						bool bDiffPixFormat = ( tex[i].isAllocated() && tex[i].texData.glInternalFormat != ofGetGLInternalFormatFromPixelFormat(plane.getPixelFormat()) );
264
						if(bDiffPixFormat || !tex[i].isAllocated() || std::size_t(tex[i].getWidth()) != plane.getWidth() || std::size_t(tex[i].getHeight()) != plane.getHeight())
265
						{
266
							tex[i].allocate(plane);
267
						}
268
						tex[i].loadData(plane);
269
					}
270
				}
271
			}
272
		}
273
	}
274
}
275

276
//---------------------------------------------------------------------------
277
void ofVideoPlayer::closeMovie(){
278
	close();
279
}
280

281
//---------------------------------------------------------------------------
282
void ofVideoPlayer::close(){
283
	if( player ){
284
		player->close();
285
	}
286
	tex.clear();
287
}
288

289
//--------------------------------------------------------
290
void ofVideoPlayer::play(){
291
	if( player ){
292
		player->play();
293
	}
294
}
295

296
//--------------------------------------------------------
297
void ofVideoPlayer::stop(){
298
	if( player ){
299
		player->stop();
300
	}
301
}
302

303
//--------------------------------------------------------
304
void ofVideoPlayer::setVolume(float volume){
305
	if( player ){
306
		if ( volume > 1.0f ){
307
			ofLogWarning("ofVideoPlayer") << "setVolume(): expected range is 0-1, limiting requested volume " << volume << " to 1.0";
308
			volume = 1.0f;
309
		}
310
		player->setVolume(volume);
311
	}
312
}
313

314

315
//--------------------------------------------------------
316
void ofVideoPlayer::setLoopState(ofLoopType state){
317
	if( player ){
318
		player->setLoopState(state);
319
	}
320
}
321

322
ofLoopType ofVideoPlayer::getLoopState() const{
323
	if( player ){
324
		return player->getLoopState();
325
	}else{
326
		return OF_LOOP_NONE;
327
	}
328
}
329

330
//---------------------------------------------------------------------------
331
void ofVideoPlayer::setPosition(float pct){
332
	if( player ){
333
		player->setPosition(pct);
334
	}
335
}
336

337
//---------------------------------------------------------------------------
338
void ofVideoPlayer::setFrame(int frame){
339
	if( player ){
340
		player->setFrame(frame);
341
	}
342
}
343

344

345
//---------------------------------------------------------------------------
346
float ofVideoPlayer::getDuration() const{
347
	if( player ){
348
		return player->getDuration();
349
	}
350
	
351
	return 0.0;
352
}
353

354
//---------------------------------------------------------------------------
355
float ofVideoPlayer::getPosition() const{
356
	if( player ){
357
		return player->getPosition();
358
	}
359
	return 0.0;
360
}
361

362
//---------------------------------------------------------------------------
363
int ofVideoPlayer::getCurrentFrame() const{
364
	if( player ){
365
		return player->getCurrentFrame();
366
	}
367
	return 0;
368
}
369

370

371
//---------------------------------------------------------------------------
372
bool ofVideoPlayer::getIsMovieDone() const{
373
	if( player ){
374
		return player->getIsMovieDone();
375
	}
376
	return false;
377
}
378

379
//---------------------------------------------------------------------------
380
void ofVideoPlayer::firstFrame(){
381
	if( player ){
382
		player->firstFrame();
383
	}
384
}
385

386
//---------------------------------------------------------------------------
387
void ofVideoPlayer::nextFrame(){
388
	if( player ){
389
		player->nextFrame();
390
	}
391
}
392

393
//---------------------------------------------------------------------------
394
void ofVideoPlayer::previousFrame(){
395
	if( player ){
396
		player->previousFrame();
397
	}
398
}
399

400
//---------------------------------------------------------------------------
401
void ofVideoPlayer::setSpeed(float _speed){
402
	if( player ){
403
		player->setSpeed(_speed);
404
	}
405
}
406

407
//---------------------------------------------------------------------------
408
float ofVideoPlayer::getSpeed() const{
409
	if( player ){
410
		return player->getSpeed();
411
	}
412
	return 0.0;
413
}
414

415
//---------------------------------------------------------------------------
416
void ofVideoPlayer::setPaused(bool _bPause){
417
	if( player ){
418
		player->setPaused(_bPause);
419
	}
420
}
421

422
//------------------------------------
423
void ofVideoPlayer::setUseTexture(bool bUse){
424
	bUseTexture = bUse;
425
	if(bUse && player && !player->getTexturePtr() && std::size_t(getWidth()) != 0 && std::size_t(getHeight()) != 0){
426
		for(std::size_t i=0;i<player->getPixels().getNumPlanes();i++){
427
			ofPixels plane = player->getPixels().getPlane(i);
428
			bool bDiffPixFormat = ( tex[i].isAllocated() && tex[i].texData.glInternalFormat != ofGetGLInternalFormatFromPixelFormat(plane.getPixelFormat()) );
429
			if(!tex[i].isAllocated() || bDiffPixFormat){
430
				tex[i].allocate(plane);
431
			}
432
		}
433
	}
434
}
435

436
//------------------------------------
437
bool ofVideoPlayer::isUsingTexture() const{
438
	return bUseTexture;
439
}
440

441
//----------------------------------------------------------
442
void ofVideoPlayer::setAnchorPercent(float xPct, float yPct){
443
	getTexture().setAnchorPercent(xPct, yPct);
444
}
445

446
//----------------------------------------------------------
447
void ofVideoPlayer::setAnchorPoint(float x, float y){
448
	getTexture().setAnchorPoint(x, y);
449
}
450

451
//----------------------------------------------------------
452
void ofVideoPlayer::resetAnchor(){
453
	getTexture().resetAnchor();
454
}
455

456
//------------------------------------
457
void ofVideoPlayer::draw(float _x, float _y, float _w, float _h) const{
458
	ofGetCurrentRenderer()->draw(*this,_x,_y,_w,_h);
459
}
460

461
//------------------------------------
462
void ofVideoPlayer::draw(float _x, float _y) const{
463
	draw(_x, _y, getWidth(), getHeight());
464
}
465

466

467
//------------------------------------
468
void ofVideoPlayer::bind() const{
469
	shared_ptr<ofBaseGLRenderer> renderer = ofGetGLRenderer();
470
	if(renderer){
471
		renderer->bind(*this);
472
	}
473
}
474

475
//------------------------------------
476
void ofVideoPlayer::unbind() const{
477
	shared_ptr<ofBaseGLRenderer> renderer = ofGetGLRenderer();
478
	if(renderer){
479
		renderer->unbind(*this);
480
	}
481
}
482

483
//------------------------------------
484
int ofVideoPlayer::getTotalNumFrames() const{
485
	if( player ){
486
		return player->getTotalNumFrames();
487
	}
488
	return 0;
489
}
490

491
//----------------------------------------------------------
492
float ofVideoPlayer::getWidth() const{
493
	if( player ){
494
		return player->getWidth();
495
	}else{
496
		return 0;
497
	}
498
}
499

500
//----------------------------------------------------------
501
float ofVideoPlayer::getHeight() const{
502
	if( player ){
503
		return player->getHeight();
504
	}else{
505
		return 0;
506
	}
507
}
508

509
//----------------------------------------------------------
510
bool ofVideoPlayer::isPaused() const{
511
	if( player ){
512
		return player->isPaused();
513
	}
514
	return false;
515
}
516

517
//----------------------------------------------------------
518
bool ofVideoPlayer::isLoaded() const{
519
	if( player ){
520
		return player->isLoaded();
521
	}
522
	return false;
523
}
524

525
//----------------------------------------------------------
526
bool ofVideoPlayer::isPlaying() const{
527
	if( player ){
528
		return player->isPlaying();
529
	}
530
	return false;
531
}
532

533
//----------------------------------------------------------
534
bool ofVideoPlayer::isInitialized() const{
535
	if( player ){
536
		return player->isInitialized() && (!bUseTexture || tex[0].isAllocated() || (player->getTexturePtr() && player->getTexturePtr()->isAllocated()) );
537
	}
538
	return false;
539
}
540

541

542