MJPEG acceleration for video capture using VAAPI

media/filters/jpeg_parser.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 "media/filters/jpeg_parser.h"
 
 #include "base/big_endian.h"
 #include "base/logging.h"
 
 using base::BigEndianReader;
@@ skipping 31 matching lines @@
   DQT = 0xDB,      // define quantization table
   DRI = 0xDD,      // define restart internal
   MARKER1 = 0xFF,  // jpeg marker prefix
 };
 }
 
 static bool InRange(int value, int a, int b) {
   return a <= value && value <= b;
 }
 
+static int RoundUp(int value, int mul) {
+  return (value + mul - 1) / mul * mul;
+}
+
 // |frame_header| is already initialized to 0 in ParseJpegPicture.
 static bool ParseSOF(const char* buffer,
                      size_t length,
                      JpegFrameHeader* frame_header) {
   // Spec B.2.2 Frame header syntax
   DCHECK(buffer);
   DCHECK(frame_header);
   BigEndianReader reader(buffer, length);
 
   uint8_t precision;
   READ_U8_OR_RETURN_FALSE(&precision);
   READ_U16_OR_RETURN_FALSE(&frame_header->visible_height);
   READ_U16_OR_RETURN_FALSE(&frame_header->visible_width);
   READ_U8_OR_RETURN_FALSE(&frame_header->num_components);
 
   if (precision != 8) {
     DLOG(ERROR) << "Only support 8-bit precision, not "
                 << static_cast<int>(precision) << " bit for baseline";
     return false;
   }
   if (frame_header->num_components >= arraysize(frame_header->components)) {
     DLOG(ERROR) << "num_components="
                 << static_cast<int>(frame_header->num_components)
                 << " is not supported";
     return false;
   }
 
+  int max_h_factor = 0;
+  int max_v_factor = 0;
   for (size_t i = 0; i < frame_header->num_components; i++) {
     JpegComponent& component = frame_header->components[i];
     READ_U8_OR_RETURN_FALSE(&component.id);
     if (component.id > frame_header->num_components) {
       DLOG(ERROR) << "component id (" << static_cast<int>(component.id)
                   << ") should be <= num_components ("
                   << static_cast<int>(frame_header->num_components) << ")";
       return false;
     }
     uint8_t hv;
     READ_U8_OR_RETURN_FALSE(&hv);
     component.horizontal_sampling_factor = hv / 16;
     component.vertical_sampling_factor = hv % 16;
+    if (component.horizontal_sampling_factor > max_h_factor)
+      max_h_factor = component.horizontal_sampling_factor;
+    if (component.vertical_sampling_factor > max_v_factor)
+      max_v_factor = component.vertical_sampling_factor;
     if (!InRange(component.horizontal_sampling_factor, 1, 4)) {
       DVLOG(1) << "Invalid horizontal sampling factor "
                << static_cast<int>(component.horizontal_sampling_factor);
       return false;
     }
     if (!InRange(component.vertical_sampling_factor, 1, 4)) {
       DVLOG(1) << "Invalid vertical sampling factor "
                << static_cast<int>(component.horizontal_sampling_factor);
       return false;
     }
     READ_U8_OR_RETURN_FALSE(&component.quantization_table_selector);
   }
 
+  // The size of data unit is 8*8 and the coded size should be extended
+  // to complete minimum coded unit, MCU. See Spec A.2.
+  frame_header->coded_width = RoundUp(frame_header->visible_width,
+                                      max_h_factor * 8);
+  frame_header->coded_height = RoundUp(frame_header->visible_height,
+                                       max_v_factor * 8);
+
   return true;
 }
 
 // |q_table| is already initialized to 0 in ParseJpegPicture.
 static bool ParseDQT(const char* buffer,
                      size_t length,
                      JpegQuantizationTable* q_table) {
   // Spec B.2.4.1 Quantization table-specification syntax
   DCHECK(buffer);
   DCHECK(q_table);
@@ skipping 249 matching lines @@
   READ_U8_OR_RETURN_FALSE(&marker2);
   if (marker1 != MARKER1 || marker2 != SOI) {
     DLOG(ERROR) << "Not a JPEG";
     return false;
   }
 
   return ParseSOI(reader.ptr(), reader.remaining(), result);
 }
 
 }  // namespace media