camera/hal/usb/cached_frame.h

/* Copyright 2017 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef CAMERA_HAL_USB_CACHED_FRAME_H_
#define CAMERA_HAL_USB_CACHED_FRAME_H_

#include <memory>
#include <vector>

#include <camera/camera_metadata.h>

#include "cros-camera/camera_face_detection.h"
#include "cros-camera/camera_metrics.h"
#include "cros-camera/common_types.h"
#include "cros-camera/jpeg_compressor.h"
#include "cros-camera/jpeg_decode_accelerator.h"
#include "hal/usb/image_processor.h"

namespace cros {

// CachedFrame contains a source FrameBuffer and a cached, converted
// FrameBuffer. The incoming frames would be converted to YU12, the default
// format of libyuv, to allow convenient processing.
class CachedFrame {
 public:
  explicit CachedFrame(const android::CameraMetadata& static_metadata);

  // Convert |in_frame| into |out_frames| with |rotate_degree|, cropping,
  // scaling, and format conversion. |rotate_degree| should be 0, 90, or 270.
  // When it returns 0, the |out_frames_status| will have the same size as
  // |out_frames| and record each output frame's conversion status.
  //
  // The |out_frames| don't need to be mapped before calling this function. They
  // will be mapped at a proper time for hardware and software access.
  int Convert(const android::CameraMetadata& static_metadata,
              const android::CameraMetadata& request_metadata,
              int rotate_degree,
              const FrameBuffer& in_frame,
              const std::vector<std::unique_ptr<FrameBuffer>>& out_frames,
              std::vector<int>* out_frame_status,
              std::vector<human_sensing::CrosFace>* faces);

 private:
  int ConvertFromNV12(const android::CameraMetadata& static_metadata,
                      const android::CameraMetadata& request_metadata,
                      const FrameBuffer& in_frame,
                      FrameBuffer* out_frame);

  int DecodeToNV12(const FrameBuffer& in_frame, FrameBuffer* out_frame);

  int DecodeByJDA(const FrameBuffer& in_frame, FrameBuffer* out_frame);

  int CompressNV12(const android::CameraMetadata& static_metadata,
                   const android::CameraMetadata& request_metadata,
                   const FrameBuffer& in_frame,
                   FrameBuffer* out_frame);

  // |faces| stores the detected results. It will be empty if error.
  void DetectFaces(const FrameBuffer& input_nv12_frame,
                   std::vector<human_sensing::CrosFace>* faces);

  // When we have a landscape mounted camera and the current camera activity is
  // portrait, the frames shown in the activity would be stretched. Therefore,
  // we want to simulate a native portrait camera. That's why we want to crop,
  // rotate |rotate_degree| clockwise and scale the frame. HAL would not change
  // CameraInfo.orientation. Instead, framework would fake the
  // CameraInfo.orientation. Framework would then tell HAL how much the frame
  // needs to rotate clockwise by |rotate_degree|.
  int CropRotateScale(int rotate_degree, FrameBuffer* frame);

  // Cached temporary buffers for the capture pipeline. We use SHM buffer for
  // I420 format since it can be resized, and Gralloc buffer for NV12 format
  // since it will be fed to HW JDA/JEA.
  std::unique_ptr<SharedFrameBuffer> temp_i420_frame_;
  std::unique_ptr<SharedFrameBuffer> temp_i420_frame2_;
  std::unique_ptr<GrallocFrameBuffer> temp_nv12_frame_;
  std::unique_ptr<GrallocFrameBuffer> temp_nv12_frame2_;

  // ImageProcessor instance.
  std::unique_ptr<ImageProcessor> image_processor_;

  // JPEG decoder accelerator (JDA) instance
  std::unique_ptr<JpegDecodeAccelerator> jda_;

  // JPEG compressor instance
  std::unique_ptr<JpegCompressor> jpeg_compressor_;

  // Metrics that used to record things like decoding latency.
  std::unique_ptr<CameraMetrics> camera_metrics_;

  // Indicate if JDA started successfully
  bool jda_available_;

  // max resolution used for JDA
  Size jda_resolution_cap_;

  // Flag to disable SW decode fallback when HW decode failed
  bool force_jpeg_hw_decode_;

  // Face detection handler.
  std::unique_ptr<FaceDetector> face_detector_;
  std::vector<human_sensing::CrosFace> faces_;
  int frame_count_;
  Size active_array_size_;
};

}  // namespace cros

#endif  // CAMERA_HAL_USB_CACHED_FRAME_H_