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 39 matching lines @@
     case VideoFrame::kVPlane:
       switch (format) {
         case VideoFrame::YV24:
           return gfx::Size(1, 1);
 
         case VideoFrame::YV16:
           return gfx::Size(2, 1);
 
         case VideoFrame::YV12:
         case VideoFrame::YV12J:
+        case VideoFrame::YV12HD:
         case VideoFrame::I420:
         case VideoFrame::YV12A:
         case VideoFrame::NV12:
           return gfx::Size(2, 2);
 
         case VideoFrame::UNKNOWN:
 #if defined(VIDEO_HOLE)
         case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
         case VideoFrame::NATIVE_TEXTURE:
@@ skipping 46 matching lines @@
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
   switch (format) {
     case VideoFrame::YV12:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV12A:
     case VideoFrame::YV12J:
     case VideoFrame::YV24:
+    case VideoFrame::YV12HD:
       break;
 
     case VideoFrame::UNKNOWN:
     case VideoFrame::NV12:
     case VideoFrame::NATIVE_TEXTURE:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::ARGB:
       NOTIMPLEMENTED();
@@ skipping 38 matching lines @@
     case VideoFrame::YV12A:
       return "YV12A";
     case VideoFrame::YV12J:
       return "YV12J";
     case VideoFrame::NV12:
       return "NV12";
     case VideoFrame::YV24:
       return "YV24";
     case VideoFrame::ARGB:
       return "ARGB";
+    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 22 matching lines @@
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
       return true;
 
     case VideoFrame::YV24:
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
     case VideoFrame::I420:
     case VideoFrame::YV12A:
     case VideoFrame::NV12:
+    case VideoFrame::YV12HD:
     case VideoFrame::YV16:
     case VideoFrame::ARGB:
       // Check that software-allocated buffer formats are aligned correctly and
       // not empty.
       const gfx::Size alignment = CommonAlignment(format);
       return RoundUp(visible_rect.right(), alignment.width()) <=
                  static_cast<size_t>(coded_size.width()) &&
              RoundUp(visible_rect.bottom(), alignment.height()) <=
                  static_cast<size_t>(coded_size.height()) &&
              !coded_size.IsEmpty() && !visible_rect.IsEmpty() &&
@@ skipping 312 matching lines @@
 #endif  // defined(VIDEO_HOLE)
       return 0;
     case VideoFrame::ARGB:
       return 1;
     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 53 matching lines @@
 }
 
 // Release data allocated by AllocateYUV().
 static void ReleaseData(uint8* data) {
   DCHECK(data);
   base::AlignedFree(data);
 }
 
 void VideoFrame::AllocateYUV() {
   DCHECK(format_ == YV12 || format_ == YV16 || format_ == YV12A ||
-         format_ == I420 || format_ == YV12J || format_ == YV24);
+         format_ == I420 || format_ == YV12J || format_ == YV24 ||
+         format_ == YV12HD);
   static_assert(0 == kYPlane, "y plane data must be index 0");
 
   size_t data_size = 0;
   size_t offset[kMaxPlanes];
   for (size_t plane = 0; plane < VideoFrame::NumPlanes(format_); ++plane) {
     // The *2 in alignment for height 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().
     const size_t height = RoundUp(rows(plane), kFrameSizeAlignment * 2);
@@ skipping 166 matching lines @@
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane) {
     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