modules/camera/3_4/v4l2_wrapper.h

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
#define V4L2_CAMERA_HAL_V4L2_WRAPPER_H_

#include <array>
#include <memory>
#include <mutex>
#include <set>
#include <string>

#include <nativehelper/ScopedFd.h>

#include "common.h"
#include "stream.h"
#include "stream_format.h"
#include "v4l2_gralloc.h"

namespace v4l2_camera_hal {
class V4L2Wrapper {
 public:
  // Use this method to create V4L2Wrapper objects. Functionally equivalent
  // to "new V4L2Wrapper", except that it may return nullptr in case of failure.
  static V4L2Wrapper* NewV4L2Wrapper(const std::string device_path);
  virtual ~V4L2Wrapper();

  // Helper class to ensure all opened connections are closed.
  class Connection {
   public:
    Connection(std::shared_ptr<V4L2Wrapper> device)
        : device_(std::move(device)), connect_result_(device_->Connect()) {}
    ~Connection() { if (connect_result_ == 0) device_->Disconnect(); }
    // Check whether the connection succeeded or not.
    inline int status() const { return connect_result_; }

   private:
    std::shared_ptr<V4L2Wrapper> device_;
    const int connect_result_;
  };

  // Turn the stream on or off.
  int StreamOn();
  int StreamOff();
  // Manage controls.
  int QueryControl(uint32_t control_id, v4l2_query_ext_ctrl* result);
  int GetControl(uint32_t control_id, int32_t* value);
  int SetControl(uint32_t control_id, int32_t desired,
                 int32_t* result = nullptr);
  // Manage format.
  int GetFormats(std::set<uint32_t>* v4l2_formats);
  int GetFormatFrameSizes(uint32_t v4l2_format,
                          std::set<std::array<int32_t, 2>>* sizes);
  // Durations are returned in ns.
  int GetFormatFrameDurationRange(uint32_t v4l2_format,
                                  const std::array<int32_t, 2>& size,
                                  std::array<int64_t, 2>* duration_range);
  int SetFormat(const default_camera_hal::Stream& stream,
                uint32_t* result_max_buffers);
  // Manage buffers.
  int EnqueueBuffer(const camera3_stream_buffer_t* camera_buffer);
  int DequeueBuffer(v4l2_buffer* buffer);

 private:
  // Constructor is private to allow failing on bad input.
  // Use NewV4L2Wrapper instead.
  V4L2Wrapper(const std::string device_path,
              std::unique_ptr<V4L2Gralloc> gralloc);

  // Connect or disconnect to the device. Access by creating/destroying
  // a V4L2Wrapper::Connection object.
  int Connect();
  void Disconnect();
  // Perform an ioctl call in a thread-safe fashion.
  template <typename T>
  int IoctlLocked(int request, T data);
  // Adjust buffers any time a device is connected/reformatted.
  int SetupBuffers();

  inline bool connected() { return device_fd_.get() >= 0; }

  // The camera device path. For example, /dev/video0.
  const std::string device_path_;
  // The opened device fd.
  ScopedFd device_fd_;
  // The underlying gralloc module.
  std::unique_ptr<V4L2Gralloc> gralloc_;
  // Whether or not the device supports the extended control query.
  bool extended_query_supported_;
  // The format this device is set up for.
  std::unique_ptr<StreamFormat> format_;
  // The maximum number of buffers this device can handle in its current format.
  uint32_t max_buffers_;
  // Lock protecting use of the device.
  std::mutex device_lock_;
  // Lock protecting connecting/disconnecting the device.
  std::mutex connection_lock_;
  // Reference count connections.
  int connection_count_;

  friend class Connection;
  friend class V4L2WrapperMock;

  DISALLOW_COPY_AND_ASSIGN(V4L2Wrapper);
};

}  // namespace v4l2_camera_hal

#endif  // V4L2_CAMERA_HAL_V4L2_WRAPPER_H_