Create VA surface with correct VA RT format for MJPEG decode acceleration

content/common/gpu/media/vaapi_jpeg_decode_accelerator.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_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 10 matching lines @@
 // UMA errors that the VaapiJpegDecodeAccelerator class reports.
 enum VAJDADecoderFailure {
   VAAPI_ERROR = 0,
   VAJDA_DECODER_FAILURES_MAX,
 };
 
 static void ReportToUMA(VAJDADecoderFailure failure) {
   UMA_HISTOGRAM_ENUMERATION("Media.VAJDA.DecoderFailure", failure,
                             VAJDA_DECODER_FAILURES_MAX);
 }
+
+unsigned int VaSurfaceFormatForJpeg(

[wuchengli, 2015/07/13 07:26:22]

static

[kcwu, 2015/07/13 07:39:40]

Done.

+    const media::JpegParseResult& parse_result) {

[henryhsu, 2015/07/09 06:56:26]

Can we pass JpegFrameHeader directly since we don't use other parts in
JpegParseResult?

[kcwu, 2015/07/13 05:45:16]

Done.

+  // The range of sampling factor is [1, 4]. Pack them into integer to make the
+  // matching code simpler. For example, 0x211 means the sampling factor are 2,
+  // 1, 1 for 3 components.
+  unsigned int h = 0, v = 0;
+  for (int i = 0; i < parse_result.frame_header.num_components; i++) {
+    DCHECK_LE(
+        parse_result.frame_header.components[i].horizontal_sampling_factor, 4);

[wuchengli, 2015/07/13 07:26:22]

Is this a bug or invalid jpeg? If it's an invalid jpeg, it shouldn't crash in
debug mode and should be changed to DVLOG.

[kcwu, 2015/07/13 07:39:40]

Invalid jpeg should already be handled by jpeg parser. So it is bug if they
reached here.

+    DCHECK_LE(parse_result.frame_header.components[i].vertical_sampling_factor,
+              4);
+    h = h << 4 |
+        parse_result.frame_header.components[i].horizontal_sampling_factor;
+    v = v << 4 |
+        parse_result.frame_header.components[i].vertical_sampling_factor;
+  }
+
+  switch (parse_result.frame_header.num_components) {
+    case 1:  // Grey image
+      return VA_RT_FORMAT_YUV400;
+
+    case 3:  // Y Cb Cr color image
+      // See https://en.wikipedia.org/wiki/Chroma_subsampling for the
+      // definition of these numbers.
+      if (h == 0x211 && v == 0x211)
+        return VA_RT_FORMAT_YUV420;
+
+      if (h == 0x211 && v == 0x111)
+        return VA_RT_FORMAT_YUV422;
+
+      if (h == 0x111 && v == 0x111)
+        return VA_RT_FORMAT_YUV444;
+
+      if (h == 0x411 && v == 0x111)
+        return VA_RT_FORMAT_YUV411;
+  }

[wuchengli, 2015/07/13 07:26:22]

DVLOG the values of h and v here.

[kcwu, 2015/07/13 07:39:40]

Done.

+
+  return 0;
+}
+
 }  // namespace
 
 VaapiJpegDecodeAccelerator::DecodeRequest::DecodeRequest(
     const media::BitstreamBuffer& bitstream_buffer,
     scoped_ptr<base::SharedMemory> shm,
     const scoped_refptr<media::VideoFrame>& video_frame)
     : bitstream_buffer(bitstream_buffer),
       shm(shm.Pass()),
       video_frame(video_frame) {
 }
@@ skipping 142 matching lines @@
   if (!media::ParseJpegPicture(
           reinterpret_cast<const uint8_t*>(request->shm->memory()),
           request->bitstream_buffer.size(), &parse_result)) {
     DLOG(ERROR) << "ParseJpegPicture failed";
     NotifyErrorFromDecoderThread(
         request->bitstream_buffer.id(),
         media::JpegDecodeAccelerator::PARSE_JPEG_FAILED);
     return;
   }
 
+  unsigned int new_va_rt_format = VaSurfaceFormatForJpeg(parse_result);
+  if (!new_va_rt_format) {
+    DLOG(ERROR) << "Unsupported subsampling";
+    NotifyErrorFromDecoderThread(
+        request->bitstream_buffer.id(),
+        media::JpegDecodeAccelerator::UNSUPPORTED_JPEG);

[henryhsu, 2015/07/09 06:56:26]

You don't need "media::JpegDecodeAccelerator::" since VaapiJpegDecodeAccelerator
inherits from media::JpegDecodeAccelerator.
Same as others.

[kcwu, 2015/07/13 05:45:16]

Done.

+    return;
+  }
+
   // Reuse VASurface if size doesn't change.
   gfx::Size new_coded_size(parse_result.frame_header.coded_width,
                            parse_result.frame_header.coded_height);
-  if (new_coded_size != coded_size_ || va_surface_id_ == VA_INVALID_SURFACE) {
+  if (new_coded_size != coded_size_ || va_surface_id_ == VA_INVALID_SURFACE ||
+      new_va_rt_format != va_rt_format_) {
     vaapi_wrapper_->DestroySurfaces();
     va_surface_id_ = VA_INVALID_SURFACE;
+    va_rt_format_ = new_va_rt_format;
 
     std::vector<VASurfaceID> va_surfaces;
-    if (!vaapi_wrapper_->CreateSurfaces(new_coded_size, 1, &va_surfaces)) {
+    if (!vaapi_wrapper_->CreateSurfaces(va_rt_format_, new_coded_size, 1,
+                                        &va_surfaces)) {
       LOG(ERROR) << "Create VA surface failed";
       NotifyErrorFromDecoderThread(
           request->bitstream_buffer.id(),
           media::JpegDecodeAccelerator::PLATFORM_FAILURE);
       return;
     }
     va_surface_id_ = va_surfaces[0];
     coded_size_ = new_coded_size;
   }
 
@@ skipping 36 matching lines @@
 
   scoped_ptr<DecodeRequest> request(
       new DecodeRequest(bitstream_buffer, shm.Pass(), video_frame));
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&request)));
 }
 
 }  // namespace content