/*
 * Copyright (c) 2021 by Allwinnertech Co., Ltd.
 *
 * 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.
 */

#define LOG_TAG "CameraHALv3_V4L2Stream"
#include "v4l2_stream.h"

#include <android-base/unique_fd.h>
#include <cutils/properties.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <utils/Timers.h>

#include <algorithm>
#include <array>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <mutex>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "camera_config.h"
#include "linux/videodev2.h"
#include "stream_format.h"
#include "type_camera.h"
#include "v4l2_gralloc.h"
#include GPU_PUBLIC_INCLUDE

#define ISP_3A_PARAM_SIZE  81412
#define ISP_DEBUG_MSG_SIZE 20796
#define ISP_DEBUG_MAGIC_STR  "ISPDEBUG"

#if DBG_SAVE_OUTPUT
static int eb_yuv_count  = 0;
static int eb_jpeg_count = 0;
static int dq_yuv_count  = 0;
static int cb_yuv_count  = 0;
const  int output_counts = 10;
#endif


namespace v4l2_camera_hal {

V4L2Stream* V4L2Stream::NewV4L2Stream(
    const int id,
    const std::string device_path,
    std::shared_ptr<CCameraConfig> pCameraCfg,
    int merge_status
    ) {
  return new V4L2Stream(id, device_path, pCameraCfg, merge_status);
}

V4L2Stream::V4L2Stream(const int id, const std::string device_path,
                       std::shared_ptr<CCameraConfig> pCameraCfg,
                       int merge_status
                       )
    : mCameraConfig(pCameraCfg),
      device_path_(std::move(device_path)),
      device_fd_(-1),
      disconnect(false),
      device_id_(id),
      has_StreamOn(false),
      mflush_buffers(false),
      isTakePicture(false),
      buffer_state_(BUFFER_UNINIT),
#ifdef USE_ISP
      mAWIspApi(NULL),
      mIspId(-1),
#endif
      connection_count_(0) {
  HAL_LOG_ENTER();
  int pipefd[2];
  int ret = -1;
  if (merge_status) {
    if (device_path_.compare(MAIN_MERGE_STREAM_PATH) == 0) {
      device_ss_ = MAIN_STREAM;
    } else if (device_path_.compare(SUB_0_MERGE_STREAM_PATH) == 0) {
      device_ss_ = SUB_0_STREAM;
    }
  } else {
    if (device_path_.compare(MAIN_STREAM_PATH) == 0) {
      device_ss_ = MAIN_STREAM;
  } else if (device_path_.compare(SUB_0_STREAM_PATH) == 0) {
      device_ss_ = SUB_0_STREAM;
  } else if (device_path_.compare(MAIN_FRONT_STREAM_PATH) == 0) {
      device_ss_ = MAIN_STREAM;
  } else if (device_path_.compare(SUB_0_FRONT_STREAM_PATH) == 0) {
      device_ss_ = SUB_0_STREAM;
    }
  }

  memset(&jpeg_crop_rect, 0, sizeof(cam_crop_rect_t));
  reduce_call_num = 0;
  reducecallnum_dst_width = 0;
  reducecallnum_dst_height = 0;
  reducecallnum_src_width = 0;
  reducecallnum_src_height = 0;
  ret = pipe(pipefd);
  if (ret == -1) {
      ALOGE("V4L2Stream create pipe failed");
  } else {
      read_fd_ = pipefd[0];
      write_fd_ = pipefd[1];
  }
  pEvents = (epoll_event *)calloc(2, sizeof(epoll_event));
}

V4L2Stream::~V4L2Stream() {
  HAL_LOG_ENTER();
  std::unique_lock<std::mutex> lock(buffer_queue_lock_);
  HAL_LOGV("%s, device_ss_:%d.", device_path_.c_str(), device_ss_);
  close(read_fd_);
  close(write_fd_);
}

int V4L2Stream::Connect(int merge_status) {
  HAL_LOG_ENTER();
  std::lock_guard<std::mutex> lock(connection_lock_);

  if (connected()) {
    HAL_LOGV("Camera stream %s is already connected.", device_path_.c_str());
    ++connection_count_;
    return 0;
  }
  HAL_LOGD("Camera stream will link to %s.", device_path_.c_str());
  int try_num = 5;
  int fd = -1;
  while (try_num--) {
    HAL_LOGD("try to link %s, the %d time.", device_path_.c_str(), 5 -try_num);
    // Open in nonblocking mode (DQBUF may return EAGAIN).
    fd = TEMP_FAILURE_RETRY(open(device_path_.c_str(), O_RDWR | O_NONBLOCK, 0));
    if (fd < 0) {
      HAL_LOGE("failed to open %s (%s)", device_path_.c_str(), strerror(errno));
      usleep(200*1000);
      continue;
    }
    break;
  }
  if (fd < 0) {
    HAL_LOGE("failed to open %s (%s)", device_path_.c_str(), strerror(errno));
    return -ENODEV;
  }

  device_fd_ = fd;
  ++connection_count_;

  struct dma_merge picture_merge;
  HAL_LOGE("bill merge_status = %d", merge_status);
  if(device_id_ == 0 && merge_status) {
      picture_merge.en = 1;
  } else if(device_id_ == 0 && !merge_status) {
      picture_merge.en = 2;
  } else {
      picture_merge.en = 0;
  }

  HAL_LOGD("device_id_:%d picture_merge.en:%d", device_id_, picture_merge.en);

  if (TEMP_FAILURE_RETRY(
        ioctl(fd, VIDIOC_SET_DMA_MERGE, &picture_merge)) != 0) {
     HAL_LOGE("VIDIOC_SET_DMA_MERGE on %d error: %s.",
         picture_merge.en,
         strerror(errno));
  }

  HAL_LOGV("Detect camera stream %s, stream serial:%d.",
      device_path_.c_str(), device_ss_);

  struct v4l2_input inp;
  inp.index = getSupportCameraId(device_id_);
  HAL_LOGV("%s ioctl %s", __func__, getV4l2IoctlString(VIDIOC_S_INPUT).c_str());
  if (TEMP_FAILURE_RETRY(ioctl(fd, VIDIOC_S_INPUT, &inp)) != 0) {
    HAL_LOGE("VIDIOC_S_INPUT on %d error: %s.", inp.index, strerror(errno));
  }

#ifdef USE_ISP
  mAWIspApi = new android::AWIspApi();
#endif
  return 0;
}

void V4L2Stream::Disconnect() {
  HAL_LOG_ENTER();
  std::lock_guard<std::mutex> lock(connection_lock_);

  if (connection_count_ == 0) {
    // Not connected.
    HAL_LOGE("Camera device %s is not connected, cannot disconnect.",
        device_path_.c_str());
    return;
  }

  --connection_count_;
  if (connection_count_ > 0) {
    HAL_LOGV("Disconnected from camera device %s. connections remain.",
        device_path_.c_str());
    return;
  }
  // wake up epoll
  disconnect = true;
  write(write_fd_, "w", 2);
  int res = TEMP_FAILURE_RETRY(close(device_fd_));
  HAL_LOGD("Close device path:%s, fd:%d, res: %s",
      device_path_.c_str(), device_fd_, strerror(res));
  if (res) {
    HAL_LOGW("Disconnected from camera device %s. fd:%d encount err(%s).",
        device_path_.c_str(), device_fd_, strerror(res));
  }
  // Delay for open after close success encount open device busy.
  // TODO(zjw): optimize this, keep node open until close the camera hal.
  // usleep(200*1000);

#ifdef USE_ISP
  if (mAWIspApi != NULL) {
    delete mAWIspApi;
    mAWIspApi = NULL;
  }
#endif

  device_fd_ = -1;
  format_.reset();
  buffers_.clear();
  // Closing the device releases all queued buffers back to the user.
}

// Helper function. Should be used instead of ioctl throughout this class.
template <typename T>
int V4L2Stream::IoctlLocked(int request, T data) {
  // Potentially called so many times logging entry is a bad idea.
  std::lock_guard<std::mutex> lock(device_lock_);
  if (!connected()) {
    HAL_LOGE("Stream %s not connected.", device_path_.c_str());
    return -ENODEV;
  }
  HAL_LOGV("Stream fd:%d.. request:%s",
      device_fd_, getV4l2IoctlString((request)).c_str());
  return TEMP_FAILURE_RETRY(ioctl(device_fd_, request, data));
}

int V4L2Stream::StreamOn() {
  HAL_LOG_ENTER();

  if (!format_) {
    HAL_LOGE("Stream format must be set before turning on stream.");
    return -EINVAL;
  }

  if (has_StreamOn) {
    HAL_LOGV("Stream had been turned on.");
    return 0;
  }
#if DELAY_BETWEEN_ON_OFF
  mTimeStampsFstreamon = systemTime() / 1000000;
#endif
  int mDevice_id = getSupportCameraId(device_id_);
  HAL_LOGD("id:%d mDevice_id:%d\n", device_id_, mDevice_id);
  if (device_id_ == 0 && device_id_ != mDevice_id) {
    struct v4l2_control ctrl;
    ctrl.id = V4L2_CID_VFLIP;
    ctrl.value = 1;
    HAL_LOGV("ioctl %s", getV4l2IoctlString(VIDIOC_S_CTRL).c_str());
    if (TEMP_FAILURE_RETRY(ioctl(device_fd_, VIDIOC_S_CTRL, &ctrl)) != 0) {
      HAL_LOGE("VIDIOC_S_CTRL  error: %s. value:%d", strerror(errno),
                                                      ctrl.value);
    }
  }

  int32_t type = format_->type();
  if (IoctlLocked(VIDIOC_STREAMON, &type) < 0) {
    HAL_LOGE("STREAMON fails: %s", strerror(errno));
    return -ENODEV;
  } else {
    buffer_state_ = BUFFER_UNINIT;
    has_StreamOn = true;
  }
#if DELAY_BETWEEN_ON_OFF
  HAL_LOGV("Stream turned on.");
  usleep(100*1000);
  HAL_LOGV("Stream after turned on sleep for stream on prepare.");
#endif

#ifdef USE_ISP
  mIspId = 0;
  if (getSingleCameraId() < 0) {
    mIspId = mAWIspApi->awIspGetIspId(mDevice_id);
  }
  //if (mIspId >= 0) {
  //  mAWIspApi->awIspStart(mIspId);
  //  HAL_LOGD("ISP turned on.");
  //} else {
  //  HAL_LOGE("ISP turned on failed!");
  //}

  if(device_id_ == 0 &&
      device_path_.compare(MAIN_MERGE_STREAM_PATH) == 0) {
      mDevice_id = 0;
      mIspId = mAWIspApi->awIspGetIspId(mDevice_id);
      if (mIspId >= 0) {
          mAWIspApi->awIspStart(mIspId);
          HAL_LOGD("ISP turned on. mDevice_id = %d", mDevice_id);
      } else {
          HAL_LOGE("ISP turned on failed!");
      }

  } else if(device_id_ == 0 &&
      device_path_.compare(SUB_0_MERGE_STREAM_PATH) == 0) {
      mDevice_id = 1;
      mIspId = mAWIspApi->awIspGetIspId(mDevice_id);
      if (mIspId >= 0) {
          mAWIspApi->awIspStart(mIspId);
          HAL_LOGD("ISP turned on. mDevice_id = %d", mDevice_id);
      } else {
          HAL_LOGE("ISP turned on failed!");
      }

  } else if(device_id_ == 1 && format_->GetMergeStreamFlag()) {
      mDevice_id = 0;
      mIspId = mAWIspApi->awIspGetIspId(mDevice_id);
      if (mIspId >= 0) {
          mAWIspApi->awIspStart(mIspId);
          HAL_LOGD("ISP turned on. mDevice_id = %d", mDevice_id);
      } else {
          HAL_LOGE("ISP turned on failed!");
      }

  } else {
      mIspId = mAWIspApi->awIspGetIspId(mDevice_id);
      if (mIspId >= 0) {
          mAWIspApi->awIspStart(mIspId);
          HAL_LOGD("ISP turned on. mDevice_id = %d", mDevice_id);
      } else {
          HAL_LOGE("ISP turned on failed!");
      }
   }

#endif

  return 0;
}

int V4L2Stream::StreamOff() {
  HAL_LOG_ENTER();

  if (!format_) {
    // Can't have turned on the stream without format being set,
    // so nothing to turn off here.
    return 0;
  }
#if DELAY_BETWEEN_ON_OFF
  // TODO(zjw): Remove it.
  // Delay between vin stream on and off time that less than
  // DELAY_BETWEEN_STREAM for resource release completely.
  unsigned long  mDeltaStream = systemTime() / 1000000 - mTimeStampsFstreamon;
  HAL_LOGD("mDeltaStream:%ld, mTimeStampsFstreamon:%ld,"
      " systemTime() / 1000000:%ld.",
      mDeltaStream, mTimeStampsFstreamon,
      systemTime() / 1000000);
  if (mDeltaStream < DELAY_BETWEEN_STREAM) {
    HAL_LOGD("mDeltaStream:%ld.", mDeltaStream);
    usleep((DELAY_BETWEEN_STREAM -mDeltaStream)*1000);
  }
#endif
  int32_t type = format_->type();
  int res = IoctlLocked(VIDIOC_STREAMOFF, &type);
  if (res) {
    HAL_LOGW("Stream turned off failed, err(%s).", strerror(res));
  }
  if (res < 0) {
    HAL_LOGE("STREAMOFF fails: %s", strerror(errno));
  }
  HAL_LOGD("After stream %d, ind:%d turned off.", device_id_, device_fd_);
#ifdef USE_ISP
  mAWIspApi->awIspStop(mIspId);
  HAL_LOGV("Stream %d, ind:%d awIspStop.", device_id_, device_fd_);
#endif

  // Calling STREAMOFF releases all queued buffers back to the user.
  // int gralloc_res = gralloc_->unlockAllBuffers();
  // No buffers in flight.
  for (size_t i = 0; i < buffers_.size(); ++i) {
    buffers_[i] = false;
  }
  // munmap buffer.
  for (size_t i = 0; i < buffers_.size(); i++) {
    HAL_LOGV("munmap index:%zu!", i);
    res = munmap(mMapMem.mem[i], mMapMem.length);
    if (res < 0) {
      HAL_LOGE("munmap failed");
    }
    mMapMem.mem[i] = NULL;
  }
  has_StreamOn = false;
  HAL_LOGV("Stream %d, ind:%d turned off.", device_id_, device_fd_);
  return 0;
}

int V4L2Stream::flush() {
  HAL_LOG_ENTER();
  mflush_buffers = true;
  buffer_availabl_queue_.notify_one();
  HAL_LOGV("Stream %d, ss:%d, ind:%d flush.",
      device_id_, device_ss_, device_fd_);
  return 0;
}

int V4L2Stream::QueryControl(uint32_t control_id,
                             v4l2_query_ext_ctrl* result) {
  int res;
  memset(result, 0, sizeof(*result));
  if (extended_query_supported_) {
    result->id = control_id;
    res = IoctlLocked(VIDIOC_QUERY_EXT_CTRL, result);
    // Assuming the operation was supported (not ENOTTY), no more to do.
    if (errno != ENOTTY) {
      if (res) {
        HAL_LOGE("QUERY_EXT_CTRL fails: %s", strerror(errno));
        return -ENODEV;
      }
      return 0;
    }
  }

  // Extended control querying not supported, fall back to basic control query.
  v4l2_queryctrl query;
  query.id = control_id;
  if (IoctlLocked(VIDIOC_QUERYCTRL, &query)) {
    HAL_LOGE("QUERYCTRL fails: %s", strerror(errno));
    return -ENODEV;
  }

  // Convert the basic result to the extended result.
  result->id = query.id;
  result->type = query.type;
  memcpy(result->name, query.name, sizeof(query.name));
  result->minimum = query.minimum;
  if (query.type == V4L2_CTRL_TYPE_BITMASK) {
    // According to the V4L2 documentation, when type is BITMASK,
    // max and default should be interpreted as __u32. Practically,
    // this means the conversion from 32 bit to 64 will pad with 0s not 1s.
    result->maximum = static_cast<uint32_t>(query.maximum);
    result->default_value = static_cast<uint32_t>(query.default_value);
  } else {
    result->maximum = query.maximum;
    result->default_value = query.default_value;
  }
  result->step = static_cast<uint32_t>(query.step);
  result->flags = query.flags;
  result->elems = 1;
  switch (result->type) {
    case V4L2_CTRL_TYPE_INTEGER64:
      result->elem_size = sizeof(int64_t);
      break;
    case V4L2_CTRL_TYPE_STRING:
      result->elem_size = result->maximum + 1;
      break;
    default:
      result->elem_size = sizeof(int32_t);
      break;
  }

  return 0;
}

int V4L2Stream::GetControl(uint32_t control_id, int32_t* value) {
  // For extended controls (any control class other than "user"),
  // G_EXT_CTRL must be used instead of G_CTRL.
  if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
    v4l2_ext_control control;
    v4l2_ext_controls controls;
    memset(&control, 0, sizeof(control));
    memset(&controls, 0, sizeof(controls));

    control.id = control_id;
    controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
    controls.count = 1;
    controls.controls = &control;

    if (IoctlLocked(VIDIOC_G_EXT_CTRLS, &controls) < 0) {
      HAL_LOGE("G_EXT_CTRLS fails: %s", strerror(errno));
      return -ENODEV;
    }
    *value = control.value;
  } else {
    v4l2_control control{control_id, 0};
    if (IoctlLocked(VIDIOC_G_CTRL, &control) < 0) {
      HAL_LOGE("G_CTRL fails: %s", strerror(errno));
      return -ENODEV;
    }
    *value = control.value;
  }
  return 0;
}

int V4L2Stream::SetTakePictureCtrl(enum v4l2_take_picture value) {
  struct v4l2_control ctrl;
  int ret = -1;
  HAL_LOGV("%s value = %d", __func__, value);
  ctrl.id = V4L2_CID_TAKE_PICTURE;
  ctrl.value = value;
  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  if (ret < 0) {
    HAL_LOGE("failed, %s", strerror(errno));
  } else {
    HAL_LOGV(" ok");
  }

  return ret;
}

int V4L2Stream::SetFlashMode(uint32_t mode) {
  int ret = -1;
  struct v4l2_control ctrl;

  ctrl.id = V4L2_CID_FLASH_LED_MODE;
  ctrl.value = mode;
  HAL_LOGV("%s mode = %d", __func__, mode);

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("%s failed, %s", __func__, strerror(errno));
  } else {
    HAL_LOGV("%s ok, %s", __func__, strerror(errno));
  }

  return ret;
}

int V4L2Stream::SetAutoFocusInit() {
  int ret = -1;
  struct v4l2_control ctrl;
  ctrl.id = V4L2_CID_AUTO_FOCUS_INIT;
  ctrl.value = 0;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("%s failed, %s", __func__, strerror(errno));
  } else {
    HAL_LOGV("%s ok, %s", __func__, strerror(errno));
  }

  return ret;
}

int V4L2Stream::SetAutoFocusRange(int af_range) {
  int ret = -1;
  struct v4l2_control ctrl;

  ctrl.id = V4L2_CID_FOCUS_AUTO;
  ctrl.value = 1;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("id V4L2_CID_FOCUS_AUTO failed, %s", strerror(errno));
  } else {
    HAL_LOGV("id V4L2_CID_FOCUS_AUTO ok, %s", strerror(errno));
  }

  ctrl.id = V4L2_CID_AUTO_FOCUS_RANGE;
  ctrl.value = af_range;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("id V4L2_CID_AUTO_FOCUS_RANGE failed, %s", strerror(errno));
  } else {
    HAL_LOGV("id V4L2_CID_AUTO_FOCUS_RANGE ok, %s", strerror(errno));
  }

  return ret;
}

int V4L2Stream::SetAutoFocusStart() {
  int ret = -1;
  struct v4l2_control ctrl;

  ctrl.id = V4L2_CID_AUTO_FOCUS_START;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("failed, %s", strerror(errno));
  } else {
    HAL_LOGV("ok, %s", strerror(errno));
  }
  return ret;
}

int V4L2Stream::SetAutoFocusStop() {
  int ret = -1;
  struct v4l2_control ctrl;

  ctrl.id = V4L2_CID_AUTO_FOCUS_STOP;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("failed, %s", strerror(errno));
  } else {
    HAL_LOGV("ok, %s", strerror(errno));
  }

  return ret;
}

int V4L2Stream::Set3ALock(int lock) {
  int ret = -1;
  struct v4l2_control ctrl;

  ctrl.id = V4L2_CID_3A_LOCK;
  ctrl.value = lock;

  ret = IoctlLocked(VIDIOC_S_CTRL, &ctrl);
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);
  if (ret < 0) {
    HAL_LOGE("failed, %s", strerror(errno));
  } else {
    HAL_LOGV("ok, %s", strerror(errno));
  }

  return ret;
}

int V4L2Stream::GetAutoFocusStatus() {
  int ret = -1;

  if (device_fd_ < 0) {
    return 0xFF000000;
  }

  ret = mAWIspApi->awGetFocusStatus();
  HAL_LOGD("ret:%d device_fd_:%d", ret, device_fd_);

  return ret;
}

int V4L2Stream::SetAutoFocusRegions(cam_rect_t cam_regions) {
  int ret = -1;
  ret = mAWIspApi->awSetFocusRegions(cam_regions.x_min,
                                     cam_regions.y_min,
                                     cam_regions.x_max,
                                     cam_regions.y_max);

  HAL_LOGD("ret:%d device_fd_:%d,x1:%d y1:%d x2:%d y2:%d",
      ret,
      device_fd_,
      cam_regions.x_min,
      cam_regions.y_min,
      cam_regions.x_max,
      cam_regions.y_max);

  return ret;
}


int V4L2Stream::SetJpegCropRect(cam_crop_rect_t cam_crop_rect) {
  jpeg_crop_rect.left   = cam_crop_rect.left;
  jpeg_crop_rect.top    = cam_crop_rect.top;
  jpeg_crop_rect.width  = cam_crop_rect.width;
  jpeg_crop_rect.height = cam_crop_rect.height;
  return 0;
}

int V4L2Stream::SetCropRect(cam_crop_rect_t cam_crop_rect) {
  int ret = -1;
  struct v4l2_selection s;

  s.target = V4L2_SEL_TGT_CROP;
  s.r.left = cam_crop_rect.left;
  s.r.top = cam_crop_rect.top;
  s.r.width = cam_crop_rect.width;
  s.r.height = cam_crop_rect.height;

  if (mCameraConfig->supportReducecallnumSize()) {
      HAL_LOGV("####SetCropRect supportReducecallnumSize!~");
  }else {
      ret = IoctlLocked(VIDIOC_S_SELECTION, &s);
      HAL_LOGV("ret:%d device_fd_:%d left:%d top:%d width:%d height:%d",
          ret, device_fd_, s.r.left, s.r.top, s.r.width, s.r.height);
      if (ret < 0) {
          HAL_LOGE("failed, %s", strerror(errno));
      } else {
          HAL_LOGV("ok, %s", strerror(errno));
      }
  }
  return ret;
}

int V4L2Stream::SetControl(uint32_t control_id,
                           int32_t desired,
                           int32_t* result) {
  int32_t result_value = 0;

  // TODO(b/29334616): When async, this may need to check if the stream
  // is on, and if so, lock it off while setting format. Need to look
  // into if V4L2 supports adjusting controls while the stream is on.

  // For extended controls (any control class other than "user"),
  // S_EXT_CTRL must be used instead of S_CTRL.
  if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
    v4l2_ext_control control;
    v4l2_ext_controls controls;
    memset(&control, 0, sizeof(control));
    memset(&controls, 0, sizeof(controls));

    control.id = control_id;
    control.value = desired;
    controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
    controls.count = 1;
    controls.controls = &control;

    if (IoctlLocked(VIDIOC_S_EXT_CTRLS, &controls) < 0) {
      HAL_LOGE("S_EXT_CTRLS fails: %s", strerror(errno));
      return -ENODEV;
    }
    result_value = control.value;
  } else {
    v4l2_control control{control_id, desired};
    if (IoctlLocked(VIDIOC_S_CTRL, &control) < 0) {
      HAL_LOGE("S_CTRL fails: %s", strerror(errno));
      return -ENODEV;
    }
    result_value = control.value;
  }

  // If the caller wants to know the result, pass it back.
  if (result != nullptr) {
    *result = result_value;
  }
  return 0;
}

int V4L2Stream::SetParm(int mCapturemode, uint32_t width, uint32_t height) {
  HAL_LOG_ENTER();

  struct v4l2_streamparm params;
  memset(&params, 0, sizeof(params));

  params.parm.capture.timeperframe.numerator = 1;
  

  params.parm.capture.reserved[0] = 0;
  params.type = V4L2_CAPTURE_TYPE;
  params.parm.capture.capturemode = mCapturemode;

  if (width * height > 2112*1568) {
    HAL_LOGV("SetParm %dx%d",width,height);
    params.parm.capture.timeperframe.denominator = 25;
  } else {
    params.parm.capture.timeperframe.denominator = 30;
  }
  if (width * height > 4000*3000) {
    params.parm.capture.timeperframe.denominator = 24;
    params.parm.capture.reserved[2] = 3;
  } else {
    if (device_id_ == 0 &&
        device_path_.compare(SUB_0_MERGE_STREAM_PATH) == 0) {
      params.parm.capture.timeperframe.denominator = 24;
      params.parm.capture.reserved[2] = 3;
    } else {
      params.parm.capture.reserved[2] = 0;
    }
  }
  HAL_LOGI("params.parm.capture.timeperframe.denominator:%d reserved:%d",
      params.parm.capture.timeperframe.denominator, params.parm.capture.reserved[2]);

  if (IoctlLocked(VIDIOC_S_PARM, &params) < 0) {
    HAL_LOGE("S_PARM fails: %s", strerror(errno));
    return -ENODEV;
  }

  return 0;
}

int V4L2Stream::GetFormats(std::set<uint32_t>* v4l2_formats) {
  HAL_LOG_ENTER();

  int format_temp = V4L2_PIX_FMT_NV12;
  v4l2_formats->insert(format_temp);

  format_temp = V4L2_PIX_FMT_YUV420;
  v4l2_formats->insert(format_temp);

  format_temp = V4L2_PIX_FMT_NV21;
  v4l2_formats->insert(format_temp);

  // Add the jpeg format for take picture.
  format_temp = V4L2_PIX_FMT_JPEG;
  v4l2_formats->insert(format_temp);

  return 0;
}

int V4L2Stream::GetFormatFrameSizes(
    uint32_t v4l2_format,
    std::set<std::array<int32_t, 2>,
    std::greater<std::array<int32_t, 2>>>* sizes) {
  v4l2_frmsizeenum size_query;
  memset(&size_query, 0, sizeof(size_query));

  // Add the jpeg format for take picture.
  if (v4l2_format == V4L2_PIX_FMT_JPEG) {
    v4l2_format = V4L2_PIX_FMT_DEFAULT;
  }

  size_query.pixel_format = v4l2_format;

  char * value;
  value = mCameraConfig->supportPictureSizeValue();

  std::string st1 = value;
  int size_width = 0;
  int size_height = 0;
  std::string tmp;
  std::vector<std::string> data;
  std::stringstream input(st1);

  while (getline(input, tmp, ',')) {
    data.push_back(tmp);
  }
  for (auto s : data) {
    sscanf(s.c_str(), "%dx%d", &size_width, &size_height);
    sizes->insert({{{size_width, size_height}}});
  }

  return 0;
}

// Converts a v4l2_fract with units of seconds to an int64_t with units of ns.
inline int64_t FractToNs(const v4l2_fract& fract) {
  return (1000000000LL * fract.numerator) / fract.denominator;
}

int V4L2Stream::GetFormatFrameDurationRange(
    uint32_t v4l2_format,
    const std::array<int32_t, 2>& size,
    std::array<int64_t, 2>* duration_range) {
  // Potentially called so many times logging entry is a bad idea.

  v4l2_frmivalenum duration_query;
  memset(&duration_query, 0, sizeof(duration_query));

  // Add the jpeg format for take picture.
  if (v4l2_format == V4L2_PIX_FMT_JPEG) {
    v4l2_format = V4L2_PIX_FMT_DEFAULT;
  }

  duration_query.pixel_format = v4l2_format;
  duration_query.width = size[0];
  duration_query.height = size[1];

  if (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) < 0) {
    HAL_LOGE("ENUM_FRAMEINTERVALS failed: %s", strerror(errno));
  }

  int64_t min = std::numeric_limits<int64_t>::max();
  int64_t max = std::numeric_limits<int64_t>::min();
  min = 33300000;
  max = 100000000;
  (*duration_range)[0] = min;
  (*duration_range)[1] = max;
  return 0;
}

int V4L2Stream::parse_pair(const char *str,
                           uint32_t *first,
                           uint32_t *second,
                           char delim) {
  // Find the first integer.
  char *end;
  uint32_t w = static_cast<int>(strtol(str, &end, 10));
  // If a delimeter does not immediately follow, give up.
  if (*end != delim) {
    HAL_LOGE("Cannot find delimeter (%c) in str=%s", delim, str);
    return -1;
  }
  // Find the second integer, immediately after the delimeter.
  uint32_t h = static_cast<int>(strtol(end+1, &end, 10));
  *first = w;
  *second = h;

  return 0;
}

int V4L2Stream::SetFormat(const StreamFormat& desired_format,
                          uint32_t* result_max_buffers,
                          bool merge_stream_flag) {
  HAL_LOG_ENTER();

  if (format_ && desired_format == *format_) {
    HAL_LOGV("The desired format is as same as the format set last.");
    return 0;
  }

  // Not in the correct format, set the new one.
  if (format_) {
    // If we had an old format, first request 0 buffers to inform the device
    // we're no longer using any previously "allocated" buffers from the old
    // format. This seems like it shouldn't be necessary for USERPTR memory,
    // and/or should happen from turning the stream off, but the driver
    // complained. May be a driver issue, or may be intended behavior.
    int res = RequestBuffers(0);
    if (res) {
      return res;
    }
  }

  // Set the camera to the new format.
  v4l2_format new_format;
  desired_format.FillFormatRequest(&new_format);

  HAL_LOGD("%s type=%d pixelformat=%d(%s) width=%d height=%d",
      __func__,
      new_format.type,
      new_format.fmt.pix_mp.pixelformat,
      getV4l2PixelFormatString(new_format.fmt.pix_mp.pixelformat).c_str(),
      new_format.fmt.pix_mp.width,
      new_format.fmt.pix_mp.height);

  int setFormatFlag = 0;
  int cur_width = 0;
  int cur_height = 0;
  if (mCameraConfig->supportInterpolationSize()) {
    uint32_t interpolation_dst_width  = 0;
    uint32_t interpolation_dst_height = 0;
    uint32_t interpolation_src_width  = 0;
    uint32_t interpolation_src_height = 0;
    char * value;
    char * value1;
    value = mCameraConfig->supportInterpolationSizeValue();
    parse_pair(value, &interpolation_src_width, &interpolation_src_height, 'x');
    value1 = mCameraConfig->defaultInterpolationSizeValue();
    parse_pair(value1,
        &interpolation_dst_width, &interpolation_dst_height, 'x');

    if (interpolation_dst_width == new_format.fmt.pix_mp.width &&
        interpolation_dst_height == new_format.fmt.pix_mp.height) {
      cur_width = new_format.fmt.pix_mp.width;
      cur_height = new_format.fmt.pix_mp.height;
      new_format.fmt.pix_mp.width = interpolation_src_width;
      new_format.fmt.pix_mp.height = interpolation_src_height;
      setFormatFlag = 1;
      }

  }

  if(mCameraConfig->supportReducecallnumSize())
  {
      char * value;
      value = mCameraConfig->supportReducecallnumSizeValue();
      parse_pair(value, &reducecallnum_src_width, &reducecallnum_src_height, 'x');

      char *reduce_call_num_char;
      reduce_call_num_char = mCameraConfig->ReduceCallNumValue();
      reduce_call_num = atoi(reduce_call_num_char);

      new_format.fmt.pix_mp.width = reducecallnum_src_width;
      new_format.fmt.pix_mp.height = reducecallnum_src_height;

      struct buf_merge buf_merge;
      buf_merge.en = 1;
      buf_merge.buffer_num = reduce_call_num;

      if (IoctlLocked(VIDIOC_SET_BUFFER_MERGE, &buf_merge) < 0) {
          HAL_LOGE("VIDIOC_SET_BUFFER_MERGE failed: %s", strerror(errno));
          return -ENODEV;
      }
  }

  // TODO(b/29334616): When async, this will need to check if the stream
  // is on, and if so, lock it off while setting format.
  if (IoctlLocked(VIDIOC_S_FMT, &new_format) < 0) {
    HAL_LOGE("S_FMT failed: %s", strerror(errno));
    return -ENODEV;
  }

  if (IoctlLocked(VIDIOC_G_FMT, &new_format) < 0) {
    HAL_LOGE("G_FMT failed: %s", strerror(errno));
    return -ENODEV;
  }

  if(mCameraConfig->supportReducecallnumSize())
  {
      char * value1;
      value1 = mCameraConfig->defaultReducecallnumSizeValue();
      parse_pair(value1, &reducecallnum_dst_width, &reducecallnum_dst_height, 'x');

      new_format.fmt.pix_mp.width = reducecallnum_dst_width;
      new_format.fmt.pix_mp.height = reducecallnum_dst_height;
  }

  // Check that the driver actually set to the requested values.
  if (desired_format != StreamFormat(new_format, merge_stream_flag)) {
    HAL_LOGE("Device doesn't support desired stream configuration.");
  }

  if (setFormatFlag && cur_width != 0 && cur_height != 0) {
    new_format.fmt.pix_mp.width = cur_width;
    new_format.fmt.pix_mp.height = cur_height;
  }
  // Keep track of our new format.
  format_.reset(new StreamFormat(new_format, merge_stream_flag));

  // Format changed, request new buffers.
  int res = RequestBuffers(*result_max_buffers);
  if (res) {
    HAL_LOGE("Requesting buffers for new format failed.");
    return res;
  }
  *result_max_buffers = buffers_.size();
  HAL_LOGV("*result_max_buffers:%d.", *result_max_buffers);
  return 0;
}

int V4L2Stream::RequestBuffers(uint32_t num_requested) {
  v4l2_requestbuffers req_buffers;
  memset(&req_buffers, 0, sizeof(req_buffers));
  req_buffers.type = format_->type();
  req_buffers.memory = format_->memory();
  req_buffers.count = num_requested;

  int res = IoctlLocked(VIDIOC_REQBUFS, &req_buffers);
  // Calling REQBUFS releases all queued buffers back to the user.
  // int gralloc_res = gralloc_->unlockAllBuffers();
  if (res < 0) {
    HAL_LOGE("REQBUFS failed: %s", strerror(errno));
    return -ENODEV;
  }

  // V4L2 will set req_buffers.count to a number of buffers it can handle.
  if (num_requested > 0 && req_buffers.count < 1) {
    HAL_LOGE("REQBUFS claims it can't handle any buffers.");
    return -ENODEV;
  }

  {
    std::lock_guard<std::mutex> guard(cmd_queue_lock_);
    buffer_cnt_inflight_ = 0;
  }

  // refresh buffers_num_ queue.
  while (!buffers_num_.empty()) {
    buffers_num_.pop();
  }

  if (buffers_num_.empty()) {
    for (size_t i = 0; i < req_buffers.count; ++i) {
      buffers_num_.push(i);
      HAL_LOGV("buffers_num_ push:%zu, size:%zu.", i, buffers_num_.size());
    }
  }

  buffers_.resize(req_buffers.count, false);
  HAL_LOGD("num_requested:%d,req_buffers.count:%d.",
      num_requested, req_buffers.count);
  return 0;
}

int V4L2Stream::queueBuffer(v4l2_buffer* pdevice_buffer) {
  int res;
  std::lock_guard<std::mutex> guard(cmd_queue_lock_);
  res = IoctlLocked(VIDIOC_QBUF, pdevice_buffer);
  if (res >= 0) {
    buffer_cnt_inflight_++;
    HAL_LOGV("After queue buffer csi driver has %d buffer(s) now.",
        buffer_cnt_inflight_);
  }
  return res;
}

int V4L2Stream::dequeueBuffer(v4l2_buffer* pdevice_buffer) {
  int res;
  std::lock_guard<std::mutex> guard(cmd_queue_lock_);
  res = IoctlLocked(VIDIOC_DQBUF, pdevice_buffer);
  if (res >= 0) {
    buffer_cnt_inflight_--;
    HAL_LOGV("After dequeue buffer csi driver has %d buffer(s) now.",
        buffer_cnt_inflight_);
  }
  return res;
}

int V4L2Stream::PrepareBuffer() {
  if (!format_) {
    HAL_LOGE("Stream format must be set before enqueuing buffers.");
    return -ENODEV;
  }

  struct v4l2_buffer device_buffer;
  int index = -1;

  for (size_t i = 0; i < buffers_.size(); i++) {
    std::lock_guard<std::mutex> guard(buffer_queue_lock_);
    index = buffers_num_.front();
    buffers_num_.pop();
    HAL_LOGV("buffers_num_ pop:%d, size:%zu.", index, buffers_num_.size());

    // Set up a v4l2 buffer struct.
    memset(&device_buffer, 0, sizeof(device_buffer));
    device_buffer.type = format_->type();
    device_buffer.index = index;
    device_buffer.memory = format_->memory();
    device_buffer.length = format_->nplanes();
    struct v4l2_plane planes[VIDEO_MAX_PLANES];
    // TODO(zjw) support mutiplanar.
    memset(planes, 0, VIDEO_MAX_PLANES * sizeof(struct v4l2_plane));
    if (V4L2_CAPTURE_TYPE == device_buffer.type) {
      device_buffer.m.planes = planes;
      if (NULL == device_buffer.m.planes) {
        HAL_LOGE("device_buffer.m.planes calloc failed!\n");
      }
    }

    // Use QUERYBUF to ensure our buffer/device is in good shape,
    // and fill out remaining fields.
    if (IoctlLocked(VIDIOC_QUERYBUF, &device_buffer) < 0) {
      HAL_LOGE("QUERYBUF fails: %s", strerror(errno));
      return -ENODEV;
    }

    mMapMem.mem[i] = mmap(0,
                          device_buffer.m.planes[0].length,
                          PROT_READ | PROT_WRITE,
                          MAP_SHARED,
                          device_fd_,
                          device_buffer.m.planes[0].m.mem_offset);
    mMapMem.length = device_buffer.m.planes[0].length;
    if (mMapMem.mem[i] == MAP_FAILED) {
      HAL_LOGE("Unable to map buffer (%s)", strerror(errno));
      for (size_t j = 0; j < i; j++) {
        munmap(buffers_addr[i], mMapMem.length);
      }
      return -1;
    }
    HAL_LOGD("index: %zu, fd: %d, mem: %lx, len: %d, offset: 0x%x",
        i,
        device_fd_,
        (unsigned long)mMapMem.mem[i],
        device_buffer.m.planes[0].
        length,
        device_buffer.m.offset);

    if (queueBuffer(&device_buffer) < 0) {
      HAL_LOGE("QBUF fails: %s", strerror(errno));
      return -ENODEV;
    }

    if (mCameraConfig->supportInterpolationSize()) {
      uint32_t interpolation_dst_width = 0;
      uint32_t interpolation_dst_height = 0;
      uint32_t interpolation_src_width = 0;
      uint32_t interpolation_src_height = 0;
      char * value;
      char * value1;
      value = mCameraConfig->supportInterpolationSizeValue();
      parse_pair(value,
          &interpolation_src_width, &interpolation_src_height, 'x');
      value1 = mCameraConfig->defaultInterpolationSizeValue();
      parse_pair(value1,
          &interpolation_dst_width, &interpolation_dst_height, 'x');
      if (interpolation_dst_width == format_->width() &&
          interpolation_dst_height == format_->height()) {
        memset(reinterpret_cast<void*>(mMapMem.mem[i]),
               0x10,
               interpolation_src_width * interpolation_src_height);
        memset(reinterpret_cast<char *>(mMapMem.mem[i]) +
            interpolation_src_width * interpolation_src_height,
            0x80,
            interpolation_src_width * interpolation_src_height / 2);
      }
    } else {
      memset(reinterpret_cast<void*>(mMapMem.mem[i]),
          0x10, format_->width() * format_->height());
      memset(reinterpret_cast<char *>(mMapMem.mem[i]) +
          format_->width() * format_->height(),
          0x80, format_->width() * format_->height() / 2);
    }
  }

  HAL_LOGD("Buffers had been prepared!");
  return 0;
}

int V4L2Stream::EnqueueBuffer() {
  if (!format_) {
    HAL_LOGE("Stream format must be set before enqueuing buffers.");
    return -ENODEV;
  }

  // Find a free buffer index. Could use some sort of persistent hinting
  // here to improve expected efficiency, but buffers_.size() is expected
  // to be low enough (<10 experimentally) that it's not worth it.
  int index = -1;
  {
    std::unique_lock<std::mutex> lock(buffer_queue_lock_);
    while (buffers_num_.empty()) {
      HAL_LOGV("buffers_num_ is empty now, wait for the queue to be filled.");
      if (mflush_buffers) {
        mflush_buffers = false;
        return 0;
      }
      buffer_availabl_queue_.wait(lock);
      if (mflush_buffers) {
        mflush_buffers = false;
        return 0;
      }
    }
    index = buffers_num_.front();
    buffers_num_.pop();
    HAL_LOGV("buffers_num_ pop:%d, size:%zu.", index, buffers_num_.size());
  }

  if (index < 0) {
    // Note: The HAL should be tracking the number of buffers in flight
    // for each stream, and should never overflow the device.
    HAL_LOGE("Cannot enqueue buffer: stream is already full.");
    return -ENODEV;
  }

  // Set up a v4l2 buffer struct.
  v4l2_buffer device_buffer;
  memset(&device_buffer, 0, sizeof(device_buffer));
  device_buffer.type = format_->type();
  device_buffer.index = index;
  device_buffer.memory = format_->memory();
  device_buffer.length = format_->nplanes();
  struct v4l2_plane planes[VIDEO_MAX_PLANES];
  memset(planes, 0, VIDEO_MAX_PLANES*sizeof(struct v4l2_plane));
  if (V4L2_CAPTURE_TYPE == device_buffer.type) {
    device_buffer.m.planes = planes;
    if (NULL == device_buffer.m.planes) {
      HAL_LOGE("device_buffer.m.planes calloc failed!\n");
    }
  }

  HAL_LOGV("mMapMem.mem[%d]:%p.", index, mMapMem.mem[index]);

  if (queueBuffer(&device_buffer) < 0) {
    HAL_LOGE("QBUF fails: %s", strerror(errno));
    return -ENODEV;
  }

  // Mark the buffer as in flight.
  std::lock_guard<std::mutex> guard(buffer_queue_lock_);
  buffers_[index] = true;

  return 0;
}

int V4L2Stream::DequeueBuffer(void** src_addr_, struct timeval* ts) {
  if (!format_) {
    HAL_LOGE(
        "Format not set, so stream can't be on, "
        "so no buffers available for dequeueing");
    return -EAGAIN;
  }

  v4l2_buffer buffer;
  memset(&buffer, 0, sizeof(buffer));
  buffer.type = format_->type();
  buffer.memory = format_->memory();
  buffer.length = format_->nplanes();
  struct v4l2_plane planes[VIDEO_MAX_PLANES];
  memset(planes, 0, VIDEO_MAX_PLANES*sizeof(struct v4l2_plane));
  if (V4L2_CAPTURE_TYPE == buffer.type) {
    buffer.m.planes = planes;
    if (NULL == buffer.m.planes) {
      HAL_LOGE("device_buffer.m.planes calloc failed!\n");
    }
  }

  int res = dequeueBuffer(&buffer);
  if (res) {
    if (errno == EAGAIN) {
      // Expected failure.
      return -EAGAIN;
    } else {
      // Unexpected failure.
      HAL_LOGE("DQBUF fails: %s", strerror(errno));
      return -ENODEV;
    }
  }

  *ts =  buffer.timestamp;
  *src_addr_ = mMapMem.mem[buffer.index];

#if DBG_SAVE_OUTPUT
  char yuv_path[100];
  dq_yuv_count = dq_yuv_count % output_counts;
  sprintf(yuv_path, "/data/camera/dq_yuv_%dx%d_%d.bin",
      format_->width(),
      format_->height(),
      dq_yuv_count++);
  int copy_size = ALIGN_16B(format_->width())*ALIGN_16B(format_->height())*3/2;
  saveBuffers(yuv_path, *src_addr_, copy_size, true);
#endif

  // Mark the buffer as no longer in flight.
  {
    std::lock_guard<std::mutex> guard(buffer_queue_lock_);
    buffers_[buffer.index] = false;
    buffers_num_.push(buffer.index);
    HAL_LOGV("buffers_num_ push:%d, size:%zu.",
        buffer.index, buffers_num_.size());
    buffer_availabl_queue_.notify_one();
    HAL_LOGV("buffer.index:%d has been freed by csi driver, "
        "and buffer_availabl_queue_ was notified!\n", buffer.index);
  }

  HAL_LOGV("mMapMem.mem[%d]:%p.", buffer.index, mMapMem.mem[buffer.index]);
  return 0;
}

int V4L2Stream::CopyYCbCrBuffer(android_ycbcr* dst_addr_ycbcr, void* src_addr) {
  if (!format_) {
    HAL_LOGE("Stream format must be set before enqueuing buffers.");
    return -ENODEV;
  }
  int res = 0;
  VencRect sCropInfo;
  VencIspBufferInfo pInBuffer, pOutBuffer;
  memset(&pInBuffer, 0, sizeof(pInBuffer));
  memset(&pOutBuffer, 0, sizeof(pOutBuffer));
  sCropInfo.nLeft = jpeg_crop_rect.left;
  sCropInfo.nTop = jpeg_crop_rect.top;
  sCropInfo.nWidth = jpeg_crop_rect.width;
  sCropInfo.nHeight = jpeg_crop_rect.height;

  int width = format_->width();
  int height = format_->height();

  if (device_ss_ == MAIN_STREAM) {
    if ((jpeg_crop_rect.width < width || jpeg_crop_rect.height < height)
        && jpeg_crop_rect.width > 0
        && jpeg_crop_rect.height > 0) {
      pInBuffer.nWidth         = width;
      pInBuffer.nHeight         = height;
      pInBuffer.colorFormat     = VENC_PIXEL_YUV420SP;
      pInBuffer.pAddrVirY     = (unsigned char*)src_addr;

      pOutBuffer.nWidth         = ALIGN_16B(width);
      pOutBuffer.nHeight         = ALIGN_16B(height);
      pOutBuffer.pAddrVirY     = (unsigned char*)dst_addr_ycbcr->y;

      HAL_LOGV("nLeft:%d, nTop:%d,nWidth:%d. nHeight:%d",
          sCropInfo.nLeft, sCropInfo.nTop, sCropInfo.nWidth, sCropInfo.nHeight);
      std::lock_guard<std::mutex> guard(aw_ve_lock);
      res = AWCropYuv(&pInBuffer, &sCropInfo , &pOutBuffer);
      if (res < 0) {
        HAL_LOGE("AWCropYuv fail nLeft:%d, nTop:%d,nWidth:%d. nHeight:%d",
            sCropInfo.nLeft,
            sCropInfo.nTop,
            sCropInfo.nWidth,
            sCropInfo.nHeight);
      } else {
        return 0;
      }
    }

    if (mCameraConfig->supportInterpolationSize()) {
      uint32_t interpolation_dst_width = 0;
      uint32_t interpolation_dst_height = 0;
      uint32_t interpolation_src_width = 0;
      uint32_t interpolation_src_height = 0;
      char * value;
      char * value1;
      value = mCameraConfig->supportInterpolationSizeValue();
      parse_pair(value,
          &interpolation_src_width, &interpolation_src_height, 'x');
      value1 = mCameraConfig->defaultInterpolationSizeValue();
      parse_pair(value1,
          &interpolation_dst_width, &interpolation_dst_height, 'x');
      if (interpolation_dst_width == format_->width() &&
          interpolation_dst_height == format_->height()) {
        pInBuffer.nWidth        = interpolation_src_width;
        pInBuffer.nHeight       = interpolation_src_height;
        pInBuffer.colorFormat   = VENC_PIXEL_YUV420SP;
        pInBuffer.pAddrVirY     = (unsigned char*)src_addr;
        pOutBuffer.nWidth       = ALIGN_16B(format_->width());
        pOutBuffer.nHeight      = ALIGN_16B(format_->height());
        pOutBuffer.pAddrVirY    = (unsigned char*)dst_addr_ycbcr->y;
        AWScalerYuv(&pInBuffer, &pOutBuffer);
        return 0;
      }
    }
  }

  if(mCameraConfig->supportReducecallnumSize())
  {
      int i,cur_width,cur_height;
      cur_width = reducecallnum_src_width;
      cur_height = reducecallnum_src_height;

      for(i = 0 ;i < reduce_call_num; i++)
      {
          memcpy((char *)dst_addr_ycbcr->y + i*(cur_width * cur_height),
              (char *)src_addr + i*(cur_width * cur_height * 3 / 2),
              cur_width*cur_height);
          /*memcpy((char *)dst_addr_ycbcr->cr + i*(cur_width * cur_height / 2),
              (char *)src_addr + (i + 1)*(cur_width * cur_height) + i * (cur_width*cur_height / 2),
              cur_width*cur_height / 2);*/
      }
      memcpy(dst_addr_ycbcr->cr, (char*)src_addr + width*height, width*height/2);
  }
  else {
      memcpy(dst_addr_ycbcr->y, src_addr, width*height);
      memcpy(dst_addr_ycbcr->cr, (char*)src_addr + width*height, width*height/2);
  }

#if DBG_SAVE_OUTPUT
  char yuv_path[100];
  sprintf(yuv_path, "/data/camera/yuv_preview_%dx%d_%d.bin",
      width, height,
      (cb_yuv_count++) % 10);
  int y_size = width * height;
  int cr_size = width * height/2;
  saveBuffers(yuv_path,
      dst_addr_ycbcr->y,
      dst_addr_ycbcr->cr,
      y_size,
      cr_size,
      true);
#endif

  return 0;
}

int V4L2Stream::EncodeBuffer(void * dst_addr,
                             void * src_addr,
                             unsigned long mJpegBufferSizes,
                             JPEG_ENC_t jpeg_enc) {
  isTakePicture = true;
  unsigned long jpeg_buf = (unsigned long)dst_addr;
  int bufSize = 0;

  // Get buffer size.
  HAL_LOGD("jpeg info:lock_buffer vaddr:%lu, buffer size:%lu.",
      jpeg_buf, mJpegBufferSizes);

  if (mCameraConfig->supportInterpolationSize()) {
    uint32_t interpolation_dst_width = 0;
    uint32_t interpolation_dst_height = 0;
    uint32_t interpolation_src_width = 0;
    uint32_t interpolation_src_height = 0;
    char * value;
    char * value1;
    value = mCameraConfig->supportInterpolationSizeValue();
    parse_pair(value, &interpolation_src_width, &interpolation_src_height, 'x');
    value1 = mCameraConfig->defaultInterpolationSizeValue();
    parse_pair(value1,
        &interpolation_dst_width, &interpolation_dst_height, 'x');
    if (interpolation_dst_width == format_->width() &&
        interpolation_dst_height == format_->height()) {
      jpeg_enc.src_w = interpolation_src_width;
      jpeg_enc.src_h = interpolation_src_height;
    }
  }

  if (jpeg_enc.src_w == 0) {
    jpeg_enc.src_w            = format_->width();
  }
  if (jpeg_enc.src_h == 0) {
    jpeg_enc.src_h            = format_->height();
  }

  if (jpeg_enc.rotate == 270 || jpeg_enc.rotate == 90) {
    std::swap(jpeg_enc.pic_w, jpeg_enc.pic_h);
    std::swap(jpeg_enc.crop_x, jpeg_enc.crop_y);
    std::swap(jpeg_enc.crop_w, jpeg_enc.crop_h);
  }

  jpeg_enc.colorFormat    = JPEG_COLOR_YUV420_NV21;

  char   mDateTime[64];
  time_t t;
  struct tm *tm_t;
  time(&t);
  tm_t = localtime(&t);
  sprintf(mDateTime,
          "%4d:%02d:%02d %02d:%02d:%02d",
          tm_t->tm_year+1900, tm_t->tm_mon+1, tm_t->tm_mday,
          tm_t->tm_hour, tm_t->tm_min, tm_t->tm_sec);

  char property[PROPERTY_VALUE_MAX];
  if (property_get("ro.product.manufacturer", property, "") > 0) {
    strcpy(jpeg_enc.CameraMake, property);
  }
  if (property_get("ro.product.model", property, "") > 0) {
    strcpy(jpeg_enc.CameraModel, property);
  }

  strcpy(jpeg_enc.DateTime, mDateTime);
  HAL_LOGV("jpeg info:%s.", mDateTime);

  jpeg_enc.whitebalance   = 0;
  jpeg_enc.focal_length    = 3.04;

  HAL_LOGV("src: %dx%d, pic: %dx%d, quality: %d, rotate: %d, Gps method: %s,"
      "thumbW: %d, thumbH: %d, factor: %d, crop: [%d, %d, %d, %d]",
      jpeg_enc.src_w,
      jpeg_enc.src_h,
      jpeg_enc.pic_w,
      jpeg_enc.pic_h,
      jpeg_enc.quality,
      jpeg_enc.rotate,
      jpeg_enc.gps_processing_method,
      jpeg_enc.thumbWidth,
      jpeg_enc.thumbHeight,
      jpeg_enc.scale_factor,
      jpeg_enc.crop_x,
      jpeg_enc.crop_y,
      jpeg_enc.crop_w,
      jpeg_enc.crop_h);


  JpegEncInfo sjpegInfo;
  EXIFInfo   exifInfo;
  memset(&sjpegInfo, 0, sizeof(JpegEncInfo));
  memset(&exifInfo, 0, sizeof(EXIFInfo));

  sjpegInfo.sBaseInfo.nStride      = jpeg_enc.src_w;
  sjpegInfo.sBaseInfo.nInputWidth  = jpeg_enc.src_w;
  sjpegInfo.sBaseInfo.nInputHeight = jpeg_enc.src_h;
  sjpegInfo.sBaseInfo.nDstWidth    = jpeg_enc.pic_w;
  sjpegInfo.sBaseInfo.nDstHeight   = jpeg_enc.pic_h;
  sjpegInfo.sBaseInfo.eInputFormat = VENC_PIXEL_YVU420SP;
  if (mCameraConfig->supportInterpolationSize()) {
    jpeg_enc.quality  = 100;
    sjpegInfo.quality = 100;
  } else if (format_->width() * format_->height() > 3264 * 2448) {
    jpeg_enc.quality  = 100;
    sjpegInfo.quality = 100;
  } 
  else {
    sjpegInfo.quality = jpeg_enc.quality;
  }

  exifInfo.Orientation = jpeg_enc.rotate;

  if (jpeg_enc.crop_h != 0) {
    sjpegInfo.nShareBufFd = jpeg_enc.crop_h;
    jpeg_enc.crop_h = 0;
    sjpegInfo.bNoUseAddrPhy = 0;
  } else {
    sjpegInfo.nShareBufFd = jpeg_enc.crop_h;
    jpeg_enc.crop_h = 0;
    sjpegInfo.bNoUseAddrPhy = 1;
  }

  HAL_LOGV("V4L2Stream::EncodeBuffer left:%d top:%d width:%d height:%d",
      jpeg_crop_rect.left,
      jpeg_crop_rect.top,
      jpeg_crop_rect.width,
      jpeg_crop_rect.height);

  if (jpeg_enc.enable_crop != 0 &&
      (jpeg_crop_rect.left != 0 || jpeg_crop_rect.top != 0)) {
    sjpegInfo.bEnableCorp = 1;
    sjpegInfo.sCropInfo.nWidth  = jpeg_crop_rect.width;
    sjpegInfo.sCropInfo.nHeight = jpeg_crop_rect.height;
    sjpegInfo.sCropInfo.nLeft   = jpeg_crop_rect.left;
    sjpegInfo.sCropInfo.nTop    = jpeg_crop_rect.top;
  } else {
    sjpegInfo.bEnableCorp = 0;
  }

  sjpegInfo.pAddrPhyY = (unsigned char *)src_addr;
  sjpegInfo.pAddrPhyC = (unsigned char *)((unsigned long)src_addr +
      jpeg_enc.src_w *jpeg_enc.src_h);
  sjpegInfo.pAddrVirY = (unsigned char *)src_addr;
  sjpegInfo.pAddrVirC = (unsigned char *)((unsigned long)src_addr +
      jpeg_enc.src_w *jpeg_enc.src_h);

  exifInfo.ThumbWidth = jpeg_enc.thumbWidth;
  exifInfo.ThumbHeight = jpeg_enc.thumbHeight;

  HAL_LOGD("src: %dx%d, pic: %dx%d, quality: %d, rotate: %d,"
      "thumbW: %d, thumbH: %d, EnableCorp: %d, "
      "crop: [%d, %d, %d, %d], share_fd:%d",
      sjpegInfo.sBaseInfo.nInputWidth,
      sjpegInfo.sBaseInfo.nInputHeight,
      sjpegInfo.sBaseInfo.nDstWidth,
      sjpegInfo.sBaseInfo.nDstHeight,
      sjpegInfo.quality,
      exifInfo.Orientation,
      exifInfo.ThumbWidth,
      exifInfo.ThumbHeight,
      sjpegInfo.bEnableCorp,
      sjpegInfo.sCropInfo.nLeft,
      sjpegInfo.sCropInfo.nTop,
      sjpegInfo.sCropInfo.nWidth,
      sjpegInfo.sCropInfo.nHeight,
      sjpegInfo.nShareBufFd);

  strcpy(reinterpret_cast<char*>(exifInfo.CameraMake), jpeg_enc.CameraMake);
  strcpy(reinterpret_cast<char*>(exifInfo.CameraModel), jpeg_enc.CameraModel);
  strcpy(reinterpret_cast<char*>(exifInfo.DateTime), jpeg_enc.DateTime);

  struct timeval tv;
  gettimeofday(&tv, NULL);
  char       subSecTime1[8];
  char       subSecTime2[8];
  char       subSecTime3[8];
  sprintf(subSecTime1, "%06ld", tv.tv_usec);
  sprintf(subSecTime2, "%06ld", tv.tv_usec);
  sprintf(subSecTime3, "%06ld", tv.tv_usec);
  strcpy(reinterpret_cast<char*>(exifInfo.subSecTime), subSecTime1);
  strcpy(reinterpret_cast<char*>(exifInfo.subSecTimeOrig), subSecTime2);
  strcpy(reinterpret_cast<char*>(exifInfo.subSecTimeDig), subSecTime3);

  if (0 != strlen(jpeg_enc.gps_processing_method)) {
    strcpy(reinterpret_cast<char*>(exifInfo.gpsProcessingMethod),
        jpeg_enc.gps_processing_method);
    exifInfo.enableGpsInfo = 1;
    exifInfo.gps_latitude  = jpeg_enc.gps_latitude;
    exifInfo.gps_longitude = jpeg_enc.gps_longitude;
    exifInfo.gps_altitude  = jpeg_enc.gps_altitude;
    exifInfo.gps_timestamp = jpeg_enc.gps_timestamp;
  } else {
    exifInfo.enableGpsInfo = 0;
  }

  // TODO(aw): fix parameter for sensor
  exifInfo.ExposureTime.num = 25;
  exifInfo.ExposureTime.den = 100;
  // eg:FNum=2.2, aperture = 220, --> num = 220,den = 100
  exifInfo.FNumber.num      = 200;
  exifInfo.FNumber.den      = 100;
  exifInfo.ISOSpeed         = 400;

  exifInfo.ExposureBiasValue.num = 25;
  exifInfo.ExposureBiasValue.den = 100;

  exifInfo.MeteringMode = 0;
  exifInfo.FlashUsed    = 0;

  exifInfo.FocalLength.num = 304;
  exifInfo.FocalLength.den = 100;

  exifInfo.DigitalZoomRatio.num = 0;
  exifInfo.DigitalZoomRatio.den = 0;

  exifInfo.WhiteBalance = 0;
  exifInfo.ExposureMode = 0;

  std::lock_guard<std::mutex> guard(aw_ve_lock);

#if DBG_SAVE_OUTPUT
  char yuv_path[100];
  eb_yuv_count = eb_yuv_count % output_counts;
  sprintf(yuv_path, "/data/camera/eb_yuv_%d.bin", eb_yuv_count++);
  int yuv_size = jpeg_enc.src_w * jpeg_enc.src_h*3/2;
  saveBuffers(yuv_path, src_addr, yuv_size, true);
#endif
  int ret = AWJpecEnc(&sjpegInfo,
                      &exifInfo,
                      reinterpret_cast<void *>(jpeg_buf),
                      &bufSize);
#if DBG_SAVE_OUTPUT
  char jpeg_path[100];
  eb_jpeg_count = eb_jpeg_count % output_counts;
  sprintf(jpeg_path, "/data/camera/eb_jpg_%d.jpg", eb_jpeg_count++);
  saveBuffers(jpeg_path, reinterpret_cast<void*>(jpeg_buf), bufSize, true);
#endif

  if (ret < 0) {
    HAL_LOGE("JpegEnc failed");
    return false;
  }

  int isp_3a_param_size = 0;
  int isp_debug_msg_size = 0;

  camera3_jpeg_3a_blob_t jpeg_3a_header;
  jpeg_3a_header.jpeg_3a_header_id = CAMERA3_JPEG_3A_PARAM_BLOB_ID;
  strncpy(jpeg_3a_header.magic_str, ISP_DEBUG_MAGIC_STR, 8);

  camera3_jpeg_isp_msg_blob_t jpeg_isp_msg_header;
  jpeg_isp_msg_header.jpeg_isp_msg_header_id = CAMERA3_JPEG_ISP_MSG_BLOB_ID;
  strncpy(jpeg_isp_msg_header.magic_str, ISP_DEBUG_MAGIC_STR, 8);

  camera3_jpeg_blob_t jpegHeader;
  jpegHeader.jpeg_blob_id = CAMERA3_JPEG_BLOB_ID;

  unsigned long jpeg_eof_offset =
    (unsigned long)(mJpegBufferSizes - (unsigned long)sizeof(jpegHeader));
  char *jpeg_eof = reinterpret_cast<char *>(jpeg_buf) + jpeg_eof_offset;

  char *jpeg_isp_3a_params = reinterpret_cast<char *>(jpeg_buf + bufSize);
  isp_3a_param_size =
      mAWIspApi->awIspGet3AParameters(reinterpret_cast<void*>(
          jpeg_isp_3a_params + sizeof(jpeg_3a_header)));
  jpeg_3a_header.jpeg_3a_size = sizeof(camera3_jpeg_3a_blob_t) +
      isp_3a_param_size;
  memcpy(jpeg_isp_3a_params, &jpeg_3a_header, sizeof(jpeg_3a_header));

  char *jpeg_isp_debug_msg = reinterpret_cast<char *>(jpeg_buf + bufSize +
      jpeg_3a_header.jpeg_3a_size);
  isp_debug_msg_size =
      mAWIspApi->awIspGetDebugMessage(reinterpret_cast<void*>(
          jpeg_isp_debug_msg + sizeof(jpeg_isp_msg_header)));
  jpeg_isp_msg_header.jpeg_isp_msg_size =
      sizeof(camera3_jpeg_isp_msg_blob_t) + isp_debug_msg_size;
  memcpy(jpeg_isp_debug_msg, &jpeg_isp_msg_header, sizeof(jpeg_isp_msg_header));

  jpegHeader.jpeg_size =
      bufSize + jpeg_3a_header.jpeg_3a_size +
      jpeg_isp_msg_header.jpeg_isp_msg_size;
  memcpy(jpeg_eof, &jpegHeader, sizeof(jpegHeader));

  HAL_LOGV("####jpeg_size:%d jpeg_3a_size:%d jpeg_isp_msg_size:%d",
      jpegHeader.jpeg_size,jpeg_3a_header.jpeg_3a_size,
      jpeg_isp_msg_header.jpeg_isp_msg_size);

  return 0;
}

int V4L2Stream::WaitCameraReady() {
  if (!format_) {
    HAL_LOGV(
        "Format not set, so stream can't be on, "
        "so no buffers available for Ready");
    return -EAGAIN;
  }

  int ret = -1;
  int epollftd = epoll_create(2);
  if (epollftd == -1) {
    HAL_LOGE("create epoll failed");
    return -1;
  }

  epoll_event event;
  event.events = EPOLLIN | EPOLLET;
  event.data.fd = device_fd_;
  ret = epoll_ctl(epollftd, EPOLL_CTL_ADD, device_fd_, &event);

  if (ret == -1) {
    HAL_LOGE("add device fd failed");
    close(epollftd);
    return -1;
  }

  epoll_event wakeup;
  wakeup.events = EPOLLIN | EPOLLET;
  wakeup.data.fd = read_fd_;
  epoll_ctl(epollftd, EPOLL_CTL_ADD, read_fd_, &event);

  if (pEvents == NULL) {
    pEvents = (epoll_event *)calloc(2, sizeof(epoll_event));
    if (pEvents == NULL) {
      close(epollftd);
      return -1;
    }
  }
  int nEventNum = epoll_wait(epollftd, pEvents, 2, 1000);
  ret = -1;
  for (int i = 0; i < nEventNum; i++) {
    if (pEvents[i].data.fd == device_fd_) {
      if (pEvents[i].events & EPOLLIN) {
        ret = 0;
        break;
      }
    } else if (pEvents[i].data.fd == read_fd_ && disconnect) {
      char data[2];
      read(read_fd_, data, 2);
      ret = -1;
      break;
    }
  }

  close(epollftd);
  return ret;
}

}  // namespace v4l2_camera_hal