unplugged-system/packages/services/DeviceAsWebcam/tests/windows_webcam_test.py

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

import logging
import time

import cv2
import device

_FPS_TEST_DURATION = 10  # seconds
_DEVICE_NAME = 'android' # TODO b/277159494
_FPS_TO_TEST = [15, 30, 60]  # Since device or cv2 do not retrieve the
                            # advertised FPS, the test will use these
                            # values which are known to be supported


def initialize_device():
  """Gets the device index of the webcam to be tested.

  Returns:
      Device index of webcam
  """
  res_device_index = -1
  device_name = ''

  device_list = device.getDeviceList()
  for index, camera in enumerate(device_list):
    if _DEVICE_NAME in camera[0].lower():
      res_device_index = index
      device_name = camera[0]
      break

  if res_device_index < 0:
    logging.error('No device found')
  else:
    logging.info('Using webcam: %s', device_name)

  return res_device_index


def initialize_resolutions(device_index):
  """Gets list of supported resolutions from webcam.

  Args:
    device_index: index of device

  Returns:
      List of tuples of supported resolutions
  """
  device_list = device.getDeviceList()

  res = []
  if device_list:
    res = device_list[device_index][1]

  return res


def setup_for_test_fps(dut, supported_resolutions):
  """Sets up and runs fps testing on device.

  Args:
      dut: device under test
      supported_resolutions: supported resolutions on device to be tested

  Returns:
      List of tuples of the fps results, where the first element is the
      expected and the second element is the actual fps from testing
  """
  results = []

  for current_resolution in supported_resolutions:
    dut.set(cv2.CAP_PROP_FRAME_WIDTH, current_resolution[0])
    dut.set(cv2.CAP_PROP_FRAME_HEIGHT, current_resolution[1])

    for current_fps in _FPS_TO_TEST:
      dut.set(cv2.CAP_PROP_FPS, current_fps)

      results.append((current_fps, test_fps(dut)))

  return results


def test_fps(dut):
  """Tests fps on device.

  Args:
      dut: device under test

  Returns:
      fps calculated from test
  """
  num_frames = dut.get(cv2.CAP_PROP_FPS) * _FPS_TEST_DURATION

  start_time = time.time()
  i = num_frames
  while i > 0:
    ret = dut.read()

    if not ret:
      logging.error('Error while reading frame')
      break

    i -= 1

  end_time = time.time()

  fps = num_frames / (end_time - start_time)

  return fps


def main():
  device_index = initialize_device()

  if device_index < 0:
    logging.info('Supported device not found!')
    return []

  supported_resolutions = initialize_resolutions(device_index)

  if not supported_resolutions:
    logging.error('Error retrieving formats and resolutions')
    return []

  dut = cv2.VideoCapture(device_index, cv2.CAP_DSHOW)

  res = setup_for_test_fps(dut, supported_resolutions)

  dut.release()
  print(res)
  return res


if __name__ == '__main__':
  main()