[Mojo Video Capture] Add test coverage for accelerated jpeg decoding

media/gpu/fake_jpeg_decode_accelerator.cc

+// Copyright 2017 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/gpu/fake_jpeg_decode_accelerator.h"
+
+#include "base/bind.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "media/filters/jpeg_parser.h"
+#include "media/gpu/shared_memory_region.h"
+#include "third_party/libyuv/include/libyuv.h"
+
+namespace media {
+
+FakeJpegDecodeAccelerator::FakeJpegDecodeAccelerator(
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(std::move(io_task_runner)),
+      weak_factory_(this) {}
+
+FakeJpegDecodeAccelerator::~FakeJpegDecodeAccelerator() = default;
+
+bool FakeJpegDecodeAccelerator::Initialize(
+    JpegDecodeAccelerator::Client* client) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_ = client;
+  return true;
+}
+
+void FakeJpegDecodeAccelerator::Decode(
+    const BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<VideoFrame>& video_frame) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());

[emircan, 2017/03/09 23:44:25]

I think this is too much work for IO thread which needs to be very responsive.
Considering that IO thread can also be used for other GPU process tasks, it
would make sense to create your own thread here like the other JpegVDA
implementations. 
That would avoid unwanted regressions that might happen when this is in use.
However, this is only in use for your own tests. I am leaving it upto you to
call if it is worth the effort. 

[chfremer, 2017/03/10 18:30:49]

Done.
Note that I still kept the call to Map() on the IO thread, which matches what
the VAAPI implementation currently does. If we want to move that off the IO
thread, I recommend we do it in a separate CL.

+  // SharedMemoryRegion will take over the |bitstream_buffer.handle()|.
+  std::unique_ptr<SharedMemoryRegion> src_shm_(
+      new SharedMemoryRegion(bitstream_buffer, true));
+  if (!src_shm_->Map()) {
+    DLOG(ERROR) << "Unable to map shared memory in FakeJpegDecodeAccelerator";
+    NotifyError(bitstream_buffer.id(), JpegDecodeAccelerator::UNREADABLE_INPUT);
+    return;
+  }
+
+  JpegParseResult parse_result;
+  if (!ParseJpegPicture(static_cast<uint8_t*>(src_shm_->memory()),
+                        src_shm_->size(), &parse_result)) {
+    DLOG(ERROR) << "ParseJpegPicture failed in FakeJpegDecodeAccelerator";
+    NotifyError(bitstream_buffer.id(),
+                JpegDecodeAccelerator::PARSE_JPEG_FAILED);
+    return;
+  }
+  const gfx::Size src_coded_size(parse_result.frame_header.coded_width,
+                                 parse_result.frame_header.coded_height);
+  DCHECK_GE(src_coded_size.width(), video_frame->coded_size().width());
+  DCHECK_GE(src_coded_size.height(), video_frame->coded_size().height());
+
+  uint8_t* dst_y = video_frame->data(VideoFrame::kYPlane);

[emircan, 2017/03/09 23:44:25]

Can you move these inside ConvertToI420()? They aren't used anywhere else.

[chfremer, 2017/03/10 18:30:49]

Done.

+  uint8_t* dst_u = video_frame->data(VideoFrame::kUPlane);
+  uint8_t* dst_v = video_frame->data(VideoFrame::kVPlane);
+  size_t dst_y_stride = video_frame->stride(VideoFrame::kYPlane);
+  size_t dst_u_stride = video_frame->stride(VideoFrame::kUPlane);
+  size_t dst_v_stride = video_frame->stride(VideoFrame::kVPlane);
+
+  if (libyuv::ConvertToI420(
+          static_cast<uint8_t*>(src_shm_->memory()), src_shm_->size(), dst_y,
+          dst_y_stride, dst_u, dst_u_stride, dst_v, dst_v_stride, 0, 0,
+          src_coded_size.width(), src_coded_size.height(),
+          video_frame->coded_size().width(), video_frame->coded_size().height(),
+          libyuv::kRotate0, libyuv::FOURCC_MJPG) != 0) {
+    DLOG(ERROR) << "Software decode failed.";
+    NotifyError(bitstream_buffer.id(), JpegDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeJpegDecodeAccelerator::OnDecodeDoneOnClientThread,
+                 weak_factory_.GetWeakPtr(), bitstream_buffer.id()));
+}
+
+bool FakeJpegDecodeAccelerator::IsSupported() {
+  return true;
+}
+
+void FakeJpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
+                                            Error error) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeJpegDecodeAccelerator::NotifyErrorOnClientThread,
+                 weak_factory_.GetWeakPtr(), bitstream_buffer_id, error));
+}
+
+void FakeJpegDecodeAccelerator::NotifyErrorOnClientThread(
+    int32_t bitstream_buffer_id,
+    Error error) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->NotifyError(bitstream_buffer_id, error);
+}
+
+void FakeJpegDecodeAccelerator::OnDecodeDoneOnClientThread(
+    int32_t input_buffer_id) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->VideoFrameReady(input_buffer_id);
+}
+
+}  // namespace media