/*
 * 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_CameraStream"
#include "camera_stream.h"

#include <fcntl.h>
#include <hardware/camera3.h>
#include <inttypes.h>
#include <string.h>
#include <sunxi_camera_v2.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>

#include <cstdlib>
#include <memory>

#include "CameraMetadata.h"
#include "metadata/metadata_common.h"
#include "stream_manager.h"

namespace v4l2_camera_hal {

template <typename T>
int CameraStream::inRange(T low, T high, T val) {
  return ((val - high) * (val - low) <= 0);
}

void CameraStream::calProperRectSize(cam_crop_rect_t srcRect,
                                     cam_crop_rect_t* dstRect) {
  std::array<int32, 2> mActiveSize = {640, 480};
  int res = SingleTagValue(mStaticMetadata.get(),
                           ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
                           &mActiveSize);
  if (res) {
    HAL_LOGE("Cannot find ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE size");
  }
  int size_width  = ALIGN_16B(mActiveSize[0]);
  int size_height = ALIGN_16B(mActiveSize[1]);
  double ratio_w  = static_cast<double>(mWidth) /
      static_cast<double>(size_width);
  double ratio_h  = static_cast<double>(mHeight) /
      static_cast<double>(size_height);
  if (inRange(0.0, 1.0, ratio_w) && inRange(0.0, 1.0, ratio_h)) {
    dstRect->width  = ratio_w*srcRect.width;
    dstRect->height = ratio_h*srcRect.height;
    dstRect->left   = (mWidth-dstRect->width)/2;
    dstRect->top    = (mHeight-dstRect->height)/2;
  } else {
    dstRect->width  = srcRect.width;
    dstRect->height = srcRect.height;
    dstRect->left   = srcRect.left;
    dstRect->top    = srcRect.top;
  }
}

CameraStream* CameraStream::NewCameraStream(std::shared_ptr<V4L2Stream> stream,
                                            int isBlob,
                                            int isMirror) {
  HAL_LOG_ENTER();

  STREAM_SERIAL ss_tmp = stream->getStreamSerial();
  HAL_LOGD("Device getStreamSerial %d, isBlob:%d, isMirror:%d.",
      ss_tmp, isBlob, isMirror);

  if (isMirror) {
    if (ss_tmp == MAIN_STREAM) {
      return new CameraMainMirrorStream(stream, isBlob);
    } else if (ss_tmp == SUB_0_STREAM) {
      return new CameraSubMirrorStream(stream, isBlob);
    } else {
      return nullptr;
    }
  } else {
    if (ss_tmp == MAIN_STREAM) {
      return new CameraMainStream(stream, isBlob);
    } else if (ss_tmp == SUB_0_STREAM) {
      return new CameraSubStream(stream, isBlob);
    } else {
      return nullptr;
    }
  }
}

CameraStream::CameraStream(std::shared_ptr<V4L2Stream> stream, int isBlob):
    isBlobFlag(isBlob),
    stream_(stream) {
  HAL_LOG_ENTER();
  manager_    = nullptr;
  mMetadata   = nullptr;
  mStreamOn   = false;
  initialized = false;
  mWidth      = 0;
  mHeight     = 0;
  mFormat     = 0;
  mUsage      = 0;
}

int CameraStream::configurateManager(StreamManager* manager) {
  HAL_LOG_ENTER();
  int res  = 0;
  manager_ = manager;
  return res;
}

CameraStream::~CameraStream() {
  HAL_LOG_ENTER();
}

int CameraStream::encodebuffer(void* dst_addr,
                               void* src_addr,
                               unsigned long mJpegBufferSizes) {
  int res = -ENOMEM;
  JPEG_ENC_t jpeg_enc;
  memset(&jpeg_enc, 0, sizeof(jpeg_enc));

  std::array<uint8_t, 33> mGpsMethod = {0};
  res = SingleTagValue(mMetadata,
                       ANDROID_JPEG_GPS_PROCESSING_METHOD,
                       &mGpsMethod);
  HAL_LOGV("%s: jpeg info:mGpsMethod:%s.",
      mStreamType.c_str(), (unsigned char *)(&(mGpsMethod[0])));

  if (0 != mGpsMethod[0]) {
    std::array<double, 3> gpsCoordinates = {0, 0, 0};
    res = SingleTagValue(mMetadata,
                         ANDROID_JPEG_GPS_COORDINATES,
                         &gpsCoordinates);
    HAL_LOGV("%s: jpeg info:latitude:%f, longitude:%f, altitude:%f.",
       mStreamType.c_str(),
       gpsCoordinates[0],
       gpsCoordinates[1],
       gpsCoordinates[2]);
    int64 mGpsTimestamp = 0;
    res = SingleTagValue(mMetadata,
                         ANDROID_JPEG_GPS_TIMESTAMP,
                         &mGpsTimestamp);
    HAL_LOGV("%s: jpeg info:mGpsTimestamp:%" PRId64 ".",
        mStreamType.c_str(), mGpsTimestamp);

    jpeg_enc.enable_gps     = 1;
    jpeg_enc.gps_latitude   = gpsCoordinates[0];
    jpeg_enc.gps_longitude  = gpsCoordinates[1];
    jpeg_enc.gps_altitude   = gpsCoordinates[2];
    jpeg_enc.gps_timestamp  = mGpsTimestamp;
    for (int i = 0; i < 33; i++) {
      jpeg_enc.gps_processing_method[i] = mGpsMethod[i];
    }
  } else {
    jpeg_enc.enable_gps = 0;
  }

  int32 mOrientation = 0;
  res = SingleTagValue(mMetadata,
                       ANDROID_JPEG_ORIENTATION,
                       &mOrientation);
  jpeg_enc.rotate = mOrientation;

  byte mQuality = 90;
  res = SingleTagValue(mMetadata,
                       ANDROID_JPEG_QUALITY,
                       &mQuality);
  HAL_LOGV("%s: jpeg info:mQuality:%d.", mStreamType.c_str(), mQuality);
  jpeg_enc.quality = mQuality;

  byte mThumbnailQuality = 90;
  res = SingleTagValue(mMetadata,
                       ANDROID_JPEG_THUMBNAIL_QUALITY,
                       &mThumbnailQuality);
  HAL_LOGV("%s: jpeg info:mThumbnailQuality:%d.",
      mStreamType.c_str(), mQuality);

  std::array<int32, 2> mThumbnailSize = {320, 240};
  res = SingleTagValue(mMetadata,
                       ANDROID_JPEG_THUMBNAIL_SIZE,
                       &mThumbnailSize);
  HAL_LOGV("%s: jpeg info:mThumbnailSize:%dx%d.",
      mStreamType.c_str(),
      mThumbnailSize[0],
      mThumbnailSize[1]);

  jpeg_enc.pic_w       = mWidth;
  jpeg_enc.pic_h       = mHeight;
  jpeg_enc.thumbWidth  = mThumbnailSize[0];
  jpeg_enc.thumbHeight = mThumbnailSize[1];

  uint8_t capture_intent = 0;
  if (mMetadata->exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
    capture_intent =
      mMetadata->find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
  }
  if (isBlobFlag && capture_intent !=
      ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT) {
    jpeg_enc.enable_crop = 1;
  } else {
    jpeg_enc.enable_crop = 0;
  }
  res = stream_->EncodeBuffer(dst_addr, src_addr, mJpegBufferSizes, jpeg_enc);
  if (res) {
    HAL_LOGE("%s: Device EncodeBuffer failed.", mStreamType.c_str());
  }
  return res;
}

int CameraStream::copy_ycbcr_buffer(android_ycbcr* dst_addr_ycbcr,
                                    void * src_addr) {
  HAL_LOGV("%s: enter", mStreamType.c_str());
  return stream_->CopyYCbCrBuffer(dst_addr_ycbcr, src_addr);
}

int CameraStream::start() {
  HAL_LOGV("%s: enter", mStreamType.c_str());
  int res = 0;
  if (initialized) {
    // Stream on first.
    if (!mStreamOn) {
      res = stream_->StreamOn();
      if (res) {
        HAL_LOGE("%s: Device failed to turn on stream.", mStreamType.c_str());
        return res;
      }
      mStreamOn = true;
    }
  }
  return res;
}

int CameraStream::stop() {
  HAL_LOGV("%s: enter", mStreamType.c_str());
  int res = 0;
  if (initialized) {
    // Stream on first.
    if (!mStreamOn) {
      HAL_LOGE("Device failed to turn off stream, turn on first.");
    } else {
      res = stream_->StreamOff();
      if (res) {
        HAL_LOGE("Device failed to turn off stream.");
        return res;
      }
      mStreamOn = false;
    }
  }
  return res;
}

int CameraStream::setFormat(uint32_t width,
                            uint32_t height,
                            int      format,
                            uint32_t usage) {
  HAL_LOGD("%s:%d x %d, format:%d(%s), usage:%d(%s).",
      mStreamType.c_str(),
      width,
      height,
      format,
      getHalPixelFormatString(format).c_str(),
      usage,
      getGrallocUsageString(usage).c_str());
  mWidth  = width;
  mHeight = height;
  mFormat = format;
  mUsage  = usage;
  return 0;
}

int CameraStream::enqueueBuffer() {
  HAL_LOGV("%s", mStreamType.c_str());
  int res = 0;
  if (initialized) {
    res = stream_->EnqueueBuffer();
    if (res) {
      HAL_LOGE("Device failed to turn on stream.");
      return res;
    }
  }
  return res;
}

int CameraStream::dequeueBuffer(void ** src_addr, struct timeval * ts) {
  HAL_LOGV("%s: enter", mStreamType.c_str());
  int res = 0;
  if (initialized) {
    res = stream_->WaitCameraReady();
    if (res != 0) {
      HAL_LOGW("%s: wait v4l2 buffer time out in dequeueBuffer!",
          mStreamType.c_str());
      return res;
    }

    res = stream_->DequeueBuffer(src_addr, ts);
    if (res) {
      HAL_LOGE("%s: Device failed to DequeueBuffer.", mStreamType.c_str());
      return res;
    }
  }
  return res;
}

int CameraStream::setIspFlash(int CameraFlashMode) {
    int res = 0;
    if (CameraFlashMode == CAM_FLASH_MODE_ON) {
        HAL_LOGV("%s: CAM_FLASH_MODE_ON", mStreamType.c_str());
        stream_->SetTakePictureCtrl(V4L2_TAKE_PICTURE_FLASH);
        stream_->SetFlashMode(V4L2_FLASH_LED_MODE_TORCH);
    } else if (CameraFlashMode == CAM_FLASH_MODE_AUTO) {
        HAL_LOGV("%s: CAM_FLASH_MODE_AUTO", mStreamType.c_str());
        stream_->SetTakePictureCtrl(V4L2_TAKE_PICTURE_FLASH);
        stream_->SetFlashMode(V4L2_FLASH_LED_MODE_AUTO);
    } else if (CameraFlashMode == CAM_FLASH_MODE_TORCH) {
        HAL_LOGV("%s: CAM_FLASH_MODE_TORCH", mStreamType.c_str());
        stream_->SetFlashMode(V4L2_FLASH_LED_MODE_TORCH);
    } else if (CameraFlashMode == CAM_FLASH_MODE_VIDEO_OFF) {
        HAL_LOGV("%s: CAM_FLASH_MODE_VIDEO_OFF", mStreamType.c_str());
        stream_->SetFlashMode(V4L2_FLASH_LED_MODE_NONE);
    } else if (CameraFlashMode == CAM_FLASH_MODE_OFF) {
        HAL_LOGV("%s: CAM_FLASH_MODE_OFF", mStreamType.c_str());
        stream_->SetTakePictureCtrl(V4L2_TAKE_PICTURE_STOP);
        stream_->SetFlashMode(V4L2_FLASH_LED_MODE_NONE);
    }
    return res;
}

int CameraStream::getFocusStatus() {
  return stream_->GetAutoFocusStatus();
}

int CameraStream::setFocusInit() {
  return stream_->SetAutoFocusInit();
}

int CameraStream::setIspFocus(int cameraFocusMode) {
  int res = -1;
  if (cameraFocusMode == CAM_FOCUS_MODE_STOP) {
    res = stream_->SetAutoFocusStop();
  } else if (cameraFocusMode == CAM_FOCUS_MODE_START) {
    res = stream_->SetAutoFocusStart();
  }
  return res;
}

int CameraStream::setIspCrop(cam_crop_rect_t camCropRect) {
  int res = -1;
  HAL_LOGV("%s left:%d top:%d width:%d height:%d",
      mStreamType.c_str(),
      camCropRect.left,
      camCropRect.top,
      camCropRect.width,
      camCropRect.height);
  if (!isBlobFlag) {
    res = stream_->SetCropRect(camCropRect);
  } else {
    cam_crop_rect_t jpegCropRect;
    memset(&jpegCropRect, 0, sizeof(cam_crop_rect_t));
    calProperRectSize(camCropRect, &jpegCropRect);
    res = stream_->SetJpegCropRect(jpegCropRect);
  }
  return res;
}

int CameraStream::setIspFocusRegions(cam_rect_t cam_regions) {
  HAL_LOG_ENTER();
  return stream_->SetAutoFocusRegions(cam_regions);
}

int CameraStream::flush() {
  int res = 0;
  if (initialized) {
    // Stream on first.
    if (!mStreamOn) {
      HAL_LOGE("%s: Device failed to flush stream, turn on first.",
          mStreamType.c_str());
    } else {
      res = stream_->flush();
      if (res) {
        HAL_LOGE("%s: Device failed to flush stream.", mStreamType.c_str());
        return res;
      }
    }
  }
  return res;
}

int CameraStream::initialize(uint32_t width,
                             uint32_t height,
                             int      format,
                             uint32_t usage,
                             bool     mergeStreamFlag) {
  int res = -1;
  HAL_LOGD("%s: %d x %d, format:%d(%s), usage:%d.",
      mStreamType.c_str(),
      width,
      height,
      format,
      getHalPixelFormatString(format).c_str(),
      usage);

  res = stream_->SetParm(V4L2_MODE_VIDEO, width, height);
  if (res) {
    HAL_LOGE("%s: Failed to SetParm.", mStreamType.c_str());
  }

  uint32_t max_buffers = MAX_BUFFER_NUM;
  if (format == HAL_PIXEL_FORMAT_BLOB) {
    format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
  }
  StreamFormat stream_format(format, width, height);
  res = stream_->SetFormat(stream_format, &max_buffers, mergeStreamFlag);
  if (res) {
    HAL_LOGE("%s: Failed to set stream to correct format for stream: %d.",
        mStreamType.c_str(), res);
  }

  res = stream_->PrepareBuffer();
  if (res) {
    HAL_LOGE("%s: Failed to prepare buffer.", mStreamType.c_str());
    return -ENODEV;
  }
  initialized = true;
  // Stream on first.
  if (!mStreamOn) {
    res = stream_->StreamOn();
    if (res) {
      HAL_LOGE("%s: Device failed to turn on stream.", mStreamType.c_str());
      return res;
    }
    mStreamOn = true;
  }
  return res;
}

int CameraStream::request(buffer_handle_t * buffer,
                              uint32_t frameNumber,
                              CameraMetadata* metadata) {
  int res = 0;
  mMetadata = metadata;

  if (!isBlobFlag) {
    std::lock_guard<std::mutex> guard(yuv_buffer_queue_lock_);
    frame_bufferHandle_map_t tmp;
    tmp.bufferHandleptr = buffer;
    tmp.frameNum = frameNumber;
    frameNumber_buffers_map_queue_.push(tmp);
    HAL_LOGV("%s: frameNumber_buffers_map_queue_ buffer_handle_t*:%p,"
        "FrameNumber:%d pushed.", mStreamType.c_str(), buffer, frameNumber);
  } else {
    std::lock_guard<std::mutex> guard(blob_buffer_queue_lock_);
    frame_bufferHandle_map_t tmp;
    tmp.bufferHandleptr = buffer;
    tmp.frameNum = frameNumber;
    blob_frameNumber_buffers_map_queue_.push(tmp);
    HAL_LOGV("%s: blob_frameNumber_buffers_map_queue_ buffer_handle_t*:%p,"
        "FrameNumber:%d pushed.", mStreamType.c_str(), buffer, frameNumber);
  }

  return res;
}

int CameraStream::getBuffer(buffer_handle_t ** buffer,
                            uint32_t* frameNumber) {
  int res = -ENOMEM;
  HAL_LOGV("%s: frameNumber_buffers_map_queue_ has %zu buffer(s).",
      mStreamType.c_str(),
      frameNumber_buffers_map_queue_.size());
  HAL_LOGV("%s: blob_frameNumber_buffers_map_queue_ has %zu buffer(s).",
      mStreamType.c_str(),
      blob_frameNumber_buffers_map_queue_.size());

  if (frameNumber_buffers_map_queue_.size() && !isBlobFlag) {
    std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
    frame_bufferHandle_map_t tmp = frameNumber_buffers_map_queue_.front();
    *frameNumber = tmp.frameNum;
    *buffer = tmp.bufferHandleptr;
    frameNumber_buffers_map_queue_.pop();
    HAL_LOGV("%s: frameNumber_buffers_map_queue_ buffer_handle_t*:%p,"
        "FrameNumber:%d poped.",
        mStreamType.c_str(),
        *buffer,
        *frameNumber);
    res = 0;
  } else if (blob_frameNumber_buffers_map_queue_.size()) {
    std::unique_lock<std::mutex> lock(blob_buffer_queue_lock_);
    frame_bufferHandle_map_t tmp =
        blob_frameNumber_buffers_map_queue_.front();;
    *frameNumber = tmp.frameNum;
    *buffer = tmp.bufferHandleptr;
    blob_frameNumber_buffers_map_queue_.pop();
    HAL_LOGV("%s: blob_frameNumber_buffers_map_queue_ buffer_handle_t*:%p,"
        "FrameNumber:%d poped.",
        mStreamType.c_str(),
        *buffer,
        *frameNumber);
    res = 0;
  }
  return res;
}

int CameraStream::waitBuffer() {
  while (frameNumber_buffers_map_queue_.empty()) {
    std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
    HAL_LOGV("%s: Wait the yuv_buffer_queue_lock_ lock.", mStreamType.c_str());
    yuv_buffer_availabl_queue_.wait(lock);
    HAL_LOGV("%s: The lock has been notified.", mStreamType.c_str());
  }
  return 0;
}

CameraMainStream::CameraMainStream(std::shared_ptr<V4L2Stream> stream,
                                   int isBlob):
    CameraStream(stream, isBlob) {
  HAL_LOG_ENTER();
  mStreamType = "CameraMainStream";
}

CameraMainStream::~CameraMainStream() {
  HAL_LOG_ENTER();
  std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
}

int CameraMainStream::start() {
  return CameraStream::start();
}

int CameraMainStream::stop() {
  return CameraStream::stop();
}

int CameraMainStream::flush() {
  return CameraStream::flush();
}

int CameraMainStream::initialize(uint32_t width,
                                 uint32_t height,
                                 int      format,
                                 uint32_t usage,
                                 bool mergeStreamFlag) {
  return CameraStream::initialize(width,
                                  height,
                                  format,
                                  usage,
                                  mergeStreamFlag);
}

int CameraMainStream::setFormat(uint32_t width,
                                uint32_t height,
                                int format,
                                uint32_t usage) {
  return CameraStream::setFormat(width, height, format, usage);
}

int CameraMainStream::waitBuffer() {
  return CameraStream::waitBuffer();
}

int CameraMainStream::getBuffer(buffer_handle_t ** buffer,
                                uint32_t* frameNumber) {
  return CameraStream::getBuffer(buffer, frameNumber);
}

int CameraMainStream::encodebuffer(void* dst_addr,
                                   void* src_addr,
                                   unsigned long mJpegBufferSizes) {
  return CameraStream::encodebuffer(dst_addr, src_addr, mJpegBufferSizes);
}

int CameraMainStream::copy_ycbcr_buffer(android_ycbcr* dst_addr_ycbcr,
                                        void* src_addr) {
  int res = -ENOMEM;
  res = CameraStream::copy_ycbcr_buffer(dst_addr_ycbcr, src_addr);
  if (res) {
    HAL_LOGE("Device CopyBuffer failed.");
  }
  return res;
}

int CameraMainStream::request(buffer_handle_t * buffer,
                              uint32_t frameNumber,
                              CameraMetadata* metadata) {
  int res = CameraStream::request(buffer, frameNumber, metadata);
  if (!res) {
    HAL_LOGE("%s: request failed!", mStreamType.c_str());
    return res;
  }

  if (!mStreamOn) {
    res = stream_->StreamOn();
    if (res) {
      HAL_LOGE("%s: Device failed to turn on stream.", mStreamType.c_str());
      return res;
    }
    mStreamOn = true;
    manager_->start(stream_->getStreamSerial());
  }

  return res;
}

int CameraMainStream::enqueueBuffer() {
  return CameraStream::enqueueBuffer();
}

int CameraMainStream::dequeueBuffer(void ** src_addr, struct timeval * ts) {
  return CameraStream::dequeueBuffer(src_addr, ts);
}

int CameraMainStream::setIspFlash(int CameraFlashMode) {
    HAL_LOGV("%s CameraFlashMode:%d", mStreamType.c_str(), CameraFlashMode);
    return CameraStream::setIspFlash(CameraFlashMode);
}

int CameraMainStream::getFocusStatus() {
  int res = CameraStream::getFocusStatus();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraMainStream::setFocusInit() {
  int res = CameraStream::setFocusInit();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraMainStream::setIspFocus(int cameraFocusMode) {
  int res = -1;
  res = CameraStream::setIspFocus(cameraFocusMode);
  HAL_LOGV("%s res:%d cameraFocusMode:%d",
      mStreamType.c_str(), res, cameraFocusMode);
  return res;
}

int CameraMainStream::setIspCrop(cam_crop_rect_t camCropRect) {
  int res = CameraStream::setIspCrop(camCropRect);
  return res;
}

int CameraMainStream::setIspFocusRegions(cam_rect_t cam_regions) {
  HAL_LOG_ENTER();
  int res = CameraStream::setIspFocusRegions(cam_regions);
  HAL_LOGV("%s SetAutoFocusRegions"
      "x_min:%d y_min:%d x_max:%d y_max:%d",
      mStreamType.c_str(),
      cam_regions.x_min,
      cam_regions.y_min,
      cam_regions.x_max,
      cam_regions.y_max);
  return res;
}

CameraSubStream::CameraSubStream(std::shared_ptr<V4L2Stream> stream,
                                 int isBlob):
    CameraStream(stream, isBlob) {
  HAL_LOG_ENTER();
  mStreamType = "CameraSubStream";
}

CameraSubStream::~CameraSubStream() {
  HAL_LOG_ENTER();
  std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
}

int CameraSubStream::start() {
  return CameraStream::start();
}

int CameraSubStream::stop() {
  return CameraStream::stop();
}

int CameraSubStream::flush() {
  return CameraStream::flush();
}

int CameraSubStream::initialize(uint32_t width,
                                uint32_t height,
                                int format,
                                uint32_t usage,
                                bool mergeStreamFlag) {
  return CameraStream::initialize(width,
                                  height,
                                  format,
                                  usage,
                                  mergeStreamFlag);

}

int CameraSubStream::setFormat(uint32_t width,
                               uint32_t height,
                               int format,
                               uint32_t usage) {
  return CameraStream::setFormat(width, height, format, usage);
}

int CameraSubStream::waitBuffer() {
  return CameraStream::waitBuffer();
}

int CameraSubStream::getBuffer(buffer_handle_t ** buffer,
                               uint32_t* frameNumber) {
  return CameraStream::getBuffer(buffer, frameNumber);
}

int CameraSubStream::encodebuffer(void * dst_addr,
                                  void * src_addr,
                                  unsigned long mJpegBufferSizes) {
  return CameraStream::encodebuffer(dst_addr, src_addr, mJpegBufferSizes);
}

int CameraSubStream::copy_ycbcr_buffer(android_ycbcr* dst_addr_ycbcr,
                                       void * src_addr) {
  int res = -ENOMEM;
  res = CameraStream::copy_ycbcr_buffer(dst_addr_ycbcr, src_addr);
  if (res) {
    HAL_LOGE("Device CopyBuffer.");
  }
  return res;
}

int CameraSubStream::request(buffer_handle_t * buffer,
                             uint32_t frameNumber,
                             CameraMetadata* metadata) {
  return CameraStream::request(buffer, frameNumber, metadata);
}

int CameraSubStream::enqueueBuffer() {
  return CameraStream::enqueueBuffer();
}

int CameraSubStream::dequeueBuffer(void ** src_addr, struct timeval * ts) {
  return CameraStream::dequeueBuffer(src_addr, ts);
}

int CameraSubStream::setIspFlash(int CameraFlashMode) {
    HAL_LOGV("%s CameraFlashMode:%d", mStreamType.c_str(), CameraFlashMode);
    return CameraStream::setIspFlash(CameraFlashMode);
}

int CameraSubStream::getFocusStatus() {
  int res = CameraStream::getFocusStatus();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraSubStream::setFocusInit() {
  int res = CameraStream::setFocusInit();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraSubStream::setIspFocus(int cameraFocusMode) {
  HAL_LOG_ENTER();
  int res = -1;
  res = CameraStream::setIspFocus(cameraFocusMode);
  HAL_LOGV("%s res:%d cameraFocusMode:%d",
      mStreamType.c_str(), res, cameraFocusMode);
  return res;
}

int CameraSubStream::setIspCrop(cam_crop_rect_t camCropRect) {
  int res = CameraStream::setIspCrop(camCropRect);
  return res;
}

int CameraSubStream::setIspFocusRegions(cam_rect_t cam_regions) {
  HAL_LOG_ENTER();
  int res = CameraStream::setIspFocusRegions(cam_regions);
  HAL_LOGV("%s SetAutoFocusRegions"
      "x_min:%d y_min:%d x_max:%d y_max:%d",
      mStreamType.c_str(),
      cam_regions.x_min,
      cam_regions.y_min,
      cam_regions.x_max,
      cam_regions.y_max);
  return res;
}

CameraMainMirrorStream::CameraMainMirrorStream(
    std::shared_ptr<V4L2Stream> stream, int isBlob):
        CameraStream(stream, isBlob) {
  HAL_LOG_ENTER();
  mStreamType = "CameraMainMirrorStream";
}

CameraMainMirrorStream::~CameraMainMirrorStream() {
  HAL_LOG_ENTER();
  std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
}

int CameraMainMirrorStream::start() {
  HAL_LOG_ENTER();
  return 0;
}

int CameraMainMirrorStream::stop() {
  HAL_LOG_ENTER();
  return 0;
}

int CameraMainMirrorStream::flush() {
  return 0;
}

int CameraMainMirrorStream::initialize(uint32_t /*width*/,
                                       uint32_t /*height*/,
                                       int /*format*/,
                                       uint32_t /*usage*/,
                                       bool /*mergeStreamFlag*/) {
  initialized = true;
  return 0;
}

int CameraMainMirrorStream::setFormat(uint32_t width,
                                      uint32_t height,
                                      int format,
                                      uint32_t usage) {
  return CameraStream::setFormat(width, height, format, usage);
}

int CameraMainMirrorStream::waitBuffer() {
  return 0;
}

int CameraMainMirrorStream::getBuffer(buffer_handle_t ** buffer,
                                      uint32_t* frameNumber) {
  return CameraStream::getBuffer(buffer, frameNumber);
}

int CameraMainMirrorStream::encodebuffer(void * dst_addr,
                                         void * src_addr,
                                         unsigned long mJpegBufferSizes) {
  return CameraStream::encodebuffer(dst_addr, src_addr, mJpegBufferSizes);
}

int CameraMainMirrorStream::copy_ycbcr_buffer(android_ycbcr* dst_addr_ycbcr,
                                              void * src_addr) {
  int res = -ENOMEM;
  res = CameraStream::copy_ycbcr_buffer(dst_addr_ycbcr, src_addr);
  if (res) {
    HAL_LOGE("%s: Device CopyBuffer.", mStreamType.c_str());
  }
  return res;
}

int CameraMainMirrorStream::request(buffer_handle_t * buffer,
                                    uint32_t frameNumber,
                                    CameraMetadata* metadata) {
  return CameraStream::request(buffer, frameNumber, metadata);
}

int CameraMainMirrorStream::enqueueBuffer() {
  return 0;
}

int CameraMainMirrorStream::dequeueBuffer(void ** /*src_addr*/,
                                          struct timeval * /*ts*/) {
  HAL_LOG_ENTER();
  return 0;
}

int CameraMainMirrorStream::setIspFlash(int CameraFlashMode) {
  HAL_LOGV("%s CameraFlashMode:%d", mStreamType.c_str(), CameraFlashMode);
  return 0;
}

int CameraMainMirrorStream::getFocusStatus() {
  int res = CameraStream::getFocusStatus();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraMainMirrorStream::setFocusInit() {
  int res = CameraStream::setFocusInit();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraMainMirrorStream::setIspFocus(int cameraFocusMode) {
  HAL_LOG_ENTER();
  int res = -1;
  HAL_LOGV("%s not implemented cameraFocusMode = %d",
      mStreamType.c_str(), cameraFocusMode);
  return res;
}

int CameraMainMirrorStream::setIspCrop(cam_crop_rect_t camCropRect) {
  int res = CameraStream::setIspCrop(camCropRect);
  return res;
}

int CameraMainMirrorStream::setIspFocusRegions(cam_rect_t cam_regions) {
    HAL_LOG_ENTER();
    int res = -1;
    HAL_LOGV("%s not implemented "
        "x_min:%d y_min:%d x_max:%d y_max:%d",
        mStreamType.c_str(),
        cam_regions.x_min,
        cam_regions.y_min,
        cam_regions.x_max,
        cam_regions.y_max);
    return res;
}

CameraSubMirrorStream::CameraSubMirrorStream(std::shared_ptr<V4L2Stream> stream,
                                             int isBlob):
    CameraStream(stream, isBlob) {
  HAL_LOG_ENTER();
  mStreamType = "CameraSubMirrorStream";
  mScaleFlag = false;
}

CameraSubMirrorStream::~CameraSubMirrorStream() {
  HAL_LOG_ENTER();
  std::unique_lock<std::mutex> lock(yuv_buffer_queue_lock_);
}

int CameraSubMirrorStream::start() {
  HAL_LOG_ENTER();
  return 0;
}

int CameraSubMirrorStream::stop() {
  HAL_LOG_ENTER();
  return 0;
}

int CameraSubMirrorStream::flush() {
  return 0;
}

int CameraSubMirrorStream::setScaleFlag() {
  HAL_LOG_ENTER();
  mScaleFlag = true;
  return 0;
}

int CameraSubMirrorStream::initialize(uint32_t /*width*/,
                                      uint32_t /*height*/,
                                      int /*format*/,
                                      uint32_t /*usage*/,
                                      bool /*mergeStreamFlag*/) {
  int res = 0;
  initialized = true;
  return res;
}

int CameraSubMirrorStream::setFormat(uint32_t width,
                                     uint32_t height,
                                     int format,
                                     uint32_t usage) {
  return CameraStream::setFormat(width, height, format, usage);
}

int CameraSubMirrorStream::waitBuffer() {
  return 0;
}

int CameraSubMirrorStream::getBuffer(buffer_handle_t ** buffer,
                                     uint32_t* frameNumber) {
  return CameraStream::getBuffer(buffer, frameNumber);
}

int CameraSubMirrorStream::encodebuffer(void* dst_addr,
                                        void* src_addr,
                                        unsigned long mJpegBufferSizes) {
  return CameraStream::encodebuffer(dst_addr, src_addr, mJpegBufferSizes);
}

int CameraSubMirrorStream::yuv420spDownScale(void* psrc,
                                             android_ycbcr* dst_addr_ycbcr,
                                             int src_w,
                                             int src_h,
                                             int dst_w,
                                             int dst_h) {
  HAL_LOG_ENTER();
  char * psrc_y  = static_cast<char *>(psrc);
  char * pdst_y  = static_cast<char *>(dst_addr_ycbcr->y);
  char * psrc_uv = static_cast<char *>(psrc) + src_w * src_h;
  char * pdst_uv = static_cast<char *>(dst_addr_ycbcr->cr);
  int scale = 1;
  int scale_w = src_w / dst_w;
  int scale_h = src_h / dst_h;
  int h, w;

  if (dst_w > src_w || dst_h > src_h) {
    HAL_LOGE("error size, %dx%d -> %dx%d\n", src_w, src_h, dst_w, dst_h);
    return -1;
  }

  if (scale_w == scale_h) {
    scale = scale_w;
  }

  HAL_LOGV("scale = %d\n", scale);

  if (scale == 1) {
    if ((src_w == dst_w) && (src_h == dst_h)) {
      memcpy(static_cast<char*>(pdst_y), static_cast<char*>(psrc), dst_w * dst_h);
      memcpy(static_cast<char*>(pdst_uv),
         static_cast<char*>(psrc) + dst_w * dst_h, dst_w * dst_h/2);
    } else {
      // crop
      for (h = 0; h < dst_h; h++) {
        memcpy(static_cast<char*>(pdst_y) + h * dst_w,
            static_cast<char*>(psrc) + h * src_w, dst_w);
      }
      for (h = 0; h < dst_h / 2; h++) {
        memcpy(static_cast<char*>(pdst_uv) + h * dst_w,
            static_cast<char*>(psrc_uv) + h * src_w, dst_w);
      }
    }

    return 0;
  }

  for (h = 0; h < dst_h; h++) {
    for (w = 0; w < dst_w; w++) {
      *(pdst_y + h * dst_w + w) = *(psrc_y + h * scale * src_w + w * scale);
    }
  }
  for (h = 0; h < dst_h / 2; h++) {
    for (w = 0; w < dst_w; w+=2) {
      *(reinterpret_cast<short*>(pdst_uv) + h * dst_w + w) =
        *(reinterpret_cast<short*>(psrc_uv) + h * scale * src_w + w * scale);
    }
  }
  return 0;
}

int CameraSubMirrorStream::copy_ycbcr_buffer(android_ycbcr* dst_addr_ycbcr,
                                             void * src_addr) {
  int res = -ENOMEM;
  if (mScaleFlag) {
    res = yuv420spDownScale(src_addr,
        dst_addr_ycbcr,
        stream_->GetDeviceWidth(),
        stream_->GetDeviceHeight(),
        mWidth,
        mHeight);
  } else {
    res = CameraStream::copy_ycbcr_buffer(dst_addr_ycbcr, src_addr);
  }
  if (res) {
    HAL_LOGE("Device CopyBuffer.");
  }
  return res;
}

int CameraSubMirrorStream::request(buffer_handle_t * buffer,
                                   uint32_t frameNumber,
                                   CameraMetadata* metadata) {
  return CameraStream::request(buffer, frameNumber, metadata);
}

int CameraSubMirrorStream::enqueueBuffer() {
  return 0;
}

int CameraSubMirrorStream::dequeueBuffer(void ** /*src_addr*/,
                                         struct timeval * /*ts*/) {
  HAL_LOG_ENTER();
  return 0;
}

int CameraSubMirrorStream::setIspFlash(int CameraFlashMode) {
  HAL_LOGV("%s CameraFlashMode:%d", mStreamType.c_str(), CameraFlashMode);
  return 0;
}

int CameraSubMirrorStream::getFocusStatus() {
  int res = CameraStream::getFocusStatus();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraSubMirrorStream::setFocusInit() {
  int res = CameraStream::setFocusInit();
  HAL_LOGV("%s res:%d", mStreamType.c_str(), res);
  return res;
}

int CameraSubMirrorStream::setIspFocus(int cameraFocusMode) {
  HAL_LOG_ENTER();
  int res = -1;
  HAL_LOGV("%s not implemented cameraFocusMode = %d",
      mStreamType.c_str(), cameraFocusMode);
  return res;
}

int CameraSubMirrorStream::setIspCrop(cam_crop_rect_t camCropRect) {
  int res = CameraStream::setIspCrop(camCropRect);
  return res;
}

int CameraSubMirrorStream::setIspFocusRegions(cam_rect_t cam_regions) {
  HAL_LOG_ENTER();
  int res = -1;
  HAL_LOGV("%s not implemented "
      "x_min:%d y_min:%d x_max:%d y_max:%d",
      mStreamType.c_str(),
      cam_regions.x_min,
      cam_regions.y_min,
      cam_regions.x_max,
      cam_regions.y_max);
  return res;
}
}  // namespace v4l2_camera_hal