Add plumbing for video pixel formats with JPEG color range.

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 14 matching lines @@
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
   DCHECK(IsValidConfig(format, coded_size, visible_rect, natural_size));
   scoped_refptr<VideoFrame> frame(new VideoFrame(
       format, coded_size, visible_rect, natural_size, timestamp, false));
   switch (format) {
     case VideoFrame::YV12:
     case VideoFrame::YV12A:
     case VideoFrame::YV16:
     case VideoFrame::I420:
+    case VideoFrame::YV12J:
       frame->AllocateYUV();
       break;
     default:
       LOG(FATAL) << "Unsupported frame format: " << format;
   }
   return frame;
 }
 
 // static
 std::string VideoFrame::FormatToString(VideoFrame::Format format) {
   switch (format) {
     case VideoFrame::UNKNOWN:
       return "UNKNOWN";
     case VideoFrame::YV12:
       return "YV12";
     case VideoFrame::YV16:
       return "YV16";
     case VideoFrame::I420:
       return "I420";
     case VideoFrame::NATIVE_TEXTURE:
       return "NATIVE_TEXTURE";
 #if defined(GOOGLE_TV)
     case VideoFrame::HOLE:
       return "HOLE";
 #endif
     case VideoFrame::YV12A:
       return "YV12A";
+    case VideoFrame::YV12J:
+      return "YV12J";
     case VideoFrame::HISTOGRAM_MAX:
       return "HISTOGRAM_MAX";
   }
   NOTREACHED() << "Invalid videoframe format provided: " << format;
   return "";
 }
 
 // static
 bool VideoFrame::IsValidConfig(VideoFrame::Format format,
                                const gfx::Size& coded_size,
@@ skipping 157 matching lines @@
 size_t VideoFrame::NumPlanes(Format format) {
   switch (format) {
     case VideoFrame::NATIVE_TEXTURE:
 #if defined(GOOGLE_TV)
     case VideoFrame::HOLE:
 #endif
       return 0;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
+    case VideoFrame::YV12J:
       return 3;
     case VideoFrame::YV12A:
       return 4;
     case VideoFrame::UNKNOWN:
     case VideoFrame::HISTOGRAM_MAX:
       break;
   }
   NOTREACHED() << "Unsupported video frame format: " << format;
   return 0;
 }
@@ skipping 13 matching lines @@
 }
 
 // static
 size_t VideoFrame::PlaneAllocationSize(Format format,
                                        size_t plane,
                                        const gfx::Size& coded_size) {
   const size_t area =
       RoundUp(coded_size.width(), 2) * RoundUp(coded_size.height(), 2);
   switch (format) {
     case VideoFrame::YV12:
+    case VideoFrame::YV12J:
     case VideoFrame::I420: {
       switch (plane) {
         case VideoFrame::kYPlane:
           return area;
         case VideoFrame::kUPlane:
         case VideoFrame::kVPlane:
           return area / 4;
         default:
           break;
       }
@@ skipping 35 matching lines @@
 }
 
 // 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::YV12A || format_ == VideoFrame::I420 ||
+         format_ == VideoFrame::YV12J);
   // 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.
@@ skipping 74 matching lines @@
   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;
       return RoundUp(width, 2) / 2;
 
     default:
       break;
   }
 
   // Intentionally leave out non-production formats.
   NOTREACHED() << "Unsupported video frame format: " << format_;
@@ skipping 65 matching lines @@
     : mailbox_(mailbox),
       sync_point_(sync_point),
       release_callback_(release_callback) {}
 
 VideoFrame::MailboxHolder::~MailboxHolder() {
   if (!release_callback_.is_null())
     release_callback_.Run(sync_point_);
 }
 
 }  // namespace media