| Index: webrtc/modules/video_render/ios/open_gles20.mm
|
| diff --git a/webrtc/modules/video_render/ios/open_gles20.mm b/webrtc/modules/video_render/ios/open_gles20.mm
|
| deleted file mode 100644
|
| index d1735280f26e2a1ab4a8aa7641c3debdef127654..0000000000000000000000000000000000000000
|
| --- a/webrtc/modules/video_render/ios/open_gles20.mm
|
| +++ /dev/null
|
| @@ -1,330 +0,0 @@
|
| -/*
|
| - * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
| - *
|
| - * Use of this source code is governed by a BSD-style license
|
| - * that can be found in the LICENSE file in the root of the source
|
| - * tree. An additional intellectual property rights grant can be found
|
| - * in the file PATENTS. All contributing project authors may
|
| - * be found in the AUTHORS file in the root of the source tree.
|
| - */
|
| -
|
| -#if !defined(__has_feature) || !__has_feature(objc_arc)
|
| -#error "This file requires ARC support."
|
| -#endif
|
| -
|
| -// This files is mostly copied from
|
| -// webrtc/modules/video_render/android/video_render_opengles20.h
|
| -
|
| -// TODO(sjlee): unify this copy with the android one.
|
| -#include "webrtc/modules/video_render/ios/open_gles20.h"
|
| -#include "webrtc/system_wrappers/include/trace.h"
|
| -
|
| -using namespace webrtc;
|
| -
|
| -const char OpenGles20::indices_[] = {0, 3, 2, 0, 2, 1};
|
| -
|
| -const char OpenGles20::vertext_shader_[] = {
|
| - "attribute vec4 aPosition;\n"
|
| - "attribute vec2 aTextureCoord;\n"
|
| - "varying vec2 vTextureCoord;\n"
|
| - "void main() {\n"
|
| - " gl_Position = aPosition;\n"
|
| - " vTextureCoord = aTextureCoord;\n"
|
| - "}\n"};
|
| -
|
| -// The fragment shader.
|
| -// Do YUV to RGB565 conversion.
|
| -const char OpenGles20::fragment_shader_[] = {
|
| - "precision mediump float;\n"
|
| - "uniform sampler2D Ytex;\n"
|
| - "uniform sampler2D Utex,Vtex;\n"
|
| - "varying vec2 vTextureCoord;\n"
|
| - "void main(void) {\n"
|
| - " float nx,ny,r,g,b,y,u,v;\n"
|
| - " mediump vec4 txl,ux,vx;"
|
| - " nx=vTextureCoord[0];\n"
|
| - " ny=vTextureCoord[1];\n"
|
| - " y=texture2D(Ytex,vec2(nx,ny)).r;\n"
|
| - " u=texture2D(Utex,vec2(nx,ny)).r;\n"
|
| - " v=texture2D(Vtex,vec2(nx,ny)).r;\n"
|
| - " y=1.1643*(y-0.0625);\n"
|
| - " u=u-0.5;\n"
|
| - " v=v-0.5;\n"
|
| - " r=y+1.5958*v;\n"
|
| - " g=y-0.39173*u-0.81290*v;\n"
|
| - " b=y+2.017*u;\n"
|
| - " gl_FragColor=vec4(r,g,b,1.0);\n"
|
| - "}\n"};
|
| -
|
| -OpenGles20::OpenGles20() : texture_width_(-1), texture_height_(-1) {
|
| - texture_ids_[0] = 0;
|
| - texture_ids_[1] = 0;
|
| - texture_ids_[2] = 0;
|
| -
|
| - program_ = 0;
|
| -
|
| - const GLfloat vertices[20] = {
|
| - // X, Y, Z, U, V
|
| - -1, -1, 0, 0, 1, // Bottom Left
|
| - 1, -1, 0, 1, 1, // Bottom Right
|
| - 1, 1, 0, 1, 0, // Top Right
|
| - -1, 1, 0, 0, 0}; // Top Left
|
| -
|
| - memcpy(vertices_, vertices, sizeof(vertices_));
|
| -}
|
| -
|
| -OpenGles20::~OpenGles20() {
|
| - if (program_) {
|
| - glDeleteTextures(3, texture_ids_);
|
| - glDeleteProgram(program_);
|
| - }
|
| -}
|
| -
|
| -bool OpenGles20::Setup(int32_t width, int32_t height) {
|
| - program_ = CreateProgram(vertext_shader_, fragment_shader_);
|
| - if (!program_) {
|
| - return false;
|
| - }
|
| -
|
| - int position_handle = glGetAttribLocation(program_, "aPosition");
|
| - int texture_handle = glGetAttribLocation(program_, "aTextureCoord");
|
| -
|
| - // set the vertices array in the shader
|
| - // vertices_ contains 4 vertices with 5 coordinates.
|
| - // 3 for (xyz) for the vertices and 2 for the texture
|
| - glVertexAttribPointer(
|
| - position_handle, 3, GL_FLOAT, false, 5 * sizeof(GLfloat), vertices_);
|
| -
|
| - glEnableVertexAttribArray(position_handle);
|
| -
|
| - // set the texture coordinate array in the shader
|
| - // vertices_ contains 4 vertices with 5 coordinates.
|
| - // 3 for (xyz) for the vertices and 2 for the texture
|
| - glVertexAttribPointer(
|
| - texture_handle, 2, GL_FLOAT, false, 5 * sizeof(GLfloat), &vertices_[3]);
|
| - glEnableVertexAttribArray(texture_handle);
|
| -
|
| - glUseProgram(program_);
|
| - int i = glGetUniformLocation(program_, "Ytex");
|
| - glUniform1i(i, 0); /* Bind Ytex to texture unit 0 */
|
| -
|
| - i = glGetUniformLocation(program_, "Utex");
|
| - glUniform1i(i, 1); /* Bind Utex to texture unit 1 */
|
| -
|
| - i = glGetUniformLocation(program_, "Vtex");
|
| - glUniform1i(i, 2); /* Bind Vtex to texture unit 2 */
|
| -
|
| - glViewport(0, 0, width, height);
|
| - return true;
|
| -}
|
| -
|
| -bool OpenGles20::SetCoordinates(const float z_order,
|
| - const float left,
|
| - const float top,
|
| - const float right,
|
| - const float bottom) {
|
| - if (top > 1 || top < 0 || right > 1 || right < 0 || bottom > 1 ||
|
| - bottom < 0 || left > 1 || left < 0) {
|
| - return false;
|
| - }
|
| -
|
| - // Bottom Left
|
| - vertices_[0] = (left * 2) - 1;
|
| - vertices_[1] = -1 * (2 * bottom) + 1;
|
| - vertices_[2] = z_order;
|
| -
|
| - // Bottom Right
|
| - vertices_[5] = (right * 2) - 1;
|
| - vertices_[6] = -1 * (2 * bottom) + 1;
|
| - vertices_[7] = z_order;
|
| -
|
| - // Top Right
|
| - vertices_[10] = (right * 2) - 1;
|
| - vertices_[11] = -1 * (2 * top) + 1;
|
| - vertices_[12] = z_order;
|
| -
|
| - // Top Left
|
| - vertices_[15] = (left * 2) - 1;
|
| - vertices_[16] = -1 * (2 * top) + 1;
|
| - vertices_[17] = z_order;
|
| -
|
| - return true;
|
| -}
|
| -
|
| -bool OpenGles20::Render(const VideoFrame& frame) {
|
| - if (texture_width_ != (GLsizei)frame.width() ||
|
| - texture_height_ != (GLsizei)frame.height()) {
|
| - SetupTextures(frame);
|
| - }
|
| - UpdateTextures(frame);
|
| -
|
| - glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices_);
|
| -
|
| - return true;
|
| -}
|
| -
|
| -GLuint OpenGles20::LoadShader(GLenum shader_type, const char* shader_source) {
|
| - GLuint shader = glCreateShader(shader_type);
|
| - if (shader) {
|
| - glShaderSource(shader, 1, &shader_source, NULL);
|
| - glCompileShader(shader);
|
| -
|
| - GLint compiled = 0;
|
| - glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
|
| - if (!compiled) {
|
| - GLint info_len = 0;
|
| - glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
|
| - if (info_len) {
|
| - char* buf = (char*)malloc(info_len);
|
| - glGetShaderInfoLog(shader, info_len, NULL, buf);
|
| - WEBRTC_TRACE(kTraceError,
|
| - kTraceVideoRenderer,
|
| - 0,
|
| - "%s: Could not compile shader %d: %s",
|
| - __FUNCTION__,
|
| - shader_type,
|
| - buf);
|
| - free(buf);
|
| - }
|
| - glDeleteShader(shader);
|
| - shader = 0;
|
| - }
|
| - }
|
| - return shader;
|
| -}
|
| -
|
| -GLuint OpenGles20::CreateProgram(const char* vertex_source,
|
| - const char* fragment_source) {
|
| - GLuint vertex_shader = LoadShader(GL_VERTEX_SHADER, vertex_source);
|
| - if (!vertex_shader) {
|
| - return -1;
|
| - }
|
| -
|
| - GLuint fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
|
| - if (!fragment_shader) {
|
| - return -1;
|
| - }
|
| -
|
| - GLuint program = glCreateProgram();
|
| - if (program) {
|
| - glAttachShader(program, vertex_shader);
|
| - glAttachShader(program, fragment_shader);
|
| - glLinkProgram(program);
|
| - GLint link_status = GL_FALSE;
|
| - glGetProgramiv(program, GL_LINK_STATUS, &link_status);
|
| - if (link_status != GL_TRUE) {
|
| - GLint info_len = 0;
|
| - glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_len);
|
| - if (info_len) {
|
| - char* buf = (char*)malloc(info_len);
|
| - glGetProgramInfoLog(program, info_len, NULL, buf);
|
| - WEBRTC_TRACE(kTraceError,
|
| - kTraceVideoRenderer,
|
| - 0,
|
| - "%s: Could not link program: %s",
|
| - __FUNCTION__,
|
| - buf);
|
| - free(buf);
|
| - }
|
| - glDeleteProgram(program);
|
| - program = 0;
|
| - }
|
| - }
|
| -
|
| - if (vertex_shader) {
|
| - glDeleteShader(vertex_shader);
|
| - }
|
| -
|
| - if (fragment_shader) {
|
| - glDeleteShader(fragment_shader);
|
| - }
|
| -
|
| - return program;
|
| -}
|
| -
|
| -static void InitializeTexture(int name, int id, int width, int height) {
|
| - glActiveTexture(name);
|
| - glBindTexture(GL_TEXTURE_2D, id);
|
| - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
| - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
| - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
| - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
| - glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
| - glTexImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - GL_LUMINANCE,
|
| - width,
|
| - height,
|
| - 0,
|
| - GL_LUMINANCE,
|
| - GL_UNSIGNED_BYTE,
|
| - NULL);
|
| -}
|
| -
|
| -void OpenGles20::SetupTextures(const VideoFrame& frame) {
|
| - const GLsizei width = frame.width();
|
| - const GLsizei height = frame.height();
|
| -
|
| - if (!texture_ids_[0]) {
|
| - glGenTextures(3, texture_ids_); // Generate the Y, U and V texture
|
| - }
|
| -
|
| - InitializeTexture(GL_TEXTURE0, texture_ids_[0], width, height);
|
| - InitializeTexture(GL_TEXTURE1, texture_ids_[1], width / 2, height / 2);
|
| - InitializeTexture(GL_TEXTURE2, texture_ids_[2], width / 2, height / 2);
|
| -
|
| - texture_width_ = width;
|
| - texture_height_ = height;
|
| -}
|
| -
|
| -// Uploads a plane of pixel data, accounting for stride != width*bpp.
|
| -static void GlTexSubImage2D(GLsizei width,
|
| - GLsizei height,
|
| - int stride,
|
| - const uint8_t* plane) {
|
| - if (stride == width) {
|
| - // Yay! We can upload the entire plane in a single GL call.
|
| - glTexSubImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - 0,
|
| - 0,
|
| - width,
|
| - height,
|
| - GL_LUMINANCE,
|
| - GL_UNSIGNED_BYTE,
|
| - static_cast<const GLvoid*>(plane));
|
| - } else {
|
| - // Boo! Since GLES2 doesn't have GL_UNPACK_ROW_LENGTH and iOS doesn't
|
| - // have GL_EXT_unpack_subimage we have to upload a row at a time. Ick.
|
| - for (int row = 0; row < height; ++row) {
|
| - glTexSubImage2D(GL_TEXTURE_2D,
|
| - 0,
|
| - 0,
|
| - row,
|
| - width,
|
| - 1,
|
| - GL_LUMINANCE,
|
| - GL_UNSIGNED_BYTE,
|
| - static_cast<const GLvoid*>(plane + (row * stride)));
|
| - }
|
| - }
|
| -}
|
| -
|
| -void OpenGles20::UpdateTextures(const VideoFrame& frame) {
|
| - const GLsizei width = frame.width();
|
| - const GLsizei height = frame.height();
|
| -
|
| - glActiveTexture(GL_TEXTURE0);
|
| - glBindTexture(GL_TEXTURE_2D, texture_ids_[0]);
|
| - GlTexSubImage2D(width, height, frame.stride(kYPlane), frame.buffer(kYPlane));
|
| -
|
| - glActiveTexture(GL_TEXTURE1);
|
| - glBindTexture(GL_TEXTURE_2D, texture_ids_[1]);
|
| - GlTexSubImage2D(
|
| - width / 2, height / 2, frame.stride(kUPlane), frame.buffer(kUPlane));
|
| -
|
| - glActiveTexture(GL_TEXTURE2);
|
| - glBindTexture(GL_TEXTURE_2D, texture_ids_[2]);
|
| - GlTexSubImage2D(
|
| - width / 2, height / 2, frame.stride(kVPlane), frame.buffer(kVPlane));
|
| -}
|
|
|