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

#include "hal_adapter/zsl_helper.h"

#include <algorithm>
#include <cstdlib>
#include <utility>
#include <vector>

#include <base/bind.h>
#include <camera/camera_metadata.h>
#include <sync/sync.h>
#include <system/camera_metadata.h>

#include "cros-camera/common.h"

namespace cros {

ZslBuffer::ZslBuffer()
    : metadata_ready(false), buffer_ready(false), selected(false) {}
ZslBuffer::ZslBuffer(uint32_t frame_number,
                     const camera3_stream_buffer_t& buffer)
    : frame_number(frame_number),
      buffer(buffer),
      metadata_ready(false),
      buffer_ready(false),
      selected(false) {}

ZslBufferManager::ZslBufferManager()
    : initialized_(false),
      buffer_manager_(CameraBufferManager::GetInstance()) {}

ZslBufferManager::~ZslBufferManager() {
  if (free_buffers_.size() != buffer_pool_.size()) {
    LOGF(WARNING) << "Not all ZSL buffers have been released";
  }
  for (auto& buffer : buffer_pool_) {
    buffer_manager_->Free(buffer);
  }
}

bool ZslBufferManager::Initialize(size_t pool_size,
                                  camera3_stream_t* output_stream) {
  output_stream_ = output_stream;

  buffer_pool_.reserve(pool_size);
  base::AutoLock buffer_pool_lock(buffer_pool_lock_);
  for (size_t i = 0; i < pool_size; ++i) {
    uint32_t stride;
    buffer_handle_t buffer;
    if (buffer_manager_->Allocate(output_stream_->width, output_stream_->height,
                                  ZslHelper::kZslPixelFormat,
                                  GRALLOC_USAGE_HW_CAMERA_ZSL |
                                      GRALLOC_USAGE_SW_READ_OFTEN |
                                      GRALLOC_USAGE_SW_WRITE_OFTEN,
                                  cros::GRALLOC, &buffer, &stride) != 0) {
      LOGF(ERROR) << "Failed to allocate buffer";
      // Free previously-allocated buffers.
      for (auto& buffer : buffer_pool_) {
        buffer_manager_->Free(buffer);
      }
      return false;
    }
    buffer_pool_.push_back(buffer);
    free_buffers_.push(&buffer_pool_.back());
    buffer_to_buffer_pointer_map_[buffer] = &buffer_pool_.back();
  }

  initialized_ = true;
  return true;
}

buffer_handle_t* ZslBufferManager::GetBuffer() {
  base::AutoLock buffer_pool_lock(buffer_pool_lock_);
  if (!initialized_) {
    LOGF(ERROR) << "ZSL buffer manager has not been initialized";
    return nullptr;
  }
  if (free_buffers_.empty()) {
    LOGF(ERROR) << "No more buffer left in the pool. This shouldn't happen";
    return nullptr;
  }

  buffer_handle_t* buffer = free_buffers_.front();
  free_buffers_.pop();
  return buffer;
}

bool ZslBufferManager::ReleaseBuffer(buffer_handle_t buffer_to_release) {
  base::AutoLock buffer_pool_lock(buffer_pool_lock_);
  if (!initialized_) {
    LOGF(ERROR) << "ZSL buffer manager has not been initialized";
    return false;
  }
  auto it = buffer_to_buffer_pointer_map_.find(buffer_to_release);
  if (it == buffer_to_buffer_pointer_map_.end()) {
    LOGF(ERROR) << "The released buffer doesn't belong to ZSL buffer manager";
    return false;
  }
  free_buffers_.push(it->second);
  return true;
}

ZslHelper::ZslHelper(const camera_metadata_t* static_info,
                     FrameNumberMapper* mapper)
    : initialized_(false),
      enabled_(false),
      fence_sync_thread_("FenceSyncThread"),
      frame_number_mapper_(mapper) {
  VLOGF_ENTER();
  if (IsCapabilitySupported(static_info, kZslCapability)) {
    uint32_t bi_width, bi_height;
    if (SelectZslStreamSize(static_info, &bi_width, &bi_height)) {
      LOGF(INFO) << "Selected ZSL stream size: " << bi_width << "x"
                 << bi_height;
      // Create ZSL streams
      bi_stream_ = std::make_unique<camera3_stream_t>();
      memset(bi_stream_.get(), 0, sizeof(*bi_stream_.get()));
      bi_stream_->stream_type = CAMERA3_STREAM_BIDIRECTIONAL;
      bi_stream_->width = bi_width;
      bi_stream_->height = bi_height;
      bi_stream_->format = kZslPixelFormat;

      // Initialize ZSL buffer manager
      uint8_t max_pipeline_depth = [&]() {
        camera_metadata_ro_entry entry;
        if (find_camera_metadata_ro_entry(
                static_info, ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &entry) != 0) {
          LOGF(ERROR) << "ANDROID_REQUEST_PIPELINE_MAX_DEPTH is missing from "
                         "static metadata!";
          // This shouldn't happen, but assigning this a value just in case.
          return static_cast<uint8_t>(20);
        }
        return entry.data.u8[0];
      }();
      if (zsl_buffer_manager_.Initialize(kZslBufferSize + max_pipeline_depth,
                                         bi_stream_.get())) {
        initialized_ = true;
      } else {
        LOGF(ERROR) << "Failed to initialize ZSL buffer manager";
      }
    } else {
      LOGF(ERROR) << "Failed to select stream sizes for ZSL.";
    }
  } else {
    LOGF(INFO) << "Device doesn't support ZSL. ZSL won't be enabled.";
  }
  if (!fence_sync_thread_.Start()) {
    LOGF(ERROR) << "Fence sync thread failed to start";
    initialized_ = false;
  }
  partial_result_count_ = [&]() {
    camera_metadata_ro_entry entry;
    if (find_camera_metadata_ro_entry(
            static_info, ANDROID_REQUEST_PARTIAL_RESULT_COUNT, &entry) != 0) {
      return 1;
    }
    return entry.data.i32[0];
  }();
  max_num_input_streams_ = [&]() {
    camera_metadata_ro_entry_t entry;
    if (find_camera_metadata_ro_entry(
            static_info, ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, &entry) != 0) {
      LOGF(ERROR) << "Failed to get maximum number of input streams.";
      return 0;
    }
    return entry.data.i32[0];
  }();
  timestamp_source_ = [&]() {
    camera_metadata_ro_entry_t entry;
    if (find_camera_metadata_ro_entry(
            static_info, ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, &entry) != 0) {
      LOGF(ERROR) << "Failed to get timestamp source. Assuming it's UNKNOWN.";
      return ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
    }
    return static_cast<
        camera_metadata_enum_android_sensor_info_timestamp_source_t>(
        entry.data.u8[0]);
  }();
}

ZslHelper::~ZslHelper() {
  fence_sync_thread_.Stop();
}

bool ZslHelper::IsZslEnabled() {
  base::AutoLock enabled_lock(enabled_lock_);
  return enabled_;
}

void ZslHelper::SetZslEnabled(bool enabled) {
  base::AutoLock enabled_lock(enabled_lock_);
  if (enabled != enabled_) {
    LOGF(INFO) << (enabled ? "Enabling" : "Disabling") << " ZSL";
    enabled_ = enabled;
  }
}

bool ZslHelper::CanEnableZsl(const internal::ScopedStreams& streams) {
  size_t num_input_streams = 0;
  bool has_zsl_output_stream = false;
  bool has_blob_output_stream = false;
  for (auto it = streams.begin(); it != streams.end(); it++) {
    camera3_stream_t* stream = it->second.get();
    if (stream->stream_type == CAMERA3_STREAM_INPUT ||
        stream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) {
      num_input_streams++;
    }
    if (stream->stream_type == CAMERA3_STREAM_OUTPUT ||
        stream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) {
      if (stream->format == HAL_PIXEL_FORMAT_BLOB ||
          (stream->usage & GRALLOC_USAGE_STILL_CAPTURE)) {
        has_blob_output_stream = true;
      }
      if ((stream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL) ==
          GRALLOC_USAGE_HW_CAMERA_ZSL) {
        has_zsl_output_stream = true;
      }
    }
  }
  return initialized_  // Initialized means we have an allocated buffer pool.
         && has_blob_output_stream  // Has a stream for still capture.
         && num_input_streams < max_num_input_streams_  // Has room for an extra
                                                        // input stream for ZSL.
         && !has_zsl_output_stream;  // HAL doesn't support multiple raw output
                                     // streams.
}

void ZslHelper::AttachZslStream(camera3_stream_configuration_t* stream_list,
                                std::vector<camera3_stream_t*>* streams) {
  stream_list->num_streams++;
  streams->push_back(bi_stream_.get());
  // There could be memory reallocation happening after the push_back call.
  stream_list->streams = streams->data();

  for (size_t i = 0; i < stream_list->num_streams; ++i) {
    // GRALLOC_USAGE_STILL_CAPTURE is a private usage from VCD.
    // We set the usage flag here to let VCD know ZSL is enabled.
    if ((*streams)[i]->usage & GRALLOC_USAGE_STILL_CAPTURE) {
      (*streams)[i]->usage |= GRALLOC_USAGE_ZSL_ENABLED;
    }
  }

  VLOGF(1) << "Attached ZSL streams. The list of streams after attaching:";
  for (size_t i = 0; i < stream_list->num_streams; ++i) {
    VLOGF(1) << "i = " << i
             << ", type = " << stream_list->streams[i]->stream_type
             << ", size = " << stream_list->streams[i]->width << "x"
             << stream_list->streams[i]->height
             << ", format = " << stream_list->streams[i]->format;
  }
}

bool ZslHelper::IsZslRequested(camera_metadata_t* settings) {
  bool enable_zsl = [&]() {
    camera_metadata_ro_entry_t entry;
    if (find_camera_metadata_ro_entry(settings, ANDROID_CONTROL_ENABLE_ZSL,
                                      &entry) == 0) {
      return static_cast<bool>(entry.data.u8[0]);
    }
    return false;
  }();
  if (!enable_zsl) {
    return false;
  }
  // We can only enable ZSL when capture intent is also still capture.
  camera_metadata_ro_entry_t entry;
  if (find_camera_metadata_ro_entry(settings, ANDROID_CONTROL_CAPTURE_INTENT,
                                    &entry) == 0) {
    return entry.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE ||
           entry.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
  }
  return false;
}

bool ZslHelper::IsAttachedZslFrame(uint32_t frame_number) {
  base::AutoLock ring_buffer_lock(ring_buffer_lock_);
  return buffer_index_map_.find(frame_number) != buffer_index_map_.end();
}

bool ZslHelper::IsAttachedZslBuffer(const camera3_stream_buffer_t* buffer) {
  return buffer && buffer->stream == bi_stream_.get();
}

bool ZslHelper::IsTransformedZslBuffer(const camera3_stream_buffer_t* buffer) {
  return buffer && buffer->stream == bi_stream_.get();
}

void ZslHelper::ProcessZslCaptureRequest(
    uint32_t framework_frame_number,
    camera3_capture_request_t* request,  // maybe just use *input_buffer?
    std::vector<camera3_stream_buffer_t>* output_buffers,
    internal::ScopedCameraMetadata* settings,
    camera3_capture_request_t* still_request,
    std::vector<camera3_stream_buffer_t>* still_output_buffers,
    SelectionStrategy strategy) {
  if (request->input_buffer != nullptr) {
    return;
  }
  if (IsZslRequested(settings->get())) {
    for (auto it = output_buffers->begin(); it != output_buffers->end();) {
      if (it->stream->format == HAL_PIXEL_FORMAT_BLOB ||
          (it->stream->usage & GRALLOC_USAGE_STILL_CAPTURE)) {
        still_output_buffers->push_back(std::move(*it));
        it = output_buffers->erase(it);
      } else {
        it++;
      }
    }
    if (still_output_buffers->empty()) {
      LOGF(ERROR) << "ZSL is requested, but we couldn't find any still "
                     "capture output buffers.";
    } else {
      camera_metadata_t* zsl_settings;
      bool transformed =
          TransformRequest(still_request, &zsl_settings, strategy);
      if (transformed) {
        still_request->frame_number =
            frame_number_mapper_->GetHalFrameNumber(framework_frame_number);
        still_request->settings = zsl_settings;
      } else {
        // TODO(lnishan): Implement 3A stabilization mechanism so that we
        // would attempt to get a buffer in another time.
        // Merging the buffers back for now.
        LOGF(ERROR) << "Not splitting this request because we cannot find a "
                       "suitable ZSL buffer";
        for (size_t i = 0; i < still_output_buffers->size(); ++i) {
          output_buffers->push_back(std::move((*still_output_buffers)[i]));
        }
        still_output_buffers->clear();
      }
    }
    still_request->num_output_buffers = still_output_buffers->size();
    still_request->output_buffers = const_cast<const camera3_stream_buffer_t*>(
        still_output_buffers->data());
  }

  // We might end up moving all output buffers to the added request. So here we
  // unconditionally add a ZSL output buffer. We also need a placeholder request
  // so that we can defer a request if a suitable ZSL buffer is not found.
  AttachRequest(request, output_buffers);
}

void ZslHelper::AttachRequest(
    camera3_capture_request_t* request,
    std::vector<camera3_stream_buffer_t>* output_buffers) {
  VLOGF_ENTER();
  if (!enabled_) {
    LOGF(WARNING) << "Trying to attach a request when ZSL is disabled";
    return;
  }
  // Check if the oldest ZSL buffer is filled and free it if it's filled and
  // not selected for any transformed ZSL requests.
  base::AutoLock l(ring_buffer_lock_);
  if (ring_buffer_.IsFilledIndex(0)) {
    const ZslBuffer& buf = ring_buffer_.ReadBuffer(0);
    if (!buf.selected) {
      // We can free the buffer if it's not selected.
      if (!zsl_buffer_manager_.ReleaseBuffer(*buf.buffer.buffer)) {
        LOGF(ERROR) << "Unable to release the oldest buffer";
      }
    }
    // No need to remember frame-to-index mapping when this buffer is popped.
    buffer_index_map_.erase(buf.frame_number);
  }

  // Attach our ZSL output buffer.
  camera3_stream_buffer_t stream_buffer;
  stream_buffer.buffer = zsl_buffer_manager_.GetBuffer();
  stream_buffer.stream = bi_stream_.get();
  stream_buffer.acquire_fence = stream_buffer.release_fence = -1;

  buffer_index_map_[request->frame_number] = ring_buffer_.CurrentIndex();
  ZslBuffer buffer(request->frame_number, stream_buffer);
  ring_buffer_.SaveToBuffer(std::move(buffer));

  output_buffers->push_back(std::move(stream_buffer));
  request->num_output_buffers++;
}

bool ZslHelper::TransformRequest(camera3_capture_request_t* request,
                                 camera_metadata_t** settings,
                                 SelectionStrategy strategy) {
  VLOGF_ENTER();
  if (!enabled_) {
    LOGF(WARNING) << "Trying to transform a request when ZSL is disabled";
    return false;
  }

  // Select the best buffer.
  ZslBuffer* selected_buffer = SelectZslBuffer(strategy);
  if (!selected_buffer) {
    LOGF(WARNING) << "Unable to find a suitable ZSL buffer. Request will not "
                     "be transformed.";
    return false;
  }

  LOGF(INFO) << "Transforming request into ZSL reprocessing request";
  base::AutoLock ring_buffer_lock(ring_buffer_lock_);
  request->input_buffer = &selected_buffer->buffer;
  request->input_buffer->stream = bi_stream_.get();
  request->input_buffer->acquire_fence = -1;
  request->input_buffer->release_fence = -1;

  // Note that camera device adapter would take ownership of this pointer.
  *settings = selected_buffer->metadata.release();
  return true;
}

void ZslHelper::ProcessZslCaptureResult(
    const camera3_capture_result_t* result,
    const camera3_stream_buffer_t** attached_output,
    const camera3_stream_buffer_t** transformed_input) {
  VLOGF_ENTER();
  for (size_t i = 0; i < result->num_output_buffers; ++i) {
    if (IsAttachedZslBuffer(&result->output_buffers[i])) {
      *attached_output = &result->output_buffers[i];
      break;
    }
  }
  if (result->input_buffer && IsTransformedZslBuffer(result->input_buffer)) {
    *transformed_input = result->input_buffer;
    ReleaseStreamBuffer(*result->input_buffer);
  }
  if (IsAttachedZslFrame(result->frame_number)) {
    base::AutoLock ring_buffer_lock(ring_buffer_lock_);
    auto it = buffer_index_map_.find(result->frame_number);
    if (it != buffer_index_map_.end()) {
      ZslBuffer* buffer = MutableReadBufferByBufferIndex(it->second);

      for (size_t i = 0; i < result->num_output_buffers; ++i) {
        if (result->output_buffers[i].stream == bi_stream_.get()) {
          WaitAttachedFrame(result->frame_number,
                            result->output_buffers[i].release_fence);
          break;
        }
      }

      if (result->partial_result != 0) {  // Result has metadata
        // Merge the result metadata.
        if (buffer) {
          buffer->metadata.append(result->result);
          if (result->partial_result == partial_result_count_) {
            buffer->metadata_ready = true;
          }
        }
      }
    }
  }
}

void ZslHelper::WaitAttachedFrame(uint32_t frame_number, int release_fence) {
  fence_sync_thread_.task_runner()->PostTask(
      FROM_HERE,
      base::Bind(&ZslHelper::WaitAttachedFrameOnFenceSyncThread,
                 base::Unretained(this), frame_number, release_fence));
}

void ZslHelper::WaitAttachedFrameOnFenceSyncThread(uint32_t frame_number,
                                                   int release_fence) {
  if (release_fence != -1 &&
      sync_wait(release_fence, ZslHelper::kZslSyncWaitTimeoutMs)) {
    LOGF(WARNING) << "Failed to wait for release fence on attached ZSL buffer";
  } else {
    base::AutoLock ring_buffer_lock(ring_buffer_lock_);
    auto it = buffer_index_map_.find(frame_number);
    if (it != buffer_index_map_.end()) {
      ZslBuffer* buffer = MutableReadBufferByBufferIndex(it->second);
      if (buffer) {
        buffer->buffer_ready = true;
      }
    }
    return;
  }
  fence_sync_thread_.task_runner()->PostTask(
      FROM_HERE,
      base::Bind(&ZslHelper::WaitAttachedFrameOnFenceSyncThread,
                 base::Unretained(this), frame_number, release_fence));
}

void ZslHelper::ReleaseStreamBuffer(camera3_stream_buffer_t buffer) {
  fence_sync_thread_.task_runner()->PostTask(
      FROM_HERE, base::Bind(&ZslHelper::ReleaseStreamBufferOnFenceSyncThread,
                            base::Unretained(this), base::Passed(&buffer)));
}

void ZslHelper::ReleaseStreamBufferOnFenceSyncThread(
    camera3_stream_buffer_t buffer) {
  if (buffer.release_fence != -1 &&
      sync_wait(buffer.release_fence, ZslHelper::kZslSyncWaitTimeoutMs)) {
    LOGF(WARNING) << "Failed to wait for release fence on ZSL input buffer";
  } else {
    if (!zsl_buffer_manager_.ReleaseBuffer(*buffer.buffer)) {
      LOGF(ERROR) << "Failed to release this stream buffer";
    }
    // The above error should only happen when the mapping in buffer manager
    // becomes invalid somwhow. It's not recoverable, so we don't retry here.
    return;
  }
  fence_sync_thread_.task_runner()->PostTask(
      FROM_HERE, base::Bind(&ZslHelper::ReleaseStreamBufferOnFenceSyncThread,
                            base::Unretained(this), base::Passed(&buffer)));
}

bool ZslHelper::IsCapabilitySupported(const camera_metadata_t* static_info,
                                      uint8_t capability) {
  camera_metadata_ro_entry_t entry;
  if (find_camera_metadata_ro_entry(
          static_info, ANDROID_REQUEST_AVAILABLE_CAPABILITIES, &entry) == 0) {
    return std::find(entry.data.u8, entry.data.u8 + entry.count, capability) !=
           entry.data.u8 + entry.count;
  }
  return false;
}

bool ZslHelper::SelectZslStreamSize(const camera_metadata_t* static_info,
                                    uint32_t* bi_width,
                                    uint32_t* bi_height) {
  VLOGF_ENTER();
  camera_metadata_ro_entry entry;
  if (find_camera_metadata_ro_entry(
          static_info, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
          &entry) != 0) {
    LOGF(ERROR) << "Failed to find stream configurations map";
    return false;
  }
  *bi_width = 0;
  *bi_height = 0;

  VLOGF(1) << "Iterating stream configuration map for ZSL streams";
  for (size_t i = 0; i < entry.count; i += 4) {
    const int32_t& format = entry.data.i32[i + STREAM_CONFIG_FORMAT_INDEX];
    if (format != kZslPixelFormat)
      continue;
    const int32_t& width = entry.data.i32[i + STREAM_CONFIG_WIDTH_INDEX];
    const int32_t& height = entry.data.i32[i + STREAM_CONFIG_HEIGHT_INDEX];
    const int32_t& direction =
        entry.data.i32[i + STREAM_CONFIG_DIRECTION_INDEX];
    VLOGF(1) << "format = " << format << ", "
             << "width = " << width << ", "
             << "height = " << height << ", "
             << "direction = " << direction;
    if (direction == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
      if (width * height > (*bi_width) * (*bi_height)) {
        *bi_width = width;
        *bi_height = height;
      }
    }
  }
  return *bi_width > 0 && *bi_height > 0;
}

ZslBuffer* ZslHelper::SelectZslBuffer(SelectionStrategy strategy) {
  // Select the best ZSL buffer based on time and statistics.
  auto GetTimestamp = [](const android::CameraMetadata& android_metadata) {
    camera_metadata_ro_entry_t entry;
    if (android_metadata.exists(ANDROID_SENSOR_TIMESTAMP)) {
      entry = android_metadata.find(ANDROID_SENSOR_TIMESTAMP);
      return entry.data.i64[0];
    }
    LOGF(ERROR) << "Cannot find sensor timestamp in ZSL buffer";
    return static_cast<int64_t>(-1);
  };
  base::AutoLock ring_buffer_lock(ring_buffer_lock_);
  if (strategy == LAST_SUBMITTED) {
    for (int i = kZslBufferSize - 1; i >= 0; --i) {
      if (!ring_buffer_.IsFilledIndex(i)) {
        continue;
      }
      ZslBuffer* buffer = ring_buffer_.MutableReadBuffer(i);
      if (buffer->metadata_ready && buffer->buffer_ready && !buffer->selected) {
        buffer->selected = true;
        return buffer;
      }
    }
    LOGF(WARNING) << "Failed to find a unselected submitted ZSL buffer";
    return nullptr;
  }

  // For CLOSEST or CLOSEST_3A strategies.
  int64_t cur_timestamp = GetCurrentTimestamp();
  LOGF(INFO) << "Current timestamp = " << cur_timestamp;
  ZslBuffer* selected_buffer = nullptr;
  int64_t min_diff = kZslLookbackNs;
  int64_t ideal_timestamp = cur_timestamp - kZslLookbackNs;
  for (int i = kZslBufferSize - 1; i >= 0; --i) {
    if (!ring_buffer_.IsFilledIndex(i)) {
      continue;
    }
    ZslBuffer* buffer = ring_buffer_.MutableReadBuffer(i);
    if (!buffer->metadata_ready || !buffer->buffer_ready || buffer->selected) {
      continue;
    }
    int64_t timestamp = GetTimestamp(buffer->metadata);
    bool satisfy_3a = strategy == CLOSEST || (strategy == CLOSEST_3A &&
                                              Is3AConverged(buffer->metadata));
    int64_t diff = timestamp - ideal_timestamp;
    VLOGF(1) << "Candidate timestamp = " << timestamp
             << " (Satisfy 3A = " << satisfy_3a << ", "
             << "Difference from desired timestamp = " << diff << ")";
    if (diff > kZslLookbackLengthNs) {
      continue;
    } else if (diff < 0) {
      // We don't select buffers that are older than what is displayed.
      break;
    }
    if (satisfy_3a) {
      if (diff < min_diff) {
        min_diff = diff;
        selected_buffer = buffer;
      } else {
        // Not possible to find a better buffer
        break;
      }
    }
  }
  if (selected_buffer == nullptr) {
    LOGF(WARNING)
        << "Failed to a find suitable ZSL buffer with the given strategy";
    return nullptr;
  }
  LOGF(INFO) << "Timestamp of the selected buffer = "
             << GetTimestamp(selected_buffer->metadata);
  selected_buffer->selected = true;
  return selected_buffer;
}

int64_t ZslHelper::GetCurrentTimestamp() {
  struct timespec t = {};
  clock_gettime(
      timestamp_source_ == ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN
          ? CLOCK_MONOTONIC
          : CLOCK_BOOTTIME /* ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME */,
      &t);
  return static_cast<int64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec;
}

bool ZslHelper::Is3AConverged(const android::CameraMetadata& android_metadata) {
  auto GetState = [&](size_t tag) {
    camera_metadata_ro_entry_t entry;
    if (android_metadata.exists(tag)) {
      entry = android_metadata.find(tag);
      return entry.data.u8[0];
    }
    LOGF(ERROR) << "Cannot find the metadata for "
                << get_camera_metadata_tag_name(tag);
    return static_cast<uint8_t>(0);
  };
  uint8_t ae_mode = GetState(ANDROID_CONTROL_AE_MODE);
  uint8_t ae_state = GetState(ANDROID_CONTROL_AE_STATE);
  bool ae_converged = [&]() {
    if (ae_mode != ANDROID_CONTROL_AE_MODE_OFF) {
      if (ae_state != ANDROID_CONTROL_AE_STATE_CONVERGED &&
          ae_state != ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED &&
          ae_state != ANDROID_CONTROL_AE_STATE_LOCKED) {
        return false;
      }
    }
    return true;
  }();
  if (!ae_converged) {
    return false;
  }
  uint8_t af_mode = GetState(ANDROID_CONTROL_AF_MODE);
  uint8_t af_state = GetState(ANDROID_CONTROL_AF_STATE);
  bool af_converged = [&]() {
    if (af_mode != ANDROID_CONTROL_AF_MODE_OFF) {
      if (af_state != ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED &&
          af_state != ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED) {
        return false;
      }
    }
    return true;
  }();
  if (!af_converged) {
    return false;
  }
  uint8_t awb_mode = GetState(ANDROID_CONTROL_AWB_MODE);
  uint8_t awb_state = GetState(ANDROID_CONTROL_AWB_STATE);
  bool awb_converged = [&]() {
    if (awb_mode != ANDROID_CONTROL_AWB_MODE_OFF) {
      if (awb_state != ANDROID_CONTROL_AWB_STATE_CONVERGED &&
          awb_state != ANDROID_CONTROL_AWB_STATE_LOCKED) {
        return false;
      }
    }
    return true;
  }();
  // We won't reach here if neither AE nor AF is converged.
  return awb_converged;
}

ZslBuffer* ZslHelper::MutableReadBufferByBufferIndex(size_t buffer_index) {
  size_t current_index = ring_buffer_.CurrentIndex();
  DCHECK(current_index > buffer_index);
  // The DCHECK fails if the caller is attempting to update a buffer that's no
  // longer in the ring buffer. This means a capture result is returned after
  // |kZslBufferSize| frames, which shouldn't happen and likely indicates
  // something is wrong.
  DCHECK(current_index - buffer_index <= ZslHelper::kZslBufferSize);
  if (current_index - buffer_index <= ZslHelper::kZslBufferSize) {
    size_t rel_index =
        ZslHelper::kZslBufferSize - (current_index - buffer_index);
    return ring_buffer_.MutableReadBuffer(rel_index);
  }
  return nullptr;
}

}  // namespace cros