MJPEG acceleration for video capture using VAAPI

content/common/gpu/media/vaapi_jpeg_decoder.cc

 // Copyright 2015 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 "content/common/gpu/media/vaapi_jpeg_decoder.h"
 
 #include "base/logging.h"
 #include "media/filters/jpeg_parser.h"
 
 namespace {
@@ skipping 83 matching lines @@
       jpeg.frame_header.visible_height < 1) {
     DLOG(ERROR) << "width(" << jpeg.frame_header.visible_width
                 << ") and height(" << jpeg.frame_header.visible_height
                 << ") should be at least 1";
     return false;
   }
 
   // Size 64k*64k is the maximum in the JPEG standard. VAAPI doesn't support
   // resolutions larger than 16k*16k.
   const int kMaxDimension = 16384;
-  if (jpeg.frame_header.visible_width > kMaxDimension ||
-      jpeg.frame_header.visible_height > kMaxDimension) {
+  if (jpeg.frame_header.coded_width > kMaxDimension ||
+      jpeg.frame_header.coded_height > kMaxDimension) {
     DLOG(ERROR) << "VAAPI doesn't support size("
-                << jpeg.frame_header.visible_width << "*"
-                << jpeg.frame_header.visible_height << ") larger than "
+                << jpeg.frame_header.coded_width << "*"
+                << jpeg.frame_header.coded_height << ") larger than "
                 << kMaxDimension << "*" << kMaxDimension;
     return false;
   }
 
   if (jpeg.frame_header.num_components != 3) {
     DLOG(ERROR) << "VAAPI doesn't support num_components("
                 << static_cast<int>(jpeg.frame_header.num_components)
                 << ") != 3";
     return false;
   }
@@ skipping 16 matching lines @@
     return false;
   }
 
   return true;
 }
 
 static void FillPictureParameters(
     const media::JpegFrameHeader& frame_header,
     VAPictureParameterBufferJPEGBaseline* pic_param) {
   memset(pic_param, 0, sizeof(*pic_param));
-  pic_param->picture_width = frame_header.visible_width;
-  pic_param->picture_height = frame_header.visible_height;
+  pic_param->picture_width = frame_header.coded_width;
+  pic_param->picture_height = frame_header.coded_height;
   pic_param->num_components = frame_header.num_components;
 
   for (int i = 0; i < pic_param->num_components; i++) {
     pic_param->components[i].component_id = frame_header.components[i].id;
     pic_param->components[i].h_sampling_factor =
         frame_header.components[i].horizontal_sampling_factor;
     pic_param->components[i].v_sampling_factor =
         frame_header.components[i].vertical_sampling_factor;
     pic_param->components[i].quantiser_table_selector =
         frame_header.components[i].quantization_table_selector;
@@ skipping 80 matching lines @@
     slice_param->components[i].ac_table_selector =
         parse_result.scan.components[i].ac_selector;
   }
   slice_param->restart_interval = parse_result.restart_interval;
 
   // Cast to int to prevent overflow.
   int max_h_factor =
       parse_result.frame_header.components[0].horizontal_sampling_factor;
   int max_v_factor =
       parse_result.frame_header.components[0].vertical_sampling_factor;
-  int visible_width = parse_result.frame_header.visible_width;
-  int visible_height = parse_result.frame_header.visible_height;
-  int mcu_cols = (visible_width + max_h_factor * 8 - 1) / (max_h_factor * 8);
+  int mcu_cols = parse_result.frame_header.coded_width / (max_h_factor * 8);
   DCHECK_GT(mcu_cols, 0);
-  int mcu_rows = (visible_height + max_v_factor * 8 - 1) / (max_v_factor * 8);
+  int mcu_rows = parse_result.frame_header.coded_height / (max_v_factor * 8);
   DCHECK_GT(mcu_rows, 0);
   slice_param->num_mcus = mcu_rows * mcu_cols;
 }
 
 // static
 bool VaapiJpegDecoder::Decode(VaapiWrapper* vaapi_wrapper,
                               const media::JpegParseResult& parse_result,
                               VASurfaceID va_surface) {
   DCHECK_NE(va_surface, VA_INVALID_SURFACE);
   if (!IsVaapiSupportedJpeg(parse_result))
@@ skipping 34 matching lines @@
                                    const_cast<char*>(parse_result.data)))
     return false;
 
   if (!vaapi_wrapper->ExecuteAndDestroyPendingBuffers(va_surface))
     return false;
 
   return true;
 }
 
 }  // namespace content