Support for YUV 4:4:4 subsampling.

media/base/video_frame.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/base/video_frame.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 18 matching lines @@
     VideoFrame::Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
   // Since we're creating a new YUV frame (and allocating memory for it
   // ourselves), we can pad the requested |coded_size| if necessary if the
   // request does not line up on sample boundaries.
   gfx::Size new_coded_size(coded_size);
   switch (format) {
+    case VideoFrame::YV24:
+      break;
     case VideoFrame::YV12:
     case VideoFrame::YV12A:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
       new_coded_size.set_height((new_coded_size.height() + 1) / 2 * 2);
     // Fallthrough.
     case VideoFrame::YV16:
       new_coded_size.set_width((new_coded_size.width() + 1) / 2 * 2);
       break;
-    default:
+    case VideoFrame::UNKNOWN:
+    case VideoFrame::NV12:
+#if defined(VIDEO_HOLE)
+    case VideoFrame::HOLE:
+#endif  // defined(VIDEO_HOLE)
+    case VideoFrame::NATIVE_TEXTURE:
       LOG(FATAL) << "Only YUV formats supported: " << format;
       return NULL;
   }
   DCHECK(IsValidConfig(format, new_coded_size, visible_rect, natural_size));
   scoped_refptr<VideoFrame> frame(
       new VideoFrame(format,
                      new_coded_size,
                      visible_rect,
                      natural_size,
                      scoped_ptr<gpu::MailboxHolder>(),
@@ skipping 19 matching lines @@
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
       return "HOLE";
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::YV12A:
       return "YV12A";
     case VideoFrame::YV12J:
       return "YV12J";
     case VideoFrame::NV12:
       return "NV12";
+    case VideoFrame::YV24:
+      return "YV24";
   }
   NOTREACHED() << "Invalid videoframe format provided: " << format;
   return "";
 }
 
 // static
 bool VideoFrame::IsValidConfig(VideoFrame::Format format,
                                const gfx::Size& coded_size,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& natural_size) {
   // Check maximum limits for all formats.
   if (coded_size.GetArea() > limits::kMaxCanvas ||
       coded_size.width() > limits::kMaxDimension ||
       coded_size.height() > limits::kMaxDimension ||
       visible_rect.x() < 0 || visible_rect.y() < 0 ||
       visible_rect.right() > coded_size.width() ||
       visible_rect.bottom() > coded_size.height() ||
       natural_size.GetArea() > limits::kMaxCanvas ||
       natural_size.width() > limits::kMaxDimension ||
       natural_size.height() > limits::kMaxDimension)
     return false;
 
   // Check format-specific width/height requirements.
   switch (format) {
     case VideoFrame::UNKNOWN:
       return (coded_size.IsEmpty() && visible_rect.IsEmpty() &&
               natural_size.IsEmpty());
+    case VideoFrame::YV24:
+      break;
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
     case VideoFrame::I420:
     case VideoFrame::YV12A:
     case VideoFrame::NV12:
-      // YUV formats have width/height requirements due to chroma subsampling.
+      // Subsampled YUV formats have width/height requirements.
       if (static_cast<size_t>(coded_size.height()) <
           RoundUp(visible_rect.bottom(), 2))
         return false;
     // Fallthrough.
     case VideoFrame::YV16:
       if (static_cast<size_t>(coded_size.width()) <
           RoundUp(visible_rect.right(), 2))
         return false;
       break;
     case VideoFrame::NATIVE_TEXTURE:
@@ skipping 48 matching lines @@
     size_t data_size,
     base::SharedMemoryHandle handle,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
     return NULL;
   if (data_size < AllocationSize(format, coded_size))
     return NULL;
 
   switch (format) {
-    case I420: {
+    case VideoFrame::I420: {
       scoped_refptr<VideoFrame> frame(
           new VideoFrame(format,
                          coded_size,
                          visible_rect,
                          natural_size,
                          scoped_ptr<gpu::MailboxHolder>(),
                          timestamp,
                          false));
       frame->shared_memory_handle_ = handle;
       frame->strides_[kYPlane] = coded_size.width();
@@ skipping 183 matching lines @@
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
       return 0;
     case VideoFrame::NV12:
       return 2;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
+    case VideoFrame::YV24:
       return 3;
     case VideoFrame::YV12A:
       return 4;
     case VideoFrame::UNKNOWN:
       break;
   }
   NOTREACHED() << "Unsupported video frame format: " << format;
   return 0;
 }
 
 
 // static
 size_t VideoFrame::AllocationSize(Format format, const gfx::Size& coded_size) {
   size_t total = 0;
   for (size_t i = 0; i < NumPlanes(format); ++i)
     total += PlaneAllocationSize(format, i, coded_size);
   return total;
 }
 
 // static
 gfx::Size VideoFrame::PlaneSize(Format format,
                                 size_t plane,
                                 const gfx::Size& coded_size) {
+  // Align to multiple-of-two size overall. This ensures that non-subsampled
+  // planes can be addressed by pixel with the same scaling as the subsampled
+  // planes.
   const int width = RoundUp(coded_size.width(), 2);
   const int height = RoundUp(coded_size.height(), 2);
   switch (format) {
+    case VideoFrame::YV24:
+      switch (plane) {
+        case VideoFrame::kYPlane:
+        case VideoFrame::kUPlane:
+        case VideoFrame::kVPlane:
+          return gfx::Size(width, height);
+        default:
+          break;
+      }
+      break;
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
-    case VideoFrame::I420: {
+    case VideoFrame::I420:
       switch (plane) {
         case VideoFrame::kYPlane:
           return gfx::Size(width, height);
         case VideoFrame::kUPlane:
         case VideoFrame::kVPlane:
           return gfx::Size(width / 2, height / 2);
         default:
           break;
       }
-    }
-    case VideoFrame::YV12A: {
+      break;
+    case VideoFrame::YV12A:
       switch (plane) {
         case VideoFrame::kYPlane:
         case VideoFrame::kAPlane:
           return gfx::Size(width, height);
         case VideoFrame::kUPlane:
         case VideoFrame::kVPlane:
           return gfx::Size(width / 2, height / 2);
         default:
           break;
       }
-    }
-    case VideoFrame::YV16: {
+      break;
+    case VideoFrame::YV16:
       switch (plane) {
         case VideoFrame::kYPlane:
           return gfx::Size(width, height);
         case VideoFrame::kUPlane:
         case VideoFrame::kVPlane:
           return gfx::Size(width / 2, height);
         default:
           break;
       }
-    }
-    case VideoFrame::NV12: {
+      break;
+    case VideoFrame::NV12:
       switch (plane) {
         case VideoFrame::kYPlane:
           return gfx::Size(width, height);
         case VideoFrame::kUVPlane:
           return gfx::Size(width, height / 2);
         default:
           break;
       }
-    }
+      break;
     case VideoFrame::UNKNOWN:
     case VideoFrame::NATIVE_TEXTURE:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
       break;
   }
   NOTREACHED() << "Unsupported video frame format/plane: "
                << format << "/" << plane;
   return gfx::Size();
 }
 
 size_t VideoFrame::PlaneAllocationSize(Format format,
                                        size_t plane,
                                        const gfx::Size& coded_size) {
   // VideoFrame formats are (so far) all YUV and 1 byte per sample.
   return PlaneSize(format, plane, coded_size).GetArea();
 }
 
 // static
 int VideoFrame::PlaneHorizontalBitsPerPixel(Format format, size_t plane) {
   switch (format) {
-    case VideoFrame::YV12A:
-      if (plane == kAPlane)
-        return 8;
-    // fallthrough
+    case VideoFrame::YV24:
+      switch (plane) {
+        case kYPlane:
+        case kUPlane:
+        case kVPlane:
+          return 8;
+        default:
+          break;
+      }
+      break;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
-    case VideoFrame::YV12J: {
+    case VideoFrame::YV12J:
       switch (plane) {
         case kYPlane:
           return 8;
         case kUPlane:
         case kVPlane:
           return 2;
         default:
           break;
       }
-    }
-
-    case VideoFrame::NV12: {
+      break;
+    case VideoFrame::YV12A:
+      switch (plane) {
+        case kYPlane:
+        case kAPlane:
+          return 8;
+        case kUPlane:
+        case kVPlane:
+          return 2;
+        default:
+          break;
+      }
+      break;
+    case VideoFrame::NV12:
       switch (plane) {
         case kYPlane:
           return 8;
         case kUVPlane:
           return 4;
         default:
           break;
       }
-    }
-    default:
+      break;
+    case VideoFrame::UNKNOWN:
+#if defined(VIDEO_HOLE)
+    case VideoFrame::HOLE:
+#endif  // defined(VIDEO_HOLE)
+    case VideoFrame::NATIVE_TEXTURE:
       break;
   }
-
-  NOTREACHED() << "Unsupported video frame format: " << format;
+  NOTREACHED() << "Unsupported video frame format/plane: "
+               << format << "/" << plane;
   return 0;
 }
 
 // Release data allocated by AllocateYUV().
 static void ReleaseData(uint8* data) {
   DCHECK(data);
   base::AlignedFree(data);
 }
 
 void VideoFrame::AllocateYUV() {
   DCHECK(format_ == VideoFrame::YV12 || format_ == VideoFrame::YV16 ||
          format_ == VideoFrame::YV12A || format_ == VideoFrame::I420 ||
-         format_ == VideoFrame::YV12J);
+         format_ == VideoFrame::YV12J || format_ == VideoFrame::YV24);
   // Align Y rows at least at 16 byte boundaries.  The stride for both
   // YV12 and YV16 is 1/2 of the stride of Y.  For YV12, every row of bytes for
   // U and V applies to two rows of Y (one byte of UV for 4 bytes of Y), so in
   // the case of YV12 the strides are identical for the same width surface, but
   // the number of bytes allocated for YV12 is 1/2 the amount for U & V as
   // YV16. We also round the height of the surface allocated to be an even
   // number to avoid any potential of faulting by code that attempts to access
   // the Y values of the final row, but assumes that the last row of U & V
   // applies to a full two rows of Y. YV12A is the same as YV12, but with an
   // additional alpha plane that has the same size and alignment as the Y plane.
-
   size_t y_stride = RoundUp(row_bytes(VideoFrame::kYPlane),
                             kFrameSizeAlignment);
   size_t uv_stride = RoundUp(row_bytes(VideoFrame::kUPlane),
                              kFrameSizeAlignment);
+
   // The *2 here is because some formats (e.g. h264) allow interlaced coding,
   // and then the size needs to be a multiple of two macroblocks (vertically).
   // See libavcodec/utils.c:avcodec_align_dimensions2().
   size_t y_height = RoundUp(coded_size_.height(), kFrameSizeAlignment * 2);
   size_t uv_height =
       (format_ == VideoFrame::YV12 || format_ == VideoFrame::YV12A ||
        format_ == VideoFrame::I420)
           ? y_height / 2
           : y_height;
   size_t y_bytes = y_height * y_stride;
@@ skipping 62 matching lines @@
 
 int VideoFrame::stride(size_t plane) const {
   DCHECK(IsValidPlane(plane));
   return strides_[plane];
 }
 
 int VideoFrame::row_bytes(size_t plane) const {
   DCHECK(IsValidPlane(plane));
   int width = coded_size_.width();
   switch (format_) {
-    // Planar, 8bpp.
-    case YV12A:
-      if (plane == kAPlane)
-        return width;
-    // Fallthrough.
-    case YV12:
-    case YV16:
-    case I420:
-    case YV12J:
-      if (plane == kYPlane)
-        return width;
-      else if (plane <= kVPlane)
-        return RoundUp(width, 2) / 2;
+    case VideoFrame::YV24:
+      switch (plane) {
+        case kYPlane:
+        case kUPlane:
+        case kVPlane:
+          return width;
+        default:
+          break;
+      }
       break;
-
-    case NV12:
-      if (plane <= kUVPlane)
-        return width;
+    case VideoFrame::YV12:
+    case VideoFrame::YV16:
+    case VideoFrame::I420:
+    case VideoFrame::YV12J:
+      switch (plane) {
+        case kYPlane:
+          return width;
+        case kUPlane:
+        case kVPlane:
+          return RoundUp(width, 2) / 2;
+        default:
+          break;
+      }
       break;
-
-    default:
+    case VideoFrame::YV12A:
+      switch (plane) {
+        case kYPlane:
+        case kAPlane:
+          return width;
+        case kUPlane:
+        case kVPlane:
+          return RoundUp(width, 2) / 2;
+        default:
+          break;
+      }
+      break;
+    case VideoFrame::NV12:
+      switch (plane) {
+        case kYPlane:
+        case kUVPlane:
+          return width;
+        default:
+          break;
+      }
+      break;
+    case VideoFrame::UNKNOWN:
+#if defined(VIDEO_HOLE)
+    case VideoFrame::HOLE:
+#endif  // defined(VIDEO_HOLE)
+    case VideoFrame::NATIVE_TEXTURE:
       break;
   }
-
-  // Intentionally leave out non-production formats.
-  NOTREACHED() << "Unsupported video frame format: " << format_;
+  NOTREACHED() << "Unsupported video frame format/plane: "
+               << format_ << "/" << plane;
   return 0;
 }
 
 int VideoFrame::rows(size_t plane) const {
   DCHECK(IsValidPlane(plane));
   int height = coded_size_.height();
   switch (format_) {
-    case YV16:
-      return height;
-
-    case YV12A:
-      if (plane == kAPlane)
-        return height;
-    // Fallthrough.
-    case YV12:
-    case YV12J:
-    case I420:
-      if (plane == kYPlane)
-        return height;
-      else if (plane <= kVPlane)
-        return RoundUp(height, 2) / 2;
+    case VideoFrame::YV24:
+    case VideoFrame::YV16:
+      switch (plane) {
+        case kYPlane:
+        case kUPlane:
+        case kVPlane:
+          return height;
+        default:
+          break;
+      }
       break;
-
-    case NV12:
-      if (plane == kYPlane)
-        return height;
-      else if (plane == kUVPlane)
-        return RoundUp(height, 2) / 2;
+    case VideoFrame::YV12:
+    case VideoFrame::YV12J:
+    case VideoFrame::I420:
+      switch (plane) {
+        case kYPlane:
+          return height;
+        case kUPlane:
+        case kVPlane:
+          return RoundUp(height, 2) / 2;
+        default:
+          break;
+      }
       break;
-
-    default:
+    case VideoFrame::YV12A:
+      switch (plane) {
+        case kYPlane:
+        case kAPlane:
+          return height;
+        case kUPlane:
+        case kVPlane:
+          return RoundUp(height, 2) / 2;
+        default:
+          break;
+      }
+      break;
+    case VideoFrame::NV12:
+      switch (plane) {
+        case kYPlane:
+          return height;
+        case kUVPlane:
+          return RoundUp(height, 2) / 2;
+        default:
+          break;
+      }
+      break;
+    case VideoFrame::UNKNOWN:
+#if defined(VIDEO_HOLE)
+    case VideoFrame::HOLE:
+#endif  // defined(VIDEO_HOLE)
+    case VideoFrame::NATIVE_TEXTURE:
       break;
   }
-
-  // Intentionally leave out non-production formats.
-  NOTREACHED() << "Unsupported video frame format: " << format_;
+  NOTREACHED() << "Unsupported video frame format/plane: "
+               << format_ << "/" << plane;
   return 0;
 }
 
 uint8* VideoFrame::data(size_t plane) const {
   DCHECK(IsValidPlane(plane));
   return data_[plane];
 }
 
 const gpu::MailboxHolder* VideoFrame::mailbox_holder() const {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
@@ skipping 24 matching lines @@
       break;
     for (int row = 0; row < rows(plane); ++row) {
       base::MD5Update(context, base::StringPiece(
           reinterpret_cast<char*>(data(plane) + stride(plane) * row),
           row_bytes(plane)));
     }
   }
 }
 
 }  // namespace media