OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #if !defined(__has_feature) || !__has_feature(objc_arc) | |
12 #error "This file requires ARC support." | |
13 #endif | |
14 | |
15 // This files is mostly copied from | |
16 // webrtc/modules/video_render/android/video_render_opengles20.h | |
17 | |
18 // TODO(sjlee): unify this copy with the android one. | |
19 #include "webrtc/modules/video_render/ios/open_gles20.h" | |
20 #include "webrtc/system_wrappers/include/trace.h" | |
21 | |
22 using namespace webrtc; | |
23 | |
24 const char OpenGles20::indices_[] = {0, 3, 2, 0, 2, 1}; | |
25 | |
26 const char OpenGles20::vertext_shader_[] = { | |
27 "attribute vec4 aPosition;\n" | |
28 "attribute vec2 aTextureCoord;\n" | |
29 "varying vec2 vTextureCoord;\n" | |
30 "void main() {\n" | |
31 " gl_Position = aPosition;\n" | |
32 " vTextureCoord = aTextureCoord;\n" | |
33 "}\n"}; | |
34 | |
35 // The fragment shader. | |
36 // Do YUV to RGB565 conversion. | |
37 const char OpenGles20::fragment_shader_[] = { | |
38 "precision mediump float;\n" | |
39 "uniform sampler2D Ytex;\n" | |
40 "uniform sampler2D Utex,Vtex;\n" | |
41 "varying vec2 vTextureCoord;\n" | |
42 "void main(void) {\n" | |
43 " float nx,ny,r,g,b,y,u,v;\n" | |
44 " mediump vec4 txl,ux,vx;" | |
45 " nx=vTextureCoord[0];\n" | |
46 " ny=vTextureCoord[1];\n" | |
47 " y=texture2D(Ytex,vec2(nx,ny)).r;\n" | |
48 " u=texture2D(Utex,vec2(nx,ny)).r;\n" | |
49 " v=texture2D(Vtex,vec2(nx,ny)).r;\n" | |
50 " y=1.1643*(y-0.0625);\n" | |
51 " u=u-0.5;\n" | |
52 " v=v-0.5;\n" | |
53 " r=y+1.5958*v;\n" | |
54 " g=y-0.39173*u-0.81290*v;\n" | |
55 " b=y+2.017*u;\n" | |
56 " gl_FragColor=vec4(r,g,b,1.0);\n" | |
57 "}\n"}; | |
58 | |
59 OpenGles20::OpenGles20() : texture_width_(-1), texture_height_(-1) { | |
60 texture_ids_[0] = 0; | |
61 texture_ids_[1] = 0; | |
62 texture_ids_[2] = 0; | |
63 | |
64 program_ = 0; | |
65 | |
66 const GLfloat vertices[20] = { | |
67 // X, Y, Z, U, V | |
68 -1, -1, 0, 0, 1, // Bottom Left | |
69 1, -1, 0, 1, 1, // Bottom Right | |
70 1, 1, 0, 1, 0, // Top Right | |
71 -1, 1, 0, 0, 0}; // Top Left | |
72 | |
73 memcpy(vertices_, vertices, sizeof(vertices_)); | |
74 } | |
75 | |
76 OpenGles20::~OpenGles20() { | |
77 if (program_) { | |
78 glDeleteTextures(3, texture_ids_); | |
79 glDeleteProgram(program_); | |
80 } | |
81 } | |
82 | |
83 bool OpenGles20::Setup(int32_t width, int32_t height) { | |
84 program_ = CreateProgram(vertext_shader_, fragment_shader_); | |
85 if (!program_) { | |
86 return false; | |
87 } | |
88 | |
89 int position_handle = glGetAttribLocation(program_, "aPosition"); | |
90 int texture_handle = glGetAttribLocation(program_, "aTextureCoord"); | |
91 | |
92 // set the vertices array in the shader | |
93 // vertices_ contains 4 vertices with 5 coordinates. | |
94 // 3 for (xyz) for the vertices and 2 for the texture | |
95 glVertexAttribPointer( | |
96 position_handle, 3, GL_FLOAT, false, 5 * sizeof(GLfloat), vertices_); | |
97 | |
98 glEnableVertexAttribArray(position_handle); | |
99 | |
100 // set the texture coordinate array in the shader | |
101 // vertices_ contains 4 vertices with 5 coordinates. | |
102 // 3 for (xyz) for the vertices and 2 for the texture | |
103 glVertexAttribPointer( | |
104 texture_handle, 2, GL_FLOAT, false, 5 * sizeof(GLfloat), &vertices_[3]); | |
105 glEnableVertexAttribArray(texture_handle); | |
106 | |
107 glUseProgram(program_); | |
108 int i = glGetUniformLocation(program_, "Ytex"); | |
109 glUniform1i(i, 0); /* Bind Ytex to texture unit 0 */ | |
110 | |
111 i = glGetUniformLocation(program_, "Utex"); | |
112 glUniform1i(i, 1); /* Bind Utex to texture unit 1 */ | |
113 | |
114 i = glGetUniformLocation(program_, "Vtex"); | |
115 glUniform1i(i, 2); /* Bind Vtex to texture unit 2 */ | |
116 | |
117 glViewport(0, 0, width, height); | |
118 return true; | |
119 } | |
120 | |
121 bool OpenGles20::SetCoordinates(const float z_order, | |
122 const float left, | |
123 const float top, | |
124 const float right, | |
125 const float bottom) { | |
126 if (top > 1 || top < 0 || right > 1 || right < 0 || bottom > 1 || | |
127 bottom < 0 || left > 1 || left < 0) { | |
128 return false; | |
129 } | |
130 | |
131 // Bottom Left | |
132 vertices_[0] = (left * 2) - 1; | |
133 vertices_[1] = -1 * (2 * bottom) + 1; | |
134 vertices_[2] = z_order; | |
135 | |
136 // Bottom Right | |
137 vertices_[5] = (right * 2) - 1; | |
138 vertices_[6] = -1 * (2 * bottom) + 1; | |
139 vertices_[7] = z_order; | |
140 | |
141 // Top Right | |
142 vertices_[10] = (right * 2) - 1; | |
143 vertices_[11] = -1 * (2 * top) + 1; | |
144 vertices_[12] = z_order; | |
145 | |
146 // Top Left | |
147 vertices_[15] = (left * 2) - 1; | |
148 vertices_[16] = -1 * (2 * top) + 1; | |
149 vertices_[17] = z_order; | |
150 | |
151 return true; | |
152 } | |
153 | |
154 bool OpenGles20::Render(const VideoFrame& frame) { | |
155 if (texture_width_ != (GLsizei)frame.width() || | |
156 texture_height_ != (GLsizei)frame.height()) { | |
157 SetupTextures(frame); | |
158 } | |
159 UpdateTextures(frame); | |
160 | |
161 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices_); | |
162 | |
163 return true; | |
164 } | |
165 | |
166 GLuint OpenGles20::LoadShader(GLenum shader_type, const char* shader_source) { | |
167 GLuint shader = glCreateShader(shader_type); | |
168 if (shader) { | |
169 glShaderSource(shader, 1, &shader_source, NULL); | |
170 glCompileShader(shader); | |
171 | |
172 GLint compiled = 0; | |
173 glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); | |
174 if (!compiled) { | |
175 GLint info_len = 0; | |
176 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len); | |
177 if (info_len) { | |
178 char* buf = (char*)malloc(info_len); | |
179 glGetShaderInfoLog(shader, info_len, NULL, buf); | |
180 WEBRTC_TRACE(kTraceError, | |
181 kTraceVideoRenderer, | |
182 0, | |
183 "%s: Could not compile shader %d: %s", | |
184 __FUNCTION__, | |
185 shader_type, | |
186 buf); | |
187 free(buf); | |
188 } | |
189 glDeleteShader(shader); | |
190 shader = 0; | |
191 } | |
192 } | |
193 return shader; | |
194 } | |
195 | |
196 GLuint OpenGles20::CreateProgram(const char* vertex_source, | |
197 const char* fragment_source) { | |
198 GLuint vertex_shader = LoadShader(GL_VERTEX_SHADER, vertex_source); | |
199 if (!vertex_shader) { | |
200 return -1; | |
201 } | |
202 | |
203 GLuint fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source); | |
204 if (!fragment_shader) { | |
205 return -1; | |
206 } | |
207 | |
208 GLuint program = glCreateProgram(); | |
209 if (program) { | |
210 glAttachShader(program, vertex_shader); | |
211 glAttachShader(program, fragment_shader); | |
212 glLinkProgram(program); | |
213 GLint link_status = GL_FALSE; | |
214 glGetProgramiv(program, GL_LINK_STATUS, &link_status); | |
215 if (link_status != GL_TRUE) { | |
216 GLint info_len = 0; | |
217 glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_len); | |
218 if (info_len) { | |
219 char* buf = (char*)malloc(info_len); | |
220 glGetProgramInfoLog(program, info_len, NULL, buf); | |
221 WEBRTC_TRACE(kTraceError, | |
222 kTraceVideoRenderer, | |
223 0, | |
224 "%s: Could not link program: %s", | |
225 __FUNCTION__, | |
226 buf); | |
227 free(buf); | |
228 } | |
229 glDeleteProgram(program); | |
230 program = 0; | |
231 } | |
232 } | |
233 | |
234 if (vertex_shader) { | |
235 glDeleteShader(vertex_shader); | |
236 } | |
237 | |
238 if (fragment_shader) { | |
239 glDeleteShader(fragment_shader); | |
240 } | |
241 | |
242 return program; | |
243 } | |
244 | |
245 static void InitializeTexture(int name, int id, int width, int height) { | |
246 glActiveTexture(name); | |
247 glBindTexture(GL_TEXTURE_2D, id); | |
248 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | |
249 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | |
250 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | |
251 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | |
252 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); | |
253 glTexImage2D(GL_TEXTURE_2D, | |
254 0, | |
255 GL_LUMINANCE, | |
256 width, | |
257 height, | |
258 0, | |
259 GL_LUMINANCE, | |
260 GL_UNSIGNED_BYTE, | |
261 NULL); | |
262 } | |
263 | |
264 void OpenGles20::SetupTextures(const VideoFrame& frame) { | |
265 const GLsizei width = frame.width(); | |
266 const GLsizei height = frame.height(); | |
267 | |
268 if (!texture_ids_[0]) { | |
269 glGenTextures(3, texture_ids_); // Generate the Y, U and V texture | |
270 } | |
271 | |
272 InitializeTexture(GL_TEXTURE0, texture_ids_[0], width, height); | |
273 InitializeTexture(GL_TEXTURE1, texture_ids_[1], width / 2, height / 2); | |
274 InitializeTexture(GL_TEXTURE2, texture_ids_[2], width / 2, height / 2); | |
275 | |
276 texture_width_ = width; | |
277 texture_height_ = height; | |
278 } | |
279 | |
280 // Uploads a plane of pixel data, accounting for stride != width*bpp. | |
281 static void GlTexSubImage2D(GLsizei width, | |
282 GLsizei height, | |
283 int stride, | |
284 const uint8_t* plane) { | |
285 if (stride == width) { | |
286 // Yay! We can upload the entire plane in a single GL call. | |
287 glTexSubImage2D(GL_TEXTURE_2D, | |
288 0, | |
289 0, | |
290 0, | |
291 width, | |
292 height, | |
293 GL_LUMINANCE, | |
294 GL_UNSIGNED_BYTE, | |
295 static_cast<const GLvoid*>(plane)); | |
296 } else { | |
297 // Boo! Since GLES2 doesn't have GL_UNPACK_ROW_LENGTH and iOS doesn't | |
298 // have GL_EXT_unpack_subimage we have to upload a row at a time. Ick. | |
299 for (int row = 0; row < height; ++row) { | |
300 glTexSubImage2D(GL_TEXTURE_2D, | |
301 0, | |
302 0, | |
303 row, | |
304 width, | |
305 1, | |
306 GL_LUMINANCE, | |
307 GL_UNSIGNED_BYTE, | |
308 static_cast<const GLvoid*>(plane + (row * stride))); | |
309 } | |
310 } | |
311 } | |
312 | |
313 void OpenGles20::UpdateTextures(const VideoFrame& frame) { | |
314 const GLsizei width = frame.width(); | |
315 const GLsizei height = frame.height(); | |
316 | |
317 glActiveTexture(GL_TEXTURE0); | |
318 glBindTexture(GL_TEXTURE_2D, texture_ids_[0]); | |
319 GlTexSubImage2D(width, height, frame.stride(kYPlane), frame.buffer(kYPlane)); | |
320 | |
321 glActiveTexture(GL_TEXTURE1); | |
322 glBindTexture(GL_TEXTURE_2D, texture_ids_[1]); | |
323 GlTexSubImage2D( | |
324 width / 2, height / 2, frame.stride(kUPlane), frame.buffer(kUPlane)); | |
325 | |
326 glActiveTexture(GL_TEXTURE2); | |
327 glBindTexture(GL_TEXTURE_2D, texture_ids_[2]); | |
328 GlTexSubImage2D( | |
329 width / 2, height / 2, frame.stride(kVPlane), frame.buffer(kVPlane)); | |
330 } | |
OLD | NEW |