opengles_display.c 18.9 KB
Newer Older
Yann Diorcet's avatar
Yann Diorcet committed
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 opengles_display.m
 Copyright (C) 2011 Belledonne Communications, Grenoble, France

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include "opengles_display.h"
#include "mediastreamer2/mscommon.h"
#include "shaders.h"

24
enum ImageType {
25 26 27
	REMOTE_IMAGE = 0,
	PREVIEW_IMAGE,
	MAX_IMAGE
28
};
29 30 31 32

/* helper functions */
static void check_GL_errors(const char* context);
static bool_t load_shaders(GLuint* program, GLint* uniforms);
33
static void allocate_gl_textures(struct opengles_display* gldisp, int w, int h, enum ImageType type);
34 35
static void load_orthographic_matrix(float left, float right, float bottom, float top, float near, float far, float* mat);
static unsigned int align_on_power_of_2(unsigned int value);
36
static bool_t update_textures_with_yuv(struct opengles_display* gldisp, enum ImageType type);
37 38


39
//#define CHECK_GL_ERROR
40 41 42 43 44 45

#ifdef CHECK_GL_ERROR
	#define GL_OPERATION(x)	\
		(x); \
		check_GL_errors(#x);
#else
46 47
	#define GL_OPERATION(x) \
		(x);
48 49 50
#endif

enum {
51 52 53 54 55 56
	UNIFORM_PROJ_MATRIX = 0,
	UNIFORM_ROTATION,
	UNIFORM_TEXTURE_Y,
	UNIFORM_TEXTURE_U,
	UNIFORM_TEXTURE_V,
	NUM_UNIFORMS
57 58 59
};

enum {
60 61 62
	ATTRIB_VERTEX = 0,
	ATTRIB_UV,
	NUM_ATTRIBS
63 64 65
};

enum {
66 67 68
	Y,
	U,
	V
69 70
};

71 72
#define TEXTURE_BUFFER_SIZE 3

73
struct opengles_display {
74 75
	/* input: yuv image to display */
	ms_mutex_t yuv_mutex;
76 77
	mblk_t *yuv[MAX_IMAGE];
	bool_t new_yuv_image[TEXTURE_BUFFER_SIZE][MAX_IMAGE];
78 79 80

	/* GL resources */
	bool_t glResourcesInitialized;
81
	GLuint program, textures[TEXTURE_BUFFER_SIZE][MAX_IMAGE][3];
82
	GLint uniforms[NUM_UNIFORMS];
83
	MSVideoSize allocatedTexturesSize[MAX_IMAGE];
84

85
	int texture_index;
86

87 88 89 90 91
	/* GL view size */
	GLint backingWidth;
	GLint backingHeight;

	/* runtime data */
92
	float uvx[MAX_IMAGE], uvy[MAX_IMAGE];
93
	MSVideoSize yuv_size[MAX_IMAGE];
94 95

	/* coordinates of for zoom-in */
96 97 98
	float zoom_factor;
	float zoom_cx;
	float zoom_cy;
99 100 101 102 103 104 105 106 107 108
};

struct opengles_display* ogl_display_new() {
	struct opengles_display* result =
		(struct opengles_display*) malloc(sizeof(struct opengles_display));
	if (result == 0) {
		ms_error("Could not allocate OpenGL display structure\n");
		return 0;
	}
	memset(result, 0, sizeof(struct opengles_display));
109 110
	result->zoom_factor = 1;
	result->zoom_cx = result->zoom_cy = 0;
111
	result->texture_index = 0;
112 113

	ms_mutex_init(&result->yuv_mutex, NULL);
114
	ms_message("%s : %p\n", __FUNCTION__, result);
115 116 117 118
	return result;
}

void ogl_display_free(struct opengles_display* gldisp) {
119
	int i;
120

121 122 123 124
	if (!gldisp) {
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
125

126 127 128 129 130 131
	for(i=0; i<MAX_IMAGE; i++) {
		if (gldisp->yuv[i]) {
			ms_free(gldisp->yuv[i]);
			gldisp->yuv[i] = NULL;
		}
	}
132 133 134 135 136
	ms_mutex_destroy(&gldisp->yuv_mutex);

	free(gldisp);
}

137
void ogl_display_set_size(struct opengles_display* gldisp, int width, int height) {
138
	gldisp->backingWidth = width;
139
	gldisp->backingHeight = height;
140
	ms_message("resize opengles_display (%d x %d, gl initialized:%d)", width, height, gldisp->glResourcesInitialized);
141

142
	GL_OPERATION(glViewport(0, 0, gldisp->backingWidth, gldisp->backingHeight));
143

144
	check_GL_errors("ogl_display_set_size");
145 146
}

147
void ogl_display_init(struct opengles_display* gldisp, int width, int height) {
148
	int i,j;
149
	static bool_t version_displayed = FALSE;
150
	if (!gldisp) {
151 152 153 154
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}

155
	ms_message("init opengles_display (%d x %d, gl initialized:%d)", width, height, gldisp->glResourcesInitialized);
156 157

	GL_OPERATION(glDisable(GL_DEPTH_TEST))
158
	GL_OPERATION(glClearColor(0, 0, 0, 1))
159

160
	ogl_display_set_size(gldisp, width, height);
161

162 163 164
	if (gldisp->glResourcesInitialized)
		return;

165 166 167 168 169 170 171
	for(j=0; j<TEXTURE_BUFFER_SIZE; j++) {
		// init textures
		for(i=0; i<MAX_IMAGE; i++) {
			GL_OPERATION(glGenTextures(3, gldisp->textures[j][i]))
			gldisp->allocatedTexturesSize[i].width = gldisp->allocatedTexturesSize[i].height = 0;
		}
	}
172

173 174 175 176 177 178 179 180 181
	if (!version_displayed) {
		version_displayed = TRUE;
		ms_message("OpenGL version string: %s", glGetString(GL_VERSION));
		ms_message("OpenGL extensions: %s",glGetString(GL_EXTENSIONS));
		ms_message("OpenGL vendor: %s", glGetString(GL_VENDOR));
		ms_message("OpenGL renderer: %s", glGetString(GL_RENDERER));
		ms_message("OpenGL version: %s", glGetString(GL_VERSION));
		ms_message("OpenGL GLSL version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
	}
182
	load_shaders(&gldisp->program, gldisp->uniforms);
183

184
	GL_OPERATION(glUseProgram(gldisp->program))
185 186

	gldisp->glResourcesInitialized = TRUE;
187

188
	check_GL_errors("ogl_display_init");
189 190
}

191
void ogl_display_uninit(struct opengles_display* gldisp, bool_t freeGLresources) {
192
	int i,j;
193

194
	if (!gldisp) {
195 196 197
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
198
	ms_message("uninit opengles_display (gl initialized:%d)\n", gldisp->glResourcesInitialized);
199 200 201 202 203 204
	for(i=0; i<MAX_IMAGE; i++) {
		if (gldisp->yuv[i]) {
			ms_free(gldisp->yuv[i]);
			gldisp->yuv[i] = NULL;
		}
	}
205

206
	if (gldisp->glResourcesInitialized && freeGLresources) {
207 208 209 210 211 212 213
		// destroy gl resources
		for(j=0; j<TEXTURE_BUFFER_SIZE; j++) {
			for(i=0; i<MAX_IMAGE; i++) {
				GL_OPERATION(glDeleteTextures(3, gldisp->textures[j][i]));
				gldisp->allocatedTexturesSize[i].width = gldisp->allocatedTexturesSize[i].height = 0;
			}
		}
214
		GL_OPERATION(glDeleteProgram(gldisp->program));
215
	}
216

217
	gldisp->glResourcesInitialized = FALSE;
218

219
	check_GL_errors("ogl_display_uninit");
220 221
}

222
static void ogl_display_set_yuv(struct opengles_display* gldisp, mblk_t *yuv, enum ImageType type) {
223
	int j;
224 225 226 227
	if (!gldisp) {
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
228
	ms_mutex_lock(&gldisp->yuv_mutex);
229
	if (gldisp->yuv[type])
230 231
		freemsg(gldisp->yuv[type]);
	gldisp->yuv[type] = dupmsg(yuv);
232 233 234
	for(j = 0; j < TEXTURE_BUFFER_SIZE; ++j) {
		gldisp->new_yuv_image[j][type] = TRUE;
	}
235 236

	ms_mutex_unlock(&gldisp->yuv_mutex);
237 238
}

239 240 241 242 243 244 245 246
void ogl_display_set_yuv_to_display(struct opengles_display* gldisp, mblk_t *yuv) {
	ogl_display_set_yuv(gldisp, yuv, REMOTE_IMAGE);
}

void ogl_display_set_preview_yuv_to_display(struct opengles_display* gldisp, mblk_t *yuv) {
	ogl_display_set_yuv(gldisp, yuv, PREVIEW_IMAGE);
}

247
static void ogl_display_render_type(struct opengles_display* gldisp, enum ImageType type, bool_t clear, float vpx, float vpy, float vpw, float vph, int orientation) {
248 249 250 251 252 253 254 255 256
	float uLeft, uRight, vTop, vBottom;
	GLfloat squareUvs[8];
	GLfloat squareVertices[8];
	int screenW, screenH;
	int x,y,w,h;
	GLfloat mat[16];
	float rad;

	if (!gldisp) {
257 258 259
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
260
	if (!gldisp->yuv[type] || !gldisp->glResourcesInitialized) {
261
		return;
262
	}
263

264
	ms_mutex_lock(&gldisp->yuv_mutex);
265
	if (gldisp->new_yuv_image[gldisp->texture_index][type]) {
266
		update_textures_with_yuv(gldisp, type);
267
		gldisp->new_yuv_image[gldisp->texture_index][type] = FALSE;
268 269
	}
	ms_mutex_unlock(&gldisp->yuv_mutex);
270

271

272 273
	uLeft = vBottom = 0.0f;
	uRight = gldisp->uvx[type];
274 275 276 277 278 279 280 281 282 283 284 285
	vTop = gldisp->uvy[type];

	squareUvs[0] = uLeft;
	squareUvs[1] =  vTop;
	squareUvs[2] = uRight;
	squareUvs[3] =  vTop;
	squareUvs[4] = uLeft;
	squareUvs[5] =  vBottom;
	squareUvs[6] = uRight;
	squareUvs[7] = vBottom;


286 287 288
	if (clear) {
		GL_OPERATION(glClear(GL_COLOR_BUFFER_BIT))
	}
289 290


291
	// drawing surface dimensions
292 293
	screenW = gldisp->backingWidth;
	screenH = gldisp->backingHeight;
294 295
	if (orientation == 90 || orientation == 270) {
		screenW = screenH;
296
		screenH = gldisp->backingWidth;
297 298 299
	}

	// Fill the smallest dimension, then compute the other one using the image ratio
Simon Morlat's avatar
Simon Morlat committed
300
	if (screenW <= screenH) {
301
		float ratio = (gldisp->yuv_size[type].height) / (float)(gldisp->yuv_size[type].width);
Simon Morlat's avatar
Simon Morlat committed
302
		w = screenW * vpw;
303
		h = w * ratio;
304 305 306 307
		if (h > screenH) {
			w *= screenH /(float) h;
			h = screenH;
		}
308
		x = vpx * gldisp->backingWidth;
309
		y = vpy * gldisp->backingHeight;
310
	} else {
311
		float ratio = gldisp->yuv_size[type].width / (float)gldisp->yuv_size[type].height;
Simon Morlat's avatar
Simon Morlat committed
312
		h = screenH * vph;
313
		w = h * ratio;
314 315 316 317
		if (w > screenW) {
			h *= screenW / (float)w;
			w = screenW;
		}
318 319
		x = vpx * screenW;
		y = vpy * screenH;
320
	}
321

322 323 324 325 326 327 328 329
	squareVertices[0] = (x - w * 0.5) / screenW - 0.;
	squareVertices[1] = (y - h * 0.5) / screenH - 0.;
	squareVertices[2] = (x + w * 0.5) / screenW - 0.;
	squareVertices[3] = (y - h * 0.5) / screenH - 0.;
	squareVertices[4] = (x - w * 0.5) / screenW - 0.;
	squareVertices[5] = (y + h * 0.5) / screenH - 0.;
	squareVertices[6] = (x + w * 0.5) / screenW - 0.;
	squareVertices[7] = (y + h * 0.5) / screenH - 0.;
330

331 332 333 334
	#define VP_SIZE 1.0f
	if (type == REMOTE_IMAGE) {
		float scale_factor = 1.0 / gldisp->zoom_factor;
		float vpDim = (VP_SIZE * scale_factor) / 2;
335

336 337 338 339 340 341 342 343 344
		#define ENSURE_RANGE_A_INSIDE_RANGE_B(a, aSize, bMin, bMax) \
		if (2*aSize >= (bMax - bMin)) \
			a = 0; \
		else if ((a - aSize < bMin) || (a + aSize > bMax)) {  \
			float diff; \
			if (a - aSize < bMin) diff = bMin - (a - aSize); \
			else diff = bMax - (a + aSize); \
			a += diff; \
		}
345

346 347
		ENSURE_RANGE_A_INSIDE_RANGE_B(gldisp->zoom_cx, vpDim, squareVertices[0], squareVertices[2])
		ENSURE_RANGE_A_INSIDE_RANGE_B(gldisp->zoom_cy, vpDim, squareVertices[1], squareVertices[7])
348

349
		load_orthographic_matrix(
350 351 352 353
			gldisp->zoom_cx - vpDim,
			gldisp->zoom_cx + vpDim,
			gldisp->zoom_cy - vpDim,
			gldisp->zoom_cy + vpDim,
354 355 356 357
			0, 0.5, mat);
	} else {
		load_orthographic_matrix(- VP_SIZE * 0.5, VP_SIZE * 0.5, - VP_SIZE * 0.5, VP_SIZE * 0.5, 0, 0.5, mat);
	}
358

359
	GL_OPERATION(glUniformMatrix4fv(gldisp->uniforms[UNIFORM_PROJ_MATRIX], 1, GL_FALSE, mat))
360 361 362

	rad = (2.0 * 3.14157 * orientation / 360.0); // Convert orientation to radian

363
	GL_OPERATION(glUniform1f(gldisp->uniforms[UNIFORM_ROTATION], rad))
364

365
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
366
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][Y]))
367
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_Y], 0))
368
	GL_OPERATION(glActiveTexture(GL_TEXTURE1))
369
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][U]))
370
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_U], 1))
371
	GL_OPERATION(glActiveTexture(GL_TEXTURE2))
372
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][V]))
373
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_V], 2))
374

375 376 377 378
	GL_OPERATION(glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices))
	GL_OPERATION(glEnableVertexAttribArray(ATTRIB_VERTEX))
	GL_OPERATION(glVertexAttribPointer(ATTRIB_UV, 2, GL_FLOAT, 1, 0, squareUvs))
	GL_OPERATION(glEnableVertexAttribArray(ATTRIB_UV))
379 380 381

	GL_OPERATION(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4))

382
	check_GL_errors("ogl_display_render_type");
383

384
}
385

386
void ogl_display_render(struct opengles_display* gldisp, int orientation) {
387 388 389
	ogl_display_render_type(gldisp, REMOTE_IMAGE, TRUE, 0, 0, 1, 1, orientation);
	// preview image already have the correct orientation
	ogl_display_render_type(gldisp, PREVIEW_IMAGE, FALSE, 0.4f, -0.4f, 0.2f, 0.2f, 0);
390

391
	gldisp->texture_index = (gldisp->texture_index + 1) % TEXTURE_BUFFER_SIZE;
392 393 394
}

static void check_GL_errors(const char* context) {
395
	 int maxIterations=10;
396 397 398 399 400 401 402 403 404 405 406 407 408
	GLenum error;
	while (((error = glGetError()) != GL_NO_ERROR) && maxIterations > 0)
	{
		switch(error)
		{
			case GL_INVALID_ENUM:  ms_error("[%2d]GL error: '%s' -> GL_INVALID_ENUM\n", maxIterations, context); break;
			case GL_INVALID_VALUE: ms_error("[%2d]GL error: '%s' -> GL_INVALID_VALUE\n", maxIterations, context); break;
			case GL_INVALID_OPERATION: ms_error("[%2d]GL error: '%s' -> GL_INVALID_OPERATION\n", maxIterations, context); break;
			case GL_OUT_OF_MEMORY: ms_error("[%2d]GL error: '%s' -> GL_OUT_OF_MEMORY\n", maxIterations, context); break;
			case GL_INVALID_FRAMEBUFFER_OPERATION: ms_error("[%2d]GL error: '%s' -> GL_INVALID_FRAMEBUFFER_OPERATION\n", maxIterations, context); break;
			default:
				ms_error("[%2d]GL error: '%s' -> %x\n", maxIterations, context, error);
		}
409
		  maxIterations--;
410
	}
411 412 413
}

static bool_t load_shaders(GLuint* program, GLint* uniforms) {
414
	GLuint vertShader, fragShader;
415 416
#include "yuv2rgb.vs.h"
#include "yuv2rgb.fs.h"
Simon Morlat's avatar
Simon Morlat committed
417 418
	(void)yuv2rgb_vs_len;
	(void)yuv2rgb_fs_len;
419

420
	*program = glCreateProgram();
421

422 423 424 425
	if (!compileShader(&vertShader, GL_VERTEX_SHADER, (const char*)yuv2rgb_vs))
		return FALSE;
	if (!compileShader(&fragShader, GL_FRAGMENT_SHADER, (const char*)yuv2rgb_fs))
		return FALSE;
426

427 428
	GL_OPERATION(glAttachShader(*program, vertShader))
	GL_OPERATION(glAttachShader(*program, fragShader))
429

430 431
	GL_OPERATION(glBindAttribLocation(*program, ATTRIB_VERTEX, "position"))
	GL_OPERATION(glBindAttribLocation(*program, ATTRIB_UV, "uv"))
432

433 434
	if (!linkProgram(*program))
		return FALSE;
435

436 437 438 439 440
	uniforms[UNIFORM_PROJ_MATRIX] = glGetUniformLocation(*program, "proj_matrix");
	uniforms[UNIFORM_ROTATION] = glGetUniformLocation(*program, "rotation");
	uniforms[UNIFORM_TEXTURE_Y] = glGetUniformLocation(*program, "t_texture_y");
	uniforms[UNIFORM_TEXTURE_U] = glGetUniformLocation(*program, "t_texture_u");
	uniforms[UNIFORM_TEXTURE_V] = glGetUniformLocation(*program, "t_texture_v");
441

442 443
	glDeleteShader(vertShader);
	glDeleteShader(fragShader);
444

445
	return TRUE;
446

447
	check_GL_errors("load_shaders");
448 449 450 451
}

static void load_orthographic_matrix(float left, float right, float bottom, float top, float near, float far, float* mat)
{
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
	float r_l = right - left;
	float t_b = top - bottom;
	float f_n = far - near;
	float tx = - (right + left) / (right - left);
	float ty = - (top + bottom) / (top - bottom);
	float tz = - (far + near) / (far - near);

	mat[0] = (2.0f / r_l);
	mat[1] = mat[2] = mat[3] = 0.0f;

	mat[4] = 0.0f;
	mat[5] = (2.0f / t_b);
	mat[6] = mat[7] = 0.0f;

	mat[8] = mat[9] = 0.0f;
	mat[10] = -2.0f / f_n;
	mat[11] = 0.0f;

	mat[12] = tx;
	mat[13] = ty;
	mat[14] = tz;
	mat[15] = 1.0f;
474 475
}

476
static void allocate_gl_textures(struct opengles_display* gldisp, int w, int h, enum ImageType type) {
477 478
	int j;
	for(j=0; j<TEXTURE_BUFFER_SIZE; j++) {
479
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
480
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][Y]))
481 482 483 484 485 486 487
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0))

	GL_OPERATION(glActiveTexture(GL_TEXTURE1))
488
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][U]))
489 490 491 492 493 494 495
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w >> 1, h >> 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0))

	GL_OPERATION(glActiveTexture(GL_TEXTURE2))
496
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][V]))
497 498 499 500 501 502
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE))
	GL_OPERATION(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w >> 1, h >> 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0))

503
	}
504 505
	gldisp->allocatedTexturesSize[type].width =  w;
	gldisp->allocatedTexturesSize[type].height =  h;
506

507
	ms_message("%s: allocated new textures[%d] (%d x %d)\n", __FUNCTION__, type, w, h);
508

509
	check_GL_errors("allocate_gl_textures");
510 511 512 513 514 515 516 517 518 519 520 521 522
}

static unsigned int align_on_power_of_2(unsigned int value) {
	int i;
	/* browse all power of 2 value, and find the one just >= value */
	for(i=0; i<32; i++) {
		unsigned int c = 1 << i;
		if (value <= c)
			return c;
	}
	return 0;
}

523
static bool_t update_textures_with_yuv(struct opengles_display* gldisp, enum ImageType type) {
524 525 526
	unsigned int aligned_yuv_w, aligned_yuv_h;
	MSPicture yuvbuf;

527
	ms_yuv_buf_init_from_mblk(&yuvbuf, gldisp->yuv[type]);
528 529 530 531 532 533 534 535 536

	if (yuvbuf.w == 0 || yuvbuf.h == 0) {
		ms_warning("Incoherent image size: %dx%d\n", yuvbuf.w, yuvbuf.h);
		return FALSE;
	}
	aligned_yuv_w = align_on_power_of_2(yuvbuf.w);
	aligned_yuv_h = align_on_power_of_2(yuvbuf.h);

	/* check if we need to adjust texture sizes */
537 538 539
	if (aligned_yuv_w != gldisp->allocatedTexturesSize[type].width ||
		aligned_yuv_h != gldisp->allocatedTexturesSize[type].height) {
		allocate_gl_textures(gldisp, aligned_yuv_w, aligned_yuv_h, type);
540
	}
541 542
	gldisp->uvx[type] = yuvbuf.w / (float)(gldisp->allocatedTexturesSize[type].width+1);
	gldisp->uvy[type] = yuvbuf.h / (float)(gldisp->allocatedTexturesSize[type].height+1);
543 544 545

	/* upload Y plane */
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
546
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][Y]))
547 548 549 550 551 552 553
	GL_OPERATION(glTexSubImage2D(GL_TEXTURE_2D, 0,
			0, 0, yuvbuf.w, yuvbuf.h,
			GL_LUMINANCE, GL_UNSIGNED_BYTE, yuvbuf.planes[Y]))
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_Y], 0))

	/* upload U plane */
	GL_OPERATION(glActiveTexture(GL_TEXTURE1))
554
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][U]))
555 556 557 558 559 560 561
	GL_OPERATION(glTexSubImage2D(GL_TEXTURE_2D, 0,
			0, 0, yuvbuf.w >> 1, yuvbuf.h >> 1,
			GL_LUMINANCE, GL_UNSIGNED_BYTE, yuvbuf.planes[U]))
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_U], 1))

	/* upload V plane */
	GL_OPERATION(glActiveTexture(GL_TEXTURE2))
562
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][V]))
563 564 565 566 567
	GL_OPERATION(glTexSubImage2D(GL_TEXTURE_2D, 0,
			0, 0, yuvbuf.w >> 1, yuvbuf.h >> 1,
			GL_LUMINANCE, GL_UNSIGNED_BYTE, yuvbuf.planes[V]))
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_V], 2))

568 569
	gldisp->yuv_size[type].width = yuvbuf.w;
	gldisp->yuv_size[type].height = yuvbuf.h;
570

571
	check_GL_errors("update_textures_with_yuv");
572

573 574 575
	return TRUE;
}

576 577 578 579
void ogl_display_zoom(struct opengles_display* gldisp, float* params) {
	gldisp->zoom_factor = params[0];
	gldisp->zoom_cx = params[1] - 0.5;
	gldisp->zoom_cy = params[2] - 0.5;
580 581
}

582
#ifdef ANDROID
583
JNIEXPORT void JNICALL Java_org_linphone_mediastream_video_display_OpenGLESDisplay_init(JNIEnv * env, jobject obj, jint ptr, jint width, jint height) {
584 585 586 587
	struct opengles_display* d = (struct opengles_display*) ptr;
	ogl_display_init(d, width, height);
}

588
JNIEXPORT void JNICALL Java_org_linphone_mediastream_video_display_OpenGLESDisplay_render(JNIEnv * env, jobject obj, jint ptr) {
589
	struct opengles_display* d = (struct opengles_display*) ptr;
590
	ogl_display_render(d, 0);
591 592
}
#endif