Replace SW YUV conversion with higher quality Shader+FBO in pepper video path.

content/renderer/pepper/video_decoder_shim.cc

 // Copyright 2014 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 "content/renderer/pepper/video_decoder_shim.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/bind.h"
+#ifndef NDEBUG
+#include "base/logging.h"
+#endif
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/blink/context_provider_web_context.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/pepper/pepper_video_decoder_host.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder.h"
 #include "media/blink/skcanvas_video_renderer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ppapi/c/pp_errors.h"
+#include "third_party/skia/include/gpu/GrTypes.h"
 
 namespace content {
 
+static const uint32_t kGrInvalidateState =
+    kRenderTarget_GrGLBackendState | kTextureBinding_GrGLBackendState |
+    kView_GrGLBackendState | kVertex_GrGLBackendState |
+    kProgram_GrGLBackendState;
+
+// YUV->RGB converter class using a shader and FBO.
+class VideoDecoderShim::YUVConverter {
+ public:
+  YUVConverter(const scoped_refptr<cc_blink::ContextProviderWebContext>&);
+  ~YUVConverter();
+  bool Initialize();
+  void Convert(const scoped_refptr<media::VideoFrame>& frame, GLuint tex_out);
+
+ private:
+  GLuint CreateShader();
+  GLuint CompileShader(const char* name, GLuint type, const char* code);
+  GLuint CreateProgram(const char* name, GLuint vshader, GLuint fshader);
+  GLuint CreateTexture();
+  void SetTexcoordClamp(uint32_t stride, uint32_t width);
+
+  scoped_refptr<cc_blink::ContextProviderWebContext> context_provider_;
+  gpu::gles2::GLES2Interface* gl_;
+  GLuint frame_buffer_;
+  GLuint vertex_buffer_;
+  GLuint program_;
+
+  GLuint y_texture_;
+  GLuint u_texture_;
+  GLuint v_texture_;
+  GLuint a_texture_;
+
+  GLuint internal_format_;
+  GLuint format_;
+  media::VideoFrame::Format video_format_;
+
+  GLuint y_width_;
+  GLuint y_height_;
+
+  GLuint uv_width_;
+  GLuint uv_height_;
+  uint32_t uv_height_divisor_;
+
+  GLfloat clamp_value_;
+  GLuint clamp_width_;
+  GLint clamp_width_loc_;
+
+  GLint yuv_matrix_loc_;
+  GLint yuv_adjust_loc_;
+
+  DISALLOW_COPY_AND_ASSIGN(YUVConverter);
+};
+
+VideoDecoderShim::YUVConverter::YUVConverter(
+    const scoped_refptr<cc_blink::ContextProviderWebContext>& context_provider)
+    : context_provider_(context_provider),
+      gl_(context_provider_->ContextGL()),
+      frame_buffer_(0),
+      vertex_buffer_(0),
+      program_(0),
+      y_texture_(0),
+      u_texture_(0),
+      v_texture_(0),
+      a_texture_(0),
+      internal_format_(0),
+      format_(0),
+      video_format_(media::VideoFrame::UNKNOWN),
+      y_width_(2),
+      y_height_(2),
+      uv_width_(2),
+      uv_height_(2),
+      uv_height_divisor_(1),
+      clamp_value_(1.f),
+      clamp_width_(0),
+      clamp_width_loc_(0),
+      yuv_matrix_loc_(0),
+      yuv_adjust_loc_(0) {
+  DCHECK(gl_);
+}
+
+VideoDecoderShim::YUVConverter::~YUVConverter() {
+  if (y_texture_)
+    gl_->DeleteTextures(1, &y_texture_);
+
+  if (u_texture_)
+    gl_->DeleteTextures(1, &u_texture_);
+
+  if (v_texture_)
+    gl_->DeleteTextures(1, &v_texture_);
+
+  if (a_texture_)
+    gl_->DeleteTextures(1, &a_texture_);
+
+  if (frame_buffer_)
+    gl_->DeleteFramebuffers(1, &frame_buffer_);
+
+  if (vertex_buffer_)
+    gl_->DeleteBuffers(1, &vertex_buffer_);
+
+  if (program_)
+    gl_->DeleteProgram(program_);
+}
+
+GLuint VideoDecoderShim::YUVConverter::CreateTexture() {
+  GLuint tex = 0;
+
+  gl_->GenTextures(1, &tex);
+  gl_->BindTexture(GL_TEXTURE_2D, tex);
+
+  // Create texture with default size - will be resized upon first frame.
+  gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, 2, 2, 0, format_,
+                  GL_UNSIGNED_BYTE, NULL);
+
+  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
+
+  return tex;
+}
+
+GLuint VideoDecoderShim::YUVConverter::CompileShader(const char* name,
+                                                     GLuint type,
+                                                     const char* code) {
+  GLuint shader = gl_->CreateShader(type);
+
+  gl_->ShaderSource(shader, 1, (const GLchar**)&code, NULL);
+  gl_->CompileShader(shader);
+
+#ifndef NDEBUG
+  GLint status = 0;
+
+  gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &status);
+  if (status != GL_TRUE) {
+    GLint max_length = 0;
+    GLint actual_length = 0;
+    gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
+
+    // The max_length includes the NULL character.
+    std::string error_log(max_length, 0);
+    gl_->GetShaderInfoLog(shader, max_length, &actual_length, &error_log[0]);
+
+    LOG(ERROR) << name << " shader compilation failed: " << error_log.c_str();
+    gl_->DeleteShader(shader);
+    return 0;
+  }
+#endif
+
+  return shader;
+}
+
+GLuint VideoDecoderShim::YUVConverter::CreateProgram(const char* name,
+                                                     GLuint vshader,
+                                                     GLuint fshader) {
+  GLuint program = gl_->CreateProgram();
+  gl_->AttachShader(program, vshader);
+  gl_->AttachShader(program, fshader);
+
+  gl_->BindAttribLocation(program, 0, "position");
+
+  gl_->LinkProgram(program);
+
+#ifndef NDEBUG
+  GLint status = 0;
+
+  gl_->GetProgramiv(program, GL_LINK_STATUS, &status);
+  if (status != GL_TRUE) {
+    GLint max_length = 0;
+    GLint actual_length = 0;
+    gl_->GetProgramiv(program, GL_INFO_LOG_LENGTH, &max_length);
+
+    // The max_length includes the NULL character.
+    std::string error_log(max_length, 0);
+    gl_->GetProgramInfoLog(program, max_length, &actual_length, &error_log[0]);
+
+    LOG(ERROR) << name << " program linking failed: " << error_log.c_str();
+    return 0;
+  }
+#endif
+
+  return program;
+}
+
+GLuint VideoDecoderShim::YUVConverter::CreateShader() {
+  const char* vert_shader =
+      "precision mediump float;\n"
+      "attribute vec2 position;\n"
+      "varying vec2 texcoord;\n"
+      "uniform float clamp_width;\n"
+      "void main()\n"
+      "{\n"
+      "    gl_Position = vec4( position.xy, 0, 1 );\n"
+      "    vec2 tmp = position*0.5+0.5;\n"
+      "    texcoord = vec2(min(tmp.x, clamp_width), tmp.y);\n"
+      "}";
+
+  const char* frag_shader =
+      "precision mediump float;\n"
+      "varying vec2 texcoord;\n"
+      "uniform sampler2D y_sampler;\n"
+      "uniform sampler2D u_sampler;\n"
+      "uniform sampler2D v_sampler;\n"
+      "uniform sampler2D a_sampler;\n"
+      "uniform mat3 yuv_matrix;\n"
+      "uniform vec3 yuv_adjust;\n"
+      "void main()\n"
+      "{\n"
+      "  vec3 yuv = vec3(texture2D(y_sampler, texcoord).x,\n"
+      "                  texture2D(u_sampler, texcoord).x,\n"
+      "                  texture2D(v_sampler, texcoord).x) +\n"
+      "                  yuv_adjust;\n"
+      "  gl_FragColor = vec4(yuv_matrix * yuv, texture2D(a_sampler, "
+      "texcoord).x);\n"
+      "}";
+
+  GLuint vertex_shader =
+      CompileShader("Vertex Shader", GL_VERTEX_SHADER, vert_shader);
+  if (!vertex_shader) {
+    return 0;
+  }
+
+  GLuint fragment_shader =
+      CompileShader("Fragment Shader", GL_FRAGMENT_SHADER, frag_shader);
+  if (!fragment_shader) {
+    gl_->DeleteShader(vertex_shader);
+    return 0;
+  }
+
+  GLuint program =
+      CreateProgram("YUVConverter Program", vertex_shader, fragment_shader);
+
+  gl_->DeleteShader(vertex_shader);
+  gl_->DeleteShader(fragment_shader);
+
+  if (!program) {
+    return 0;
+  }
+
+  gl_->UseProgram(program);
+
+  GLint uniform_location;
+  uniform_location = gl_->GetUniformLocation(program, "y_sampler");
+  DCHECK(uniform_location != -1);
+  gl_->Uniform1i(uniform_location, 0);
+
+  uniform_location = gl_->GetUniformLocation(program, "u_sampler");
+  DCHECK(uniform_location != -1);
+  gl_->Uniform1i(uniform_location, 1);
+
+  uniform_location = gl_->GetUniformLocation(program, "v_sampler");
+  DCHECK(uniform_location != -1);
+  gl_->Uniform1i(uniform_location, 2);
+
+  uniform_location = gl_->GetUniformLocation(program, "a_sampler");
+  DCHECK(uniform_location != -1);
+  gl_->Uniform1i(uniform_location, 3);
+
+  clamp_width_loc_ = gl_->GetUniformLocation(program, "clamp_width");
+  DCHECK(clamp_width_loc_ != -1);
+  gl_->Uniform1f(clamp_width_loc_, clamp_value_);
+
+  gl_->UseProgram(0);
+
+  yuv_matrix_loc_ = gl_->GetUniformLocation(program, "yuv_matrix");
+  DCHECK(yuv_matrix_loc_ != -1);
+
+  yuv_adjust_loc_ = gl_->GetUniformLocation(program, "yuv_adjust");
+  DCHECK(yuv_adjust_loc_ != -1);
+
+  return program;
+}
+
+bool VideoDecoderShim::YUVConverter::Initialize() {
+  // If texture_rg extension is not available, use slower GL_LUMINANCE.
+  if (context_provider_->ContextCapabilities().gpu.texture_rg) {
+    internal_format_ = GL_RED_EXT;
+    format_ = GL_RED_EXT;
+  } else {
+    internal_format_ = GL_LUMINANCE;
+    format_ = GL_LUMINANCE;
+  }
+
+  if (context_provider_->ContextCapabilities().gpu.max_texture_image_units <
+      4) {
+    // We support YUVA textures and require 4 texture units in the fragment
+    // stage.
+    return false;
+  }
+
+  gl_->PushGroupMarkerEXT(0, "YUVConverterContext");
+
+  gl_->GenFramebuffers(1, &frame_buffer_);
+
+  y_texture_ = CreateTexture();
+  u_texture_ = CreateTexture();
+  v_texture_ = CreateTexture();
+  a_texture_ = CreateTexture();
+
+  // Vertex positions.  Also converted to texcoords in vertex shader.
+  GLfloat vertex_positions[] = {-1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f};
+
+  gl_->GenBuffers(1, &vertex_buffer_);
+  gl_->BindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+  gl_->BufferData(GL_ARRAY_BUFFER, 2 * sizeof(GLfloat) * 4, vertex_positions,
+                  GL_STATIC_DRAW);
+  gl_->BindBuffer(GL_ARRAY_BUFFER, 0);
+
+  program_ = CreateShader();
+
+  gl_->PopGroupMarkerEXT();
+
+  context_provider_->InvalidateGrContext(kGrInvalidateState);
+
+  return (program_ != 0);
+}
+
+void VideoDecoderShim::YUVConverter::SetTexcoordClamp(uint32_t stride,
+                                                      uint32_t width) {
+  clamp_width_ = width;
+  if (width != stride) {
+    // Clamp texcoord width to avoid sampling padding pixels.
+    clamp_value_ = static_cast<float>(width) / static_cast<float>(stride);
+    // Further clamp to 1/2 pixel inside to avoid bilinear sampling errors.
+    clamp_value_ -= (1.f / (2.f * static_cast<float>(stride)));
+  } else {
+    // No clamping necessary if width and stride are equal.
+    clamp_value_ = 1.f;
+  }
+}
+
+void VideoDecoderShim::YUVConverter::Convert(
+    const scoped_refptr<media::VideoFrame>& frame,
+    GLuint tex_out) {
+  const float* yuv_matrix = 0;
+  const float* yuv_adjust = 0;
+
+  if (video_format_ != frame->format()) {
+    // The constants below were taken from cc/output/gl_renderer.cc.
+    // These values are magic numbers that are used in the transformation from
+    // YUV to RGB color values.  They are taken from the following webpage:
+    // http://www.fourcc.org/fccyvrgb.php
+    const float yuv_to_rgb_rec601[9] = {
+        1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
+    };
+    const float yuv_to_rgb_jpeg[9] = {
+        1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414f, 0.0f,
+    };
+    const float yuv_to_rgb_rec709[9] = {
+        1.164f, 1.164f, 1.164f, 0.0f, -0.213f, 2.112f, 1.793f, -0.533f, 0.0f,
+    };
+
+    // These values map to 16, 128, and 128 respectively, and are computed
+    // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
+    // They are used in the YUV to RGBA conversion formula:
+    //   Y - 16   : Gives 16 values of head and footroom for overshooting
+    //   U - 128  : Turns unsigned U into signed U [-128,127]
+    //   V - 128  : Turns unsigned V into signed V [-128,127]
+    const float yuv_adjust_constrained[3] = {
+        -0.0625f, -0.5f, -0.5f,
+    };
+    // Same as above, but without the head and footroom.
+    const float yuv_adjust_full[3] = {
+        0.0f, -0.5f, -0.5f,
+    };
+
+    switch (frame->format()) {
+      case media::VideoFrame::YV12:  // 420
+      case media::VideoFrame::YV12A:
+      case media::VideoFrame::I420:
+        uv_height_divisor_ = 2;
+        yuv_matrix = yuv_to_rgb_rec601;
+        yuv_adjust = yuv_adjust_constrained;
+        break;
+
+      case media::VideoFrame::YV12HD:  // 420
+        uv_height_divisor_ = 2;
+        yuv_matrix = yuv_to_rgb_rec709;
+        yuv_adjust = yuv_adjust_constrained;
+        break;
+
+      case media::VideoFrame::YV12J:  // 420
+        uv_height_divisor_ = 2;
+        yuv_matrix = yuv_to_rgb_jpeg;
+        yuv_adjust = yuv_adjust_full;
+        break;
+
+      case media::VideoFrame::YV16:  // 422
+      case media::VideoFrame::YV24:  // 444
+        uv_height_divisor_ = 1;
+        yuv_matrix = yuv_to_rgb_rec601;
+        yuv_adjust = yuv_adjust_constrained;
+        break;
+
+      default:
+        NOTREACHED();
+    }
+
+    video_format_ = frame->format();
+
+    // Zero these so everything is reset below.
+    y_width_ = y_height_ = 0;
+  }
+
+  gl_->PushGroupMarkerEXT(0, "YUVConverterContext");
+
+  bool set_clamp = false;
+
+  uint32_t ywidth = frame->coded_size().width();
+  uint32_t yheight = frame->coded_size().height();
+
+  DCHECK_EQ(frame->stride(media::VideoFrame::kUPlane),
+            frame->stride(media::VideoFrame::kVPlane));
+
+  uint32_t ystride = frame->stride(media::VideoFrame::kYPlane);
+  uint32_t uvstride = frame->stride(media::VideoFrame::kUPlane);
+
+  // The following code assumes that extended GLES 2.0 state like
+  // UNPACK_SKIP* and UNPACK_ROW_LENGTH (if available) are set to defaults.
+  gl_->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+  if (ystride != y_width_ || yheight != y_height_) {
+    // Choose width based on the stride.  Clamp texcoords below.
+    y_width_ = ystride;
+    y_height_ = yheight;
+
+    uv_width_ = uvstride;
+    uv_height_ = y_height_ / uv_height_divisor_;
+
+    SetTexcoordClamp(ystride, ywidth);
+    set_clamp = true;
+
+    // Re-create to resize the textures and upload data.
+    gl_->ActiveTexture(GL_TEXTURE0);
+    gl_->BindTexture(GL_TEXTURE_2D, y_texture_);
+    gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, y_width_, y_height_, 0,
+                    format_, GL_UNSIGNED_BYTE,
+                    frame->data(media::VideoFrame::kYPlane));
+
+    gl_->ActiveTexture(GL_TEXTURE1);
+    gl_->BindTexture(GL_TEXTURE_2D, u_texture_);
+    gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, uv_width_, uv_height_,
+                    0, format_, GL_UNSIGNED_BYTE,
+                    frame->data(media::VideoFrame::kUPlane));
+
+    gl_->ActiveTexture(GL_TEXTURE2);
+    gl_->BindTexture(GL_TEXTURE_2D, v_texture_);
+    gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, uv_width_, uv_height_,
+                    0, format_, GL_UNSIGNED_BYTE,
+                    frame->data(media::VideoFrame::kVPlane));
+
+    if (video_format_ == media::VideoFrame::YV12A) {
+      DCHECK_EQ(frame->stride(media::VideoFrame::kYPlane),
+                frame->stride(media::VideoFrame::kAPlane));
+      gl_->ActiveTexture(GL_TEXTURE3);
+      gl_->BindTexture(GL_TEXTURE_2D, a_texture_);
+      gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, y_width_, y_height_,
+                      0, format_, GL_UNSIGNED_BYTE,
+                      frame->data(media::VideoFrame::kAPlane));
+    } else {
+      // if there is no alpha channel, then create a 2x2 texture with full
+      // alpha.
+      const uint8_t alpha[4] = {0xff, 0xff, 0xff, 0xff};
+      gl_->ActiveTexture(GL_TEXTURE3);
+      gl_->BindTexture(GL_TEXTURE_2D, a_texture_);
+      gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format_, 2, 2, 0, format_,
+                      GL_UNSIGNED_BYTE, alpha);
+    }
+  } else {
+    // Width may have changed even though stride remained the same.
+    if (clamp_width_ != ywidth) {
+      SetTexcoordClamp(ystride, ywidth);
+      set_clamp = true;
+    }
+
+    // Bind textures and upload texture data
+    gl_->ActiveTexture(GL_TEXTURE0);
+    gl_->BindTexture(GL_TEXTURE_2D, y_texture_);
+    gl_->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, y_width_, y_height_, format_,
+                       GL_UNSIGNED_BYTE,
+                       frame->data(media::VideoFrame::kYPlane));
+
+    gl_->ActiveTexture(GL_TEXTURE1);
+    gl_->BindTexture(GL_TEXTURE_2D, u_texture_);
+    gl_->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, uv_width_, uv_height_, format_,
+                       GL_UNSIGNED_BYTE,
+                       frame->data(media::VideoFrame::kUPlane));
+
+    gl_->ActiveTexture(GL_TEXTURE2);
+    gl_->BindTexture(GL_TEXTURE_2D, v_texture_);
+    gl_->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, uv_width_, uv_height_, format_,
+                       GL_UNSIGNED_BYTE,
+                       frame->data(media::VideoFrame::kVPlane));
+
+    if (video_format_ == media::VideoFrame::YV12A) {
+      DCHECK_EQ(frame->stride(media::VideoFrame::kYPlane),
+                frame->stride(media::VideoFrame::kAPlane));
+      gl_->ActiveTexture(GL_TEXTURE3);
+      gl_->BindTexture(GL_TEXTURE_2D, a_texture_);
+      gl_->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, y_width_, y_height_, format_,
+                         GL_UNSIGNED_BYTE,
+                         frame->data(media::VideoFrame::kAPlane));
+    } else {
+      gl_->ActiveTexture(GL_TEXTURE3);
+      gl_->BindTexture(GL_TEXTURE_2D, a_texture_);
+    }
+  }
+
+  gl_->BindFramebuffer(GL_FRAMEBUFFER, frame_buffer_);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            tex_out, 0);
+
+#ifndef NDEBUG
+  // We should probably check for framebuffer complete here, but that
+  // will slow this method down so check only in debug mode.
+  GLint status = gl_->CheckFramebufferStatus(GL_FRAMEBUFFER);
+  if (status != GL_FRAMEBUFFER_COMPLETE) {
+    return;
+  }
+#endif
+
+  gl_->Viewport(0, 0, ywidth, yheight);
+
+  gl_->UseProgram(program_);
+
+  if (set_clamp) {
+    gl_->Uniform1f(clamp_width_loc_, clamp_value_);
+  }
+
+  if (yuv_matrix) {
+    gl_->UniformMatrix3fv(yuv_matrix_loc_, 1, 0, yuv_matrix);
+    gl_->Uniform3fv(yuv_adjust_loc_, 1, yuv_adjust);
+  }
+
+  gl_->BindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+  gl_->EnableVertexAttribArray(0);
+  gl_->VertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat),
+                           static_cast<const void*>(0));
+
+  gl_->DrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+  // The YUVConverter shares the context with Skia and possibly other modules
+  // that may make OpenGL calls.  To be a "good OpenGL citizen" for other
+  // (non-Skia) modules that may share this context we restore
+  // buffer/texture/state bindings to OpenGL defaults here.  If we were only
+  // sharing the context with Skia this may not be necessary as we also
+  // Invalidate the GrContext below so that Skia is aware that its state
+  // caches need to be reset.
+
+  gl_->BindBuffer(GL_ARRAY_BUFFER, 0);
+  gl_->DisableVertexAttribArray(0);
+  gl_->UseProgram(0);
+  gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
+
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
+
+  gl_->ActiveTexture(GL_TEXTURE2);
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
+
+  gl_->ActiveTexture(GL_TEXTURE1);
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
+
+  gl_->ActiveTexture(GL_TEXTURE0);
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
+
+  gl_->PopGroupMarkerEXT();
+
+  context_provider_->InvalidateGrContext(kGrInvalidateState);
+}
+
 struct VideoDecoderShim::PendingDecode {
   PendingDecode(uint32_t decode_id,
                 const scoped_refptr<media::DecoderBuffer>& buffer);
   ~PendingDecode();
 
   const uint32_t decode_id;
   const scoped_refptr<media::DecoderBuffer> buffer;
 };
 
 VideoDecoderShim::PendingDecode::PendingDecode(
     uint32_t decode_id,
     const scoped_refptr<media::DecoderBuffer>& buffer)
     : decode_id(decode_id), buffer(buffer) {
 }
 
 VideoDecoderShim::PendingDecode::~PendingDecode() {
 }
 
 struct VideoDecoderShim::PendingFrame {
   explicit PendingFrame(uint32_t decode_id);
   PendingFrame(uint32_t decode_id,
-               const gfx::Size& coded_size,
-               const gfx::Rect& visible_rect);
+               const scoped_refptr<media::VideoFrame>& frame);
   ~PendingFrame();
 
   const uint32_t decode_id;
-  const gfx::Size coded_size;
-  const gfx::Rect visible_rect;
-  std::vector<uint8_t> argb_pixels;
+  scoped_refptr<media::VideoFrame> video_frame;
 
  private:
   // This could be expensive to copy, so guard against that.
   DISALLOW_COPY_AND_ASSIGN(PendingFrame);
 };
 
 VideoDecoderShim::PendingFrame::PendingFrame(uint32_t decode_id)
     : decode_id(decode_id) {
 }
 
-VideoDecoderShim::PendingFrame::PendingFrame(uint32_t decode_id,
-                                             const gfx::Size& coded_size,
-                                             const gfx::Rect& visible_rect)
-    : decode_id(decode_id),
-      coded_size(coded_size),
-      visible_rect(visible_rect),
-      argb_pixels(coded_size.width() * coded_size.height() * 4) {
+VideoDecoderShim::PendingFrame::PendingFrame(
+    uint32_t decode_id,
+    const scoped_refptr<media::VideoFrame>& frame)
+    : decode_id(decode_id), video_frame(frame) {
 }
 
 VideoDecoderShim::PendingFrame::~PendingFrame() {
 }
 
 // DecoderImpl runs the underlying VideoDecoder on the media thread, receiving
 // calls from the VideoDecodeShim on the main thread and sending results back.
 // This class is constructed on the main thread, but used and destructed on the
 // media thread.
 class VideoDecoderShim::DecoderImpl {
@@ skipping 175 matching lines @@
 }
 
 void VideoDecoderShim::DecoderImpl::OnOutputComplete(
     const scoped_refptr<media::VideoFrame>& frame) {
   // Software decoders are expected to generated frames only when a Decode()
   // call is pending.
   DCHECK(awaiting_decoder_);
 
   scoped_ptr<PendingFrame> pending_frame;
   if (!frame->end_of_stream()) {
-    pending_frame.reset(new PendingFrame(
-        decode_id_, frame->coded_size(), frame->visible_rect()));
-    // Convert the VideoFrame pixels to ABGR to match VideoDecodeAccelerator.
-    media::SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
-        frame,
-        &pending_frame->argb_pixels.front(),
-        frame->coded_size().width() * 4);
+    pending_frame.reset(new PendingFrame(decode_id_, frame));
   } else {
     pending_frame.reset(new PendingFrame(decode_id_));
   }
 
   main_message_loop_->PostTask(FROM_HERE,
                                base::Bind(&VideoDecoderShim::OnOutputComplete,
                                           shim_,
                                           base::Passed(&pending_frame)));
 }
 
 void VideoDecoderShim::DecoderImpl::OnResetComplete() {
   main_message_loop_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnResetComplete, shim_));
 }
 
 VideoDecoderShim::VideoDecoderShim(PepperVideoDecoderHost* host)
     : state_(UNINITIALIZED),
       host_(host),
       media_task_runner_(
           RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
       context_provider_(
           RenderThreadImpl::current()->SharedMainThreadContextProvider()),
       texture_pool_size_(0),
       num_pending_decodes_(0),
+      yuv_converter_(new YUVConverter(context_provider_)),
       weak_ptr_factory_(this) {
   DCHECK(host_);
   DCHECK(media_task_runner_.get());
   DCHECK(context_provider_.get());
   decoder_impl_.reset(new DecoderImpl(weak_ptr_factory_.GetWeakPtr()));
 }
 
 VideoDecoderShim::~VideoDecoderShim() {
   DCHECK(RenderThreadImpl::current());
   // Delete any remaining textures.
@@ skipping 23 matching lines @@
   DCHECK_EQ(state_, UNINITIALIZED);
   media::VideoCodec codec = media::kUnknownVideoCodec;
   if (profile <= media::H264PROFILE_MAX)
     codec = media::kCodecH264;
   else if (profile <= media::VP8PROFILE_MAX)
     codec = media::kCodecVP8;
   else if (profile <= media::VP9PROFILE_MAX)
     codec = media::kCodecVP9;
   DCHECK_NE(codec, media::kUnknownVideoCodec);
 
+  if (!yuv_converter_->Initialize()) {
+    return false;
+  }
+
   media::VideoDecoderConfig config(
       codec,
       profile,
       media::VideoFrame::YV12,
       gfx::Size(32, 24),  // Small sizes that won't fail.
       gfx::Rect(32, 24),
       gfx::Size(32, 24),
       NULL /* extra_data */,  // TODO(bbudge) Verify this isn't needed.
       0 /* extra_data_size */,
       false /* decryption */);
@@ skipping 112 matching lines @@
   // the host that decode has completed. This exerts "back pressure" to keep
   // the host from sending buffers that will cause pending_frames_ to grow.
   if (pending_frames_.empty())
     NotifyCompletedDecodes();
 }
 
 void VideoDecoderShim::OnOutputComplete(scoped_ptr<PendingFrame> frame) {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
 
-  if (!frame->argb_pixels.empty()) {
-    if (texture_size_ != frame->coded_size) {
+  if (frame->video_frame) {
+    if (texture_size_ != frame->video_frame->coded_size()) {
       // If the size has changed, all current textures must be dismissed. Add
       // all textures to |textures_to_dismiss_| and dismiss any that aren't in
       // use by the plugin. We will dismiss the rest as they are recycled.
       for (TextureIdMap::const_iterator it = texture_id_map_.begin();
            it != texture_id_map_.end();
            ++it) {
         textures_to_dismiss_.insert(it->first);
       }
       for (TextureIdSet::const_iterator it = available_textures_.begin();
            it != available_textures_.end();
            ++it) {
         DismissTexture(*it);
       }
       available_textures_.clear();
       FlushCommandBuffer();
 
       DCHECK(pending_texture_mailboxes_.empty());
       for (uint32_t i = 0; i < texture_pool_size_; i++)
         pending_texture_mailboxes_.push_back(gpu::Mailbox::Generate());
 
       host_->RequestTextures(texture_pool_size_,
-                             frame->coded_size,
-                             GL_TEXTURE_2D,
+                             frame->video_frame->coded_size(), GL_TEXTURE_2D,
                              pending_texture_mailboxes_);
-      texture_size_ = frame->coded_size;
+      texture_size_ = frame->video_frame->coded_size();
     }
 
     pending_frames_.push(linked_ptr<PendingFrame>(frame.release()));
     SendPictures();
   }
 }
 
 void VideoDecoderShim::SendPictures() {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
   while (!pending_frames_.empty() && !available_textures_.empty()) {
     const linked_ptr<PendingFrame>& frame = pending_frames_.front();
 
     TextureIdSet::iterator it = available_textures_.begin();
     uint32_t texture_id = *it;
     available_textures_.erase(it);
 
     uint32_t local_texture_id = texture_id_map_[texture_id];
-    gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
-    gles2->ActiveTexture(GL_TEXTURE0);
-    gles2->BindTexture(GL_TEXTURE_2D, local_texture_id);
-#if !defined(OS_ANDROID)
-    // BGRA is the native texture format, except on Android, where textures
-    // would be uploaded as GL_RGBA.
-    gles2->TexImage2D(GL_TEXTURE_2D,
-                      0,
-                      GL_BGRA_EXT,
-                      texture_size_.width(),
-                      texture_size_.height(),
-                      0,
-                      GL_BGRA_EXT,
-                      GL_UNSIGNED_BYTE,
-                      &frame->argb_pixels.front());
-#else
-#error Not implemented.
-#endif
+
+    yuv_converter_->Convert(frame->video_frame, local_texture_id);
 
     host_->PictureReady(media::Picture(texture_id, frame->decode_id,
-                                       frame->visible_rect, false));
+                                       frame->video_frame->visible_rect(),
+                                       false));
     pending_frames_.pop();
   }
 
   FlushCommandBuffer();
 
   if (pending_frames_.empty()) {
     // If frames aren't backing up, notify the host of any completed decodes so
     // it can send more buffers.
     NotifyCompletedDecodes();
 
@@ skipping 39 matching lines @@
 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gles2->DeleteTextures(1, &texture_id);
 }
 
 void VideoDecoderShim::FlushCommandBuffer() {
   context_provider_->ContextGL()->Flush();
 }
 
 }  // namespace content