Add support for Rec709 color space videos in software YUV convert path.

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 @@
 
 // Rounds up |coded_size| if necessary for |format|.
 static gfx::Size AdjustCodedSize(VideoFrame::Format format,
                                  const gfx::Size& coded_size) {
   gfx::Size new_coded_size(coded_size);
   switch (format) {
     case VideoFrame::YV12:
     case VideoFrame::YV12A:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
+    case VideoFrame::YV12HD:
       new_coded_size.set_height(RoundUp(new_coded_size.height(), 2));
     // Fallthrough.
     case VideoFrame::YV16:
       new_coded_size.set_width(RoundUp(new_coded_size.width(), 2));
       break;
     default:
       break;
   }
   return new_coded_size;
 }
@@ skipping 48 matching lines @@
       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";
+    case VideoFrame::YV12HD:
+      return "YV12HD";
   }
   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) {
@@ skipping 14 matching lines @@
     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:
+    case VideoFrame::YV12HD:
       // 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;
@@ skipping 315 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::YV12HD:
     case VideoFrame::YV24:
       return 3;
     case VideoFrame::YV12A:
       return 4;
     case VideoFrame::UNKNOWN:
       break;
   }
   NOTREACHED() << "Unsupported video frame format: " << format;
   return 0;
 }
@@ skipping 22 matching lines @@
         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::YV12HD:
     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;
       }
@@ skipping 60 matching lines @@
         case kVPlane:
           return 8;
         default:
           break;
       }
       break;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
+    case VideoFrame::YV12HD:
       switch (plane) {
         case kYPlane:
           return 8;
         case kUPlane:
         case kVPlane:
           return 2;
         default:
           break;
       }
       break;
@@ skipping 33 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::YV12J || format_ == VideoFrame::YV24);
+         format_ == VideoFrame::YV12J || format_ == VideoFrame::YV24 ||
+         format_ == VideoFrame::YV12HD);
   // 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 99 matching lines @@
         case kVPlane:
           return width;
         default:
           break;
       }
       break;
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV12J:
+    case VideoFrame::YV12HD:
       switch (plane) {
         case kYPlane:
           return width;
         case kUPlane:
         case kVPlane:
           return RoundUp(width, 2) / 2;
         default:
           break;
       }
       break;
@@ skipping 44 matching lines @@
         case kYPlane:
         case kUPlane:
         case kVPlane:
           return height;
         default:
           break;
       }
       break;
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
+    case VideoFrame::YV12HD:
     case VideoFrame::I420:
       switch (plane) {
         case kYPlane:
           return height;
         case kUPlane:
         case kVPlane:
           return RoundUp(height, 2) / 2;
         default:
           break;
       }
@@ skipping 79 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