Relanding 1143663007: VideoFrame: Separate Pixel Format from Storage Type.

media/blink/skcanvas_video_renderer.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 "media/blink/skcanvas_video_renderer.h"
 
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
@@ skipping 24 matching lines @@
 namespace media {
 
 namespace {
 
 // This class keeps two temporary resources; software bitmap, hardware bitmap.
 // If both bitmap are created and then only software bitmap is updated every
 // frame, hardware bitmap outlives until the media player dies. So we delete
 // a temporary resource if it is not used for 3 sec.
 const int kTemporaryResourceDeletionDelay = 3;  // Seconds;
 
-bool IsYUV(media::VideoFrame::Format format) {
-  switch (format) {
-    case VideoFrame::YV12:
-    case VideoFrame::YV16:
-    case VideoFrame::I420:
-    case VideoFrame::YV12A:
-    case VideoFrame::YV24:
-    case VideoFrame::NV12:
-      return true;
-    case VideoFrame::UNKNOWN:
-    case VideoFrame::NATIVE_TEXTURE:
-#if defined(VIDEO_HOLE)
-    case VideoFrame::HOLE:
-#endif  // defined(VIDEO_HOLE)
-    case VideoFrame::ARGB:
-      return false;
-  }
-  NOTREACHED() << "Invalid videoframe format provided: " << format;
-  return false;
-}
-
 bool CheckColorSpace(const scoped_refptr<VideoFrame>& video_frame,
                      VideoFrame::ColorSpace color_space) {
   int result;
   return video_frame->metadata()->GetInteger(
              media::VideoFrameMetadata::COLOR_SPACE, &result) &&
          result == color_space;
 }
 
-bool IsYUVOrNative(media::VideoFrame::Format format) {
-  return IsYUV(format) || format == media::VideoFrame::NATIVE_TEXTURE;
-}
-
 bool IsSkBitmapProperlySizedTexture(const SkBitmap* bitmap,
                                     const gfx::Size& size) {
   return bitmap->getTexture() && bitmap->width() == size.width() &&
          bitmap->height() == size.height();
 }
 
 bool AllocateSkBitmapTexture(GrContext* gr,
                              SkBitmap* bitmap,
                              const gfx::Size& size) {
   DCHECK(gr);
@@ skipping 89 matching lines @@
     // If skia couldn't do the YUV conversion on GPU, we will on CPU.
     SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
         frame_, pixels, row_bytes);
     return kSuccess;
   }
 
   bool onGetYUV8Planes(SkISize sizes[3],
                        void* planes[3],
                        size_t row_bytes[3],
                        SkYUVColorSpace* color_space) override {
-    if (!frame_.get() || !IsYUV(frame_->format()) ||
+    if (!frame_.get() || !media::VideoFrame::IsYuvPlanar(frame_->format()) ||
         // TODO(rileya): Skia currently doesn't support Rec709 YUV conversion,
         // or YUVA conversion. Remove this case once it does. As-is we will
         // fall back on the pure-software path in this case.
         CheckColorSpace(frame_, VideoFrame::COLOR_SPACE_HD_REC709) ||
         frame_->format() == VideoFrame::YV12A) {
       return false;
     }
 
     if (color_space) {
       if (CheckColorSpace(frame_, VideoFrame::COLOR_SPACE_JPEG))
@@ skipping 89 matching lines @@
 
   SkRect dest;
   dest.set(dest_rect.x(), dest_rect.y(), dest_rect.right(), dest_rect.bottom());
 
   SkPaint paint;
   paint.setAlpha(alpha);
 
   // Paint black rectangle if there isn't a frame available or the
   // frame has an unexpected format.
   if (!video_frame.get() || video_frame->natural_size().IsEmpty() ||
-      !IsYUVOrNative(video_frame->format())) {
+      !(media::VideoFrame::IsYuvPlanar(video_frame->format()) ||
+        (video_frame->storage_type() == media::VideoFrame::STORAGE_TEXTURE))) {
     canvas->drawRect(dest, paint);
     canvas->flush();
     return;
   }
 
   SkBitmap* target_frame = nullptr;
 
-  if (video_frame->format() == VideoFrame::NATIVE_TEXTURE) {
+  if (video_frame->storage_type() == VideoFrame::STORAGE_TEXTURE) {
     // Draw HW Video on both SW and HW Canvas.
     // In SW Canvas case, rely on skia drawing Ganesh SkBitmap on SW SkCanvas.
     if (accelerated_last_frame_.isNull() ||
         video_frame->timestamp() != accelerated_last_frame_timestamp_) {
       DCHECK(context_3d.gl);
       DCHECK(context_3d.gr_context);
       if (accelerated_generator_) {
         // Reset SkBitmap used in SWVideo-to-HWCanvas path.
         accelerated_last_frame_.reset();
         accelerated_generator_ = nullptr;
       }
       if (!CopyVideoFrameTextureToSkBitmapTexture(
               video_frame.get(), &accelerated_last_frame_, context_3d)) {
         NOTREACHED();
         return;
       }
       DCHECK(video_frame->visible_rect().width() ==
                  accelerated_last_frame_.width() &&
              video_frame->visible_rect().height() ==
                  accelerated_last_frame_.height());
 
       accelerated_last_frame_timestamp_ = video_frame->timestamp();
     }
     target_frame = &accelerated_last_frame_;
     accelerated_frame_deleting_timer_.Reset();
   } else if (canvas->getGrContext()) {
-    DCHECK(video_frame->format() != VideoFrame::NATIVE_TEXTURE);
     if (accelerated_last_frame_.isNull() ||
         video_frame->timestamp() != accelerated_last_frame_timestamp_) {
       // Draw SW Video on HW Canvas.
       if (!accelerated_generator_ && !accelerated_last_frame_.isNull()) {
         // Reset SkBitmap used in HWVideo-to-HWCanvas path.
         accelerated_last_frame_.reset();
       }
       accelerated_generator_ = new VideoImageGenerator(video_frame);
 
       // Note: This takes ownership of |accelerated_generator_|.
       if (!SkInstallDiscardablePixelRef(accelerated_generator_,
                                         &accelerated_last_frame_)) {
         NOTREACHED();
         return;
       }
       DCHECK(video_frame->visible_rect().width() ==
                  accelerated_last_frame_.width() &&
              video_frame->visible_rect().height() ==
                  accelerated_last_frame_.height());
 
       accelerated_last_frame_timestamp_ = video_frame->timestamp();
     } else if (accelerated_generator_) {
       accelerated_generator_->set_frame(video_frame);
     }
     target_frame = &accelerated_last_frame_;
     accelerated_frame_deleting_timer_.Reset();
   } else {
     // Draw SW Video on SW Canvas.
-    DCHECK(video_frame->format() != VideoFrame::NATIVE_TEXTURE);
+    DCHECK(VideoFrame::IsMappable(video_frame->storage_type()));
     if (last_frame_.isNull() ||
         video_frame->timestamp() != last_frame_timestamp_) {
       // Check if |bitmap| needs to be (re)allocated.
       if (last_frame_.isNull() ||
           last_frame_.width() != video_frame->visible_rect().width() ||
           last_frame_.height() != video_frame->visible_rect().height()) {
         last_frame_.allocN32Pixels(video_frame->visible_rect().width(),
                                    video_frame->visible_rect().height());
         last_frame_.setIsVolatile(true);
       }
@@ skipping 63 matching lines @@
                                  const Context3D& context_3d) {
   Paint(video_frame, canvas, video_frame->visible_rect(), 0xff,
         SkXfermode::kSrc_Mode, media::VIDEO_ROTATION_0, context_3d);
 }
 
 // static
 void SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
     const scoped_refptr<media::VideoFrame>& video_frame,
     void* rgb_pixels,
     size_t row_bytes) {
-  DCHECK(IsYUVOrNative(video_frame->format()))
-      << video_frame->format();
-  if (IsYUV(video_frame->format())) {
-    DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
-              video_frame->stride(media::VideoFrame::kVPlane));
+  if (!VideoFrame::IsMappable(video_frame->storage_type())) {
+    NOTREACHED() << "Cannot extract pixels from non-CPU frame formats.";
+    return;
+  }
+  if (!media::VideoFrame::IsYuvPlanar(video_frame->format())) {
+    NOTREACHED() << "Non YUV formats are not supported";
+    return;
   }
 
-  size_t y_offset = 0;
-  size_t uv_offset = 0;
-  if (IsYUV(video_frame->format())) {
-    int y_shift = (video_frame->format() == media::VideoFrame::YV16) ? 0 : 1;
-    // Use the "left" and "top" of the destination rect to locate the offset
-    // in Y, U and V planes.
-    y_offset = (video_frame->stride(media::VideoFrame::kYPlane) *
-                video_frame->visible_rect().y()) +
-                video_frame->visible_rect().x();
-    // For format YV12, there is one U, V value per 2x2 block.
-    // For format YV16, there is one U, V value per 2x1 block.
-    uv_offset = (video_frame->stride(media::VideoFrame::kUPlane) *
-                (video_frame->visible_rect().y() >> y_shift)) +
-                (video_frame->visible_rect().x() >> 1);
-  }
+  DCHECK_EQ(video_frame->stride(media::VideoFrame::kUPlane),
+            video_frame->stride(media::VideoFrame::kVPlane));
+
+  const int y_shift =
+      (video_frame->format() == media::VideoFrame::YV16) ? 0 : 1;
+  // Use the "left" and "top" of the destination rect to locate the offset
+  // in Y, U and V planes.
+  const size_t y_offset = (video_frame->stride(media::VideoFrame::kYPlane) *
+                           video_frame->visible_rect().y()) +
+                          video_frame->visible_rect().x();
+  // For format YV12, there is one U, V value per 2x2 block.
+  // For format YV16, there is one U, V value per 2x1 block.
+  const size_t uv_offset = (video_frame->stride(media::VideoFrame::kUPlane) *
+                            (video_frame->visible_rect().y() >> y_shift)) +
+                           (video_frame->visible_rect().x() >> 1);
 
   switch (video_frame->format()) {
     case VideoFrame::YV12:
     case VideoFrame::I420:
       if (CheckColorSpace(video_frame, VideoFrame::COLOR_SPACE_JPEG)) {
         ConvertYUVToRGB32(
           video_frame->data(VideoFrame::kYPlane) + y_offset,
           video_frame->data(VideoFrame::kUPlane) + uv_offset,
           video_frame->data(VideoFrame::kVPlane) + uv_offset,
           static_cast<uint8*>(rgb_pixels),
@@ skipping 76 matching lines @@
 #if SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \
     SK_A32_SHIFT == 24
       libyuv::ARGBToABGR(static_cast<uint8*>(rgb_pixels),
                          row_bytes,
                          static_cast<uint8*>(rgb_pixels),
                          row_bytes,
                          video_frame->visible_rect().width(),
                          video_frame->visible_rect().height());
 #endif
       break;
-
-    case VideoFrame::NATIVE_TEXTURE:
-      NOTREACHED();
-      break;
-#if defined(VIDEO_HOLE)
-    case VideoFrame::HOLE:
-#endif  // defined(VIDEO_HOLE)
+#if defined(OS_MACOSX) || defined(OS_CHROMEOS)
+    case VideoFrame::NV12:
+#endif
     case VideoFrame::ARGB:
+    case VideoFrame::XRGB:
     case VideoFrame::UNKNOWN:
-    case VideoFrame::NV12:
       NOTREACHED();
   }
 }
 
 // static
 void SkCanvasVideoRenderer::CopyVideoFrameTextureToGLTexture(
     gpu::gles2::GLES2Interface* gl,
     VideoFrame* video_frame,
     unsigned int texture,
     unsigned int internal_format,
     unsigned int type,
     bool premultiply_alpha,
     bool flip_y) {
-  DCHECK(video_frame && video_frame->format() == VideoFrame::NATIVE_TEXTURE);
-  DCHECK_EQ(1u, VideoFrame::NumTextures(video_frame->texture_format()));
+  DCHECK(video_frame);
+  DCHECK_EQ(video_frame->storage_type(), VideoFrame::STORAGE_TEXTURE);
+  DCHECK_EQ(1u, VideoFrame::NumPlanes(video_frame->format()));
+
   const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
   DCHECK(mailbox_holder.texture_target == GL_TEXTURE_2D ||
          mailbox_holder.texture_target == GL_TEXTURE_RECTANGLE_ARB ||
          mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES);
 
   gl->WaitSyncPointCHROMIUM(mailbox_holder.sync_point);
   uint32 source_texture = gl->CreateAndConsumeTextureCHROMIUM(
       mailbox_holder.texture_target, mailbox_holder.mailbox.name);
 
   // The video is stored in a unmultiplied format, so premultiply
@@ skipping 21 matching lines @@
   last_frame_timestamp_ = media::kNoTimestamp();
 }
 
 void SkCanvasVideoRenderer::ResetAcceleratedLastFrame() {
   accelerated_last_frame_.reset();
   accelerated_generator_ = nullptr;
   accelerated_last_frame_timestamp_ = media::kNoTimestamp();
 }
 
 }  // namespace media