opengles_display.c 18.8 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 86
	int texture_index;
	
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 120
	int i;
	
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 141 142 143 144
	ms_message("resize opengles_display (%d x %d, gl initialized:%d)", width, height, gldisp->glResourcesInitialized);
 
	GL_OPERATION(glViewport(0, 0, gldisp->backingWidth, gldisp->backingHeight));
	
	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 161
	ogl_display_set_size(gldisp, width, height);
	
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 193 194
	int i,j;
	
	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 224 225 226
	if (!gldisp) {
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
227
	ms_mutex_lock(&gldisp->yuv_mutex);
228
	if (gldisp->yuv[type])
229 230
		freemsg(gldisp->yuv[type]);
	gldisp->yuv[type] = dupmsg(yuv);
231 232 233 234 235 236
	int j;
	for(j = 0; j < TEXTURE_BUFFER_SIZE; ++j) {
		gldisp->new_yuv_image[j][type] = TRUE;
	}
	
	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
 	if (!gldisp) {
249 250 251
		ms_error("%s called with null struct opengles_display", __FUNCTION__);
		return;
	}
252
	if (!gldisp->yuv[type] || !gldisp->glResourcesInitialized) {
253
		return;
254
	}
255
	
256
	ms_mutex_lock(&gldisp->yuv_mutex);
257
	if (gldisp->new_yuv_image[gldisp->texture_index][type]) {
258
		update_textures_with_yuv(gldisp, type);
259
		gldisp->new_yuv_image[gldisp->texture_index][type] = FALSE;
260 261
	}
	ms_mutex_unlock(&gldisp->yuv_mutex);
262
	
263 264
	float uLeft, uRight, vTop, vBottom;

265 266 267
	uLeft = vBottom = 0.0f;
	uRight = gldisp->uvx[type];
	vTop = gldisp->uvy[type]; 
268

269
	GLfloat squareUvs[] = {
270 271 272 273
		uLeft, vTop,
		uRight, vTop,
		uLeft, vBottom,
		uRight, vBottom
274 275 276 277 278 279 280 281
	};
	
	if (clear) {
		GL_OPERATION(glClear(GL_COLOR_BUFFER_BIT))
	}
	
	GLfloat squareVertices[8];
	
282 283
	// drawing surface dimensions
	int screenW = gldisp->backingWidth;
284
	int screenH = gldisp->backingHeight;	
285 286
	if (orientation == 90 || orientation == 270) {
		screenW = screenH;
287
		screenH = gldisp->backingWidth;			
288 289
	}

290
	int x,y,w,h;
291
	// Fill the smallest dimension, then compute the other one using the image ratio
Simon Morlat's avatar
Simon Morlat committed
292
	if (screenW <= screenH) {
293
		float ratio = (gldisp->yuv_size[type].height) / (float)(gldisp->yuv_size[type].width);
Simon Morlat's avatar
Simon Morlat committed
294
		w = screenW * vpw;
295
		h = w * ratio;
296 297 298 299
		if (h > screenH) {
			w *= screenH /(float) h;
			h = screenH;
		}
300
		x = vpx * gldisp->backingWidth;
301
		y = vpy * gldisp->backingHeight;
302
	} else {
303
		float ratio = gldisp->yuv_size[type].width / (float)gldisp->yuv_size[type].height;
Simon Morlat's avatar
Simon Morlat committed
304
		h = screenH * vph;
305
		w = h * ratio;
306 307 308 309
		if (w > screenW) {
			h *= screenW / (float)w;
			w = screenW;
		}
310 311
		x = vpx * screenW;
		y = vpy * screenH;
312
	}
313 314 315 316 317 318 319 320 321 322
	
	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.;
	
323
	GLfloat mat[16];
324 325 326 327
	#define VP_SIZE 1.0f
	if (type == REMOTE_IMAGE) {
		float scale_factor = 1.0 / gldisp->zoom_factor;
		float vpDim = (VP_SIZE * scale_factor) / 2;
328

329 330 331 332 333 334 335 336 337 338 339 340 341 342
		#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; \
		}
		
		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])
	   
		load_orthographic_matrix(
343 344 345 346 347 348 349 350 351
			gldisp->zoom_cx - vpDim, 
			gldisp->zoom_cx + vpDim, 
			gldisp->zoom_cy - vpDim, 
			gldisp->zoom_cy + vpDim, 
			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);
	}
	
352
	GL_OPERATION(glUniformMatrix4fv(gldisp->uniforms[UNIFORM_PROJ_MATRIX], 1, GL_FALSE, mat))
353 354 355 356 357 358
	
	float rad = (2.0 * 3.14157 * orientation / 360.0); // Convert orientation to radian
	
	GL_OPERATION(glUniform1f(gldisp->uniforms[UNIFORM_ROTATION], rad))
	
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
359
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][Y]))
360
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_Y], 0))
361
	GL_OPERATION(glActiveTexture(GL_TEXTURE1))
362
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][U]))
363
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_U], 1))
364
	GL_OPERATION(glActiveTexture(GL_TEXTURE2))
365
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][V]))
366
	GL_OPERATION(glUniform1i(gldisp->uniforms[UNIFORM_TEXTURE_V], 2))
367
	
368 369 370 371
	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))
372
	
373
	GL_OPERATION(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4))   
374 375 376
	
	check_GL_errors("ogl_display_render_type");
	
377
}
378

379
void ogl_display_render(struct opengles_display* gldisp, int orientation) {
380 381 382 383 384
	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);
	
	gldisp->texture_index = (gldisp->texture_index + 1) % TEXTURE_BUFFER_SIZE;
385 386 387
}

static void check_GL_errors(const char* context) {
388
	 int maxIterations=10;
389 390 391 392 393 394 395 396 397 398 399 400 401
	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);
		}
402
		  maxIterations--;
403
	}
404 405 406 407 408
}

static bool_t load_shaders(GLuint* program, GLint* uniforms) {
#include "yuv2rgb.vs.h"
#include "yuv2rgb.fs.h"
409 410 411
	yuv2rgb_fs_len = yuv2rgb_fs_len;
	yuv2rgb_vs_len = yuv2rgb_vs_len;
	
412 413
	GLuint vertShader, fragShader;
	*program = glCreateProgram();
414

415 416 417 418
	if (!compileShader(&vertShader, GL_VERTEX_SHADER, (const char*)yuv2rgb_vs))
		return FALSE;
	if (!compileShader(&fragShader, GL_FRAGMENT_SHADER, (const char*)yuv2rgb_fs))
		return FALSE;
419

420 421
	GL_OPERATION(glAttachShader(*program, vertShader))
	GL_OPERATION(glAttachShader(*program, fragShader))
422

423 424
	GL_OPERATION(glBindAttribLocation(*program, ATTRIB_VERTEX, "position"))
	GL_OPERATION(glBindAttribLocation(*program, ATTRIB_UV, "uv"))
425

426 427
	if (!linkProgram(*program))
		return FALSE;
428

429 430 431 432 433
	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");
434

435 436
	glDeleteShader(vertShader);
	glDeleteShader(fragShader);
437

438 439 440
	return TRUE;
	
	check_GL_errors("load_shaders");
441 442 443 444
}

static void load_orthographic_matrix(float left, float right, float bottom, float top, float near, float far, float* mat)
{
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
	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;
467 468
}

469
static void allocate_gl_textures(struct opengles_display* gldisp, int w, int h, enum ImageType type) {
470 471
	int j;
	for(j=0; j<TEXTURE_BUFFER_SIZE; j++) {
472
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
473
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][Y]))
474 475 476 477 478 479 480
	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))
481
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][U]))
482 483 484 485 486 487 488
	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))
489
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[j][type][V]))
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))

496
	}
497 498
	gldisp->allocatedTexturesSize[type].width =  w;
	gldisp->allocatedTexturesSize[type].height =  h;
499

500
	ms_message("%s: allocated new textures[%d] (%d x %d)\n", __FUNCTION__, type, w, h);
501 502
	
	check_GL_errors("allocate_gl_textures");
503 504 505 506 507 508 509 510 511 512 513 514 515
}

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

516
static bool_t update_textures_with_yuv(struct opengles_display* gldisp, enum ImageType type) {
517 518 519
	unsigned int aligned_yuv_w, aligned_yuv_h;
	MSPicture yuvbuf;

520
	ms_yuv_buf_init_from_mblk(&yuvbuf, gldisp->yuv[type]);
521 522 523 524 525 526 527 528 529

	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 */
530 531 532
	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);
533
	}
534 535
	gldisp->uvx[type] = yuvbuf.w / (float)(gldisp->allocatedTexturesSize[type].width+1);
	gldisp->uvy[type] = yuvbuf.h / (float)(gldisp->allocatedTexturesSize[type].height+1);
536 537 538

	/* upload Y plane */
	GL_OPERATION(glActiveTexture(GL_TEXTURE0))
539
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][Y]))
540 541 542 543 544 545 546
	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))
547
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][U]))
548 549 550 551 552 553 554
	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))
555
	GL_OPERATION(glBindTexture(GL_TEXTURE_2D, gldisp->textures[gldisp->texture_index][type][V]))
556 557 558 559 560
	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))

561 562
	gldisp->yuv_size[type].width = yuvbuf.w;
	gldisp->yuv_size[type].height = yuvbuf.h;
563

564 565
	check_GL_errors("update_textures_with_yuv");
	
566 567 568
	return TRUE;
}

569 570 571 572
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;
573 574
}

575
#ifdef ANDROID
576
JNIEXPORT void JNICALL Java_org_linphone_mediastream_video_display_OpenGLESDisplay_init(JNIEnv * env, jobject obj, jint ptr, jint width, jint height) {
577 578 579 580
	struct opengles_display* d = (struct opengles_display*) ptr;
	ogl_display_init(d, width, height);
}

581
JNIEXPORT void JNICALL Java_org_linphone_mediastream_video_display_OpenGLESDisplay_render(JNIEnv * env, jobject obj, jint ptr) {
582
	struct opengles_display* d = (struct opengles_display*) ptr;
583
	ogl_display_render(d, 0);
584 585
}
#endif