revert cl 49121 since the way of using glEglImageTargetTexture2DOES is undefined and

media/tools/player_x11/gles_video_renderer.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/tools/player_x11/gles_video_renderer.h"
 
 #include <dlfcn.h>
 #include <EGL/eglext.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrender.h>
@@ skipping 26 matching lines @@
     const media::MediaFormat& media_format) {
   int width = 0;
   int height = 0;
   bool uses_egl_image_ = false;
   return ParseMediaFormat(media_format, &width, &height, &uses_egl_image_);
 }
 
 void GlesVideoRenderer::OnStop() {
   // TODO(hclam): Context switching seems to be broek so the following
   // calls may fail. Need to fix them.
+  eglMakeCurrent(egl_display_, EGL_NO_SURFACE,
+                 EGL_NO_SURFACE, EGL_NO_CONTEXT);
   for (size_t i = 0; i < egl_frames_.size(); ++i) {
     scoped_refptr<media::VideoFrame> frame = egl_frames_[i].first;
     if (frame->private_buffer())
       egl_destroy_image_khr_(egl_display_, frame->private_buffer());
     if (egl_frames_[i].second)
       glDeleteTextures(1, &egl_frames_[i].second);
   }
   egl_frames_.clear();
-  eglMakeCurrent(egl_display_, EGL_NO_SURFACE,
-                 EGL_NO_SURFACE, EGL_NO_CONTEXT);
   eglDestroyContext(egl_display_, egl_context_);
   eglDestroySurface(egl_display_, egl_surface_);
 }
 
 // Matrix used for the YUV to RGB conversion.
 static const float kYUV2RGB[9] = {
   1.f, 1.f, 1.f,
   0.f, -.344f, 1.772f,
   1.403f, -.714f, 0.f,
 };
@@ skipping 101 matching lines @@
 
   scoped_refptr<media::VideoFrame> video_frame;
   GetCurrentFrame(&video_frame);
 
   if (!video_frame.get()) {
     return;
   }
 
   if (uses_egl_image_) {
     if (media::VideoFrame::TYPE_EGL_IMAGE == video_frame->type()) {
-      glActiveTexture(GL_TEXTURE0);
-      EGLImageKHR egl_image =
-          reinterpret_cast<EGLImageKHR>(video_frame->private_buffer());
-      gl_eglimage_target_texture2d_oes_(GL_TEXTURE_2D, egl_image);
-      glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-      eglSwapBuffers(egl_display_, egl_surface_);
+
+      GLuint texture = FindTexture(video_frame);
+      if (texture) {
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        eglSwapBuffers(egl_display_, egl_surface_);
+      }
     }
     return;
   }
 
   // Convert YUV frame to RGB.
   DCHECK(video_frame->format() == media::VideoFrame::YV12 ||
          video_frame->format() == media::VideoFrame::YV16);
   DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==
          video_frame->stride(media::VideoFrame::kVPlane));
   DCHECK(video_frame->planes() == media::VideoFrame::kNumYUVPlanes);
@@ skipping 32 matching lines @@
     }
 
     glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0,
                  GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
   }
 
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   eglSwapBuffers(egl_display_, egl_surface_);
 }
 
+// find if texture exists corresponding to video_frame
+GLuint GlesVideoRenderer::FindTexture(
+    scoped_refptr<media::VideoFrame> video_frame) {
+  for (size_t i = 0; i < egl_frames_.size(); ++i) {
+    scoped_refptr<media::VideoFrame> frame = egl_frames_[i].first;
+    if (video_frame->private_buffer() == frame->private_buffer())
+      return egl_frames_[i].second;
+  }
+  return NULL;
+}
+
 bool GlesVideoRenderer::InitializeGles() {
   // Resize the window to fit that of the video.
   XResizeWindow(display_, window_, width_, height_);
 
   egl_display_ = eglGetDisplay(display_);
   if (eglGetError() != EGL_SUCCESS) {
     DLOG(ERROR) << "eglGetDisplay failed.";
     return false;
   }
 
@@ skipping 120 matching lines @@
     int len;
     glGetProgramInfoLog(program, kErrorSize - 1, &len, log);
     log[kErrorSize - 1] = 0;
     LOG(FATAL) << log;
   }
   glUseProgram(program);
   glDeleteProgram(program);
 }
 
 void GlesVideoRenderer::CreateTextureAndProgramEgl() {
-  if (!egl_create_image_khr_) {
+  if (!egl_create_image_khr_)
     egl_create_image_khr_ = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>
                             (eglGetProcAddress("eglCreateImageKHR"));
-    CHECK(egl_create_image_khr_);
-  }
-  if (!egl_destroy_image_khr_) {
+  if (!egl_destroy_image_khr_)
     egl_destroy_image_khr_ = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>
                              (eglGetProcAddress("eglDestroyImageKHR"));
-    CHECK(egl_destroy_image_khr_);
-  }
-
-  if (!gl_eglimage_target_texture2d_oes_) {
-    gl_eglimage_target_texture2d_oes_ =
-        reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>
-            (eglGetProcAddress("glEGLImageTargetTexture2DOES"));
-    CHECK(gl_eglimage_target_texture2d_oes_);
-  }
-
   // TODO(wjia): get count from decoder.
   for (int i = 0; i < 4; i++) {
     GLuint texture;
     EGLint attrib = EGL_NONE;
     EGLImageKHR egl_image;
 
     glGenTextures(1, &texture);
     glBindTexture(GL_TEXTURE_2D, texture);
     glTexImage2D(
         GL_TEXTURE_2D,
@@ skipping 92 matching lines @@
 
   int pos_location = glGetAttribLocation(program, "in_pos");
   glEnableVertexAttribArray(pos_location);
   glVertexAttribPointer(pos_location, 2, GL_FLOAT, GL_FALSE, 0, kVertices);
 
   int tc_location = glGetAttribLocation(program, "in_tc");
   glEnableVertexAttribArray(tc_location);
   glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0,
                         kTextureCoords);
 }