Allow rendering from non-stream GL_TEXTURE_EXTERNAL_OES

content/common/gpu/media/exynos_video_decode_accelerator.cc

 // Copyright (c) 2012 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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 223 matching lines @@
       gsc_fd_(-1),
       gsc_input_streamon_(false),
       gsc_input_buffer_queued_count_(0),
       gsc_output_streamon_(false),
       gsc_output_buffer_queued_count_(0),
       device_poll_thread_("ExynosDevicePollThread"),
       device_poll_interrupt_fd_(-1),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
-      video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {
-}
+      video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {}
 
 ExynosVideoDecodeAccelerator::~ExynosVideoDecodeAccelerator() {
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   if (device_poll_interrupt_fd_ != -1) {
     HANDLE_EINTR(close(device_poll_interrupt_fd_));
     device_poll_interrupt_fd_ = -1;
   }
   if (gsc_fd_ != -1) {
@@ skipping 177 matching lines @@
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   if (buffers.size() != gsc_output_buffer_map_.size()) {
     DLOG(ERROR) << "AssignPictureBuffers(): Failed to provide requested picture"
       " buffers. (Got " << buffers.size() << ", requested " <<
       gsc_output_buffer_map_.size() << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
-  for (size_t i = 0; i < buffers.size(); ++i) {
-    if (buffers[i].size() != frame_buffer_size_) {
-      DLOG(ERROR) << "AssignPictureBuffers(): invalid buffer size";
-      NOTIFY_ERROR(INVALID_ARGUMENT);
-      return;
-    }
-  }
-
   if (!make_context_current_.Run()) {
     DLOG(ERROR) << "AssignPictureBuffers(): could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   scoped_ptr<PictureBufferArrayRef> pic_buffers_ref(
       new PictureBufferArrayRef(egl_display_, buffers.size()));
 
   const static EGLint kImageAttrs[] = {
     EGL_IMAGE_PRESERVED_KHR, 0,
     EGL_NONE,
   };
   Display* x_display = base::MessagePumpForUI::GetDefaultXDisplay();
   gfx::ScopedTextureBinder bind_restore(GL_TEXTURE_2D, 0);
   for (size_t i = 0; i < pic_buffers_ref->picture_buffers.size(); ++i) {
+    DCHECK(buffers[i].size() == frame_buffer_size_);
     PictureBufferArrayRef::PictureBufferRef& buffer =
         pic_buffers_ref->picture_buffers[i];
     // Create the X pixmap and then create an EGLImageKHR from it, so we can
     // get dma_buf backing.
-    Pixmap pixmap = XCreatePixmap(x_display, RootWindow(x_display, 0),
-        buffers[i].size().width(), buffers[i].size().height(), 32);
+    Pixmap pixmap = XCreatePixmap(x_display,
+                                  RootWindow(x_display, 0),
+                                  frame_buffer_size_.width(),
+                                  frame_buffer_size_.height(),
+                                  32);
     if (!pixmap) {
       DLOG(ERROR) << "AssignPictureBuffers(): could not create X pixmap";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     glBindTexture(GL_TEXTURE_2D, buffers[i].texture_id());
     EGLImageKHR egl_image = eglCreateImageKHR(
         egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
         (EGLClientBuffer)pixmap, kImageAttrs);
     // We can free the X pixmap immediately -- according to the
@@ skipping 1966 matching lines @@
   DestroyGscOutputBuffers();
   DestroyMfcOutputBuffers();
 
   // Finish resolution change on decoder thread.
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::FinishResolutionChange,
       base::Unretained(this)));
 }
 
 }  // namespace content