RaspiCamControl.cpp

Go to the documentation of this file.

/*
Copyright (c) 2013, Broadcom Europe Ltd
Copyright (c) 2013, James Hughes
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the copyright holder nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#if defined(__arm__) || defined(__aarch64__)

#include <memory.h>
#include <stdio.h>

#include "interface/vcos/vcos.h"

#include "RaspiCamControl.h"
#include "interface/mmal/mmal.h"
#include "interface/mmal/mmal_logging.h"
#include "interface/mmal/util/mmal_default_components.h"
#include "interface/mmal/util/mmal_util.h"
#include "interface/mmal/util/mmal_util_params.h"
#include "interface/vmcs_host/vc_vchi_gencmd.h"

typedef struct xref_t {
  char const* mode;
  int mmal_mode;
} XREF_T;

static XREF_T exposure_map[] = { { "off", MMAL_PARAM_EXPOSUREMODE_OFF },
                                 { "auto", MMAL_PARAM_EXPOSUREMODE_AUTO },
                                 { "night", MMAL_PARAM_EXPOSUREMODE_NIGHT },
                                 { "nightpreview", MMAL_PARAM_EXPOSUREMODE_NIGHTPREVIEW },
                                 { "backlight", MMAL_PARAM_EXPOSUREMODE_BACKLIGHT },
                                 { "spotlight", MMAL_PARAM_EXPOSUREMODE_SPOTLIGHT },
                                 { "sports", MMAL_PARAM_EXPOSUREMODE_SPORTS },
                                 { "snow", MMAL_PARAM_EXPOSUREMODE_SNOW },
                                 { "beach", MMAL_PARAM_EXPOSUREMODE_BEACH },
                                 { "verylong", MMAL_PARAM_EXPOSUREMODE_VERYLONG },
                                 { "fixedfps", MMAL_PARAM_EXPOSUREMODE_FIXEDFPS },
                                 { "antishake", MMAL_PARAM_EXPOSUREMODE_ANTISHAKE },
                                 { "fireworks", MMAL_PARAM_EXPOSUREMODE_FIREWORKS } };

static const int exposure_map_size = sizeof(exposure_map) / sizeof(exposure_map[0]);

static XREF_T awb_map[] = { { "off", MMAL_PARAM_AWBMODE_OFF },
                            { "auto", MMAL_PARAM_AWBMODE_AUTO },
                            { "sun", MMAL_PARAM_AWBMODE_SUNLIGHT },
                            { "cloud", MMAL_PARAM_AWBMODE_CLOUDY },
                            { "shade", MMAL_PARAM_AWBMODE_SHADE },
                            { "tungsten", MMAL_PARAM_AWBMODE_TUNGSTEN },
                            { "fluorescent", MMAL_PARAM_AWBMODE_FLUORESCENT },
                            { "incandescent", MMAL_PARAM_AWBMODE_INCANDESCENT },
                            { "flash", MMAL_PARAM_AWBMODE_FLASH },
                            { "horizon", MMAL_PARAM_AWBMODE_HORIZON } };

static const int awb_map_size = sizeof(awb_map) / sizeof(awb_map[0]);

static XREF_T imagefx_map[] = { { "none", MMAL_PARAM_IMAGEFX_NONE },
                                { "negative", MMAL_PARAM_IMAGEFX_NEGATIVE },
                                { "solarise", MMAL_PARAM_IMAGEFX_SOLARIZE },
                                { "sketch", MMAL_PARAM_IMAGEFX_SKETCH },
                                { "denoise", MMAL_PARAM_IMAGEFX_DENOISE },
                                { "emboss", MMAL_PARAM_IMAGEFX_EMBOSS },
                                { "oilpaint", MMAL_PARAM_IMAGEFX_OILPAINT },
                                { "hatch", MMAL_PARAM_IMAGEFX_HATCH },
                                { "gpen", MMAL_PARAM_IMAGEFX_GPEN },
                                { "pastel", MMAL_PARAM_IMAGEFX_PASTEL },
                                { "watercolour", MMAL_PARAM_IMAGEFX_WATERCOLOUR },
                                { "film", MMAL_PARAM_IMAGEFX_FILM },
                                { "blur", MMAL_PARAM_IMAGEFX_BLUR },
                                { "saturation", MMAL_PARAM_IMAGEFX_SATURATION },
                                { "colourswap", MMAL_PARAM_IMAGEFX_COLOURSWAP },
                                { "washedout", MMAL_PARAM_IMAGEFX_WASHEDOUT },
                                { "posterise", MMAL_PARAM_IMAGEFX_POSTERISE },
                                { "colourpoint", MMAL_PARAM_IMAGEFX_COLOURPOINT },
                                { "colourbalance", MMAL_PARAM_IMAGEFX_COLOURBALANCE },
                                { "cartoon", MMAL_PARAM_IMAGEFX_CARTOON } };

static const int imagefx_map_size = sizeof(imagefx_map) / sizeof(imagefx_map[0]);

static XREF_T metering_mode_map[] = { { "average", MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE },
                                      { "spot", MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT },
                                      { "backlit", MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT },
                                      { "matrix", MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX } };

static const int metering_mode_map_size = sizeof(metering_mode_map) / sizeof(metering_mode_map[0]);

#define CommandSharpness 0
#define CommandContrast 1
#define CommandBrightness 2
#define CommandSaturation 3
#define CommandISO 4
#define CommandVideoStab 5
#define CommandEVComp 6
#define CommandExposure 7
#define CommandAWB 8
#define CommandImageFX 9
#define CommandColourFX 10
#define CommandMeterMode 11
#define CommandRotation 12
#define CommandHFlip 13
#define CommandVFlip 14
#define CommandROI 15

#define parameter_reset -99999

static int update_cycle_parameter(int* option, int min, int max, int increment) {
  vcos_assert(option);
  if (!option)
    return 0;

  if (*option == parameter_reset)
    *option = min - increment;

  *option += increment;

  if (*option > max) {
    *option = parameter_reset;
    return 0;
  } else
    return 1;
}

int raspicamcontrol_cycle_test(MMAL_COMPONENT_T& camera) {
  static int parameter = 0;
  static int parameter_option = parameter_reset;  // which value the parameter currently has

  // We are going to cycle through all the relevant entries in the parameter
  // block and send options to the camera.
  if (parameter == 0) {
    // sharpness
    if (update_cycle_parameter(&parameter_option, -100, 100, 10))
      raspicamcontrol_set_sharpness(camera, parameter_option);
    else {
      raspicamcontrol_set_sharpness(camera, 0);
      parameter++;
    }
  } else if (parameter == 1) {
    // contrast
    if (update_cycle_parameter(&parameter_option, -100, 100, 10))
      raspicamcontrol_set_contrast(camera, parameter_option);
    else {
      raspicamcontrol_set_contrast(camera, 0);
      parameter++;
    }
  } else if (parameter == 2) {
    // brightness
    if (update_cycle_parameter(&parameter_option, 0, 100, 10))
      raspicamcontrol_set_brightness(camera, parameter_option);
    else {
      raspicamcontrol_set_brightness(camera, 50);
      parameter++;
    }
  } else if (parameter == 3) {
    // contrast
    if (update_cycle_parameter(&parameter_option, -100, 100, 10))
      raspicamcontrol_set_saturation(camera, parameter_option);
    else {
      parameter++;
      raspicamcontrol_set_saturation(camera, 0);
    }
  } else if (parameter == 4) {
    // EV
    if (update_cycle_parameter(&parameter_option, -10, 10, 4))
      raspicamcontrol_set_exposure_compensation(camera, parameter_option);
    else {
      raspicamcontrol_set_exposure_compensation(camera, 0);
      parameter++;
    }
  } else if (parameter == 5) {
    // MMAL_PARAM_EXPOSUREMODE_T
    if (update_cycle_parameter(&parameter_option, 0, exposure_map_size, 1))
      raspicamcontrol_set_exposure_mode(camera, (MMAL_PARAM_EXPOSUREMODE_T)exposure_map[parameter_option].mmal_mode);
    else {
      raspicamcontrol_set_exposure_mode(camera, MMAL_PARAM_EXPOSUREMODE_AUTO);
      parameter++;
    }
  } else if (parameter == 6) {
    // MMAL_PARAM_AWB_T
    if (update_cycle_parameter(&parameter_option, 0, awb_map_size, 1))
      raspicamcontrol_set_awb_mode(camera, (MMAL_PARAM_AWBMODE_T)awb_map[parameter_option].mmal_mode);
    else {
      raspicamcontrol_set_awb_mode(camera, MMAL_PARAM_AWBMODE_AUTO);
      parameter++;
    }
  }
  if (parameter == 7) {
    // MMAL_PARAM_IMAGEFX_T
    if (update_cycle_parameter(&parameter_option, 0, imagefx_map_size, 1))
      raspicamcontrol_set_imageFX(camera, (MMAL_PARAM_IMAGEFX_T)imagefx_map[parameter_option].mmal_mode);
    else {
      raspicamcontrol_set_imageFX(camera, MMAL_PARAM_IMAGEFX_NONE);
      parameter++;
    }
  }
  if (parameter == 8) {
    MMAL_PARAM_COLOURFX_T colfx = { 0, 0, 0 };
    switch (parameter_option) {
      case parameter_reset:
        parameter_option = 1;
        colfx.u = 128;
        colfx.v = 128;
        break;
      case 1:
        parameter_option = 2;
        colfx.u = 100;
        colfx.v = 200;
        break;
      case 2:
        parameter_option = parameter_reset;
        colfx.enable = 0;
        parameter++;
        break;
    }
    raspicamcontrol_set_colourFX(camera, &colfx);
  }

  // Orientation
  if (parameter == 9) {
    switch (parameter_option) {
      case parameter_reset:
        raspicamcontrol_set_rotation(camera, 90);
        parameter_option = 1;
        break;

      case 1:
        raspicamcontrol_set_rotation(camera, 180);
        parameter_option = 2;
        break;

      case 2:
        raspicamcontrol_set_rotation(camera, 270);
        parameter_option = 3;
        break;

      case 3: {
        raspicamcontrol_set_rotation(camera, 0);
        raspicamcontrol_set_flips(camera, 1, 0);
        parameter_option = 4;
        break;
      }
      case 4: {
        raspicamcontrol_set_flips(camera, 0, 1);
        parameter_option = 5;
        break;
      }
      case 5: {
        raspicamcontrol_set_flips(camera, 1, 1);
        parameter_option = 6;
        break;
      }
      case 6: {
        raspicamcontrol_set_flips(camera, 0, 0);
        parameter_option = parameter_reset;
        parameter++;
        break;
      }
    }
  }

  if (parameter == 10) {
    parameter = 1;
    return 0;
  }

  return 1;
}

static int map_xref(const char* str, const XREF_T* map, int num_refs) {
  int i;

  for (i = 0; i < num_refs; i++) {
    if (!strcasecmp(str, map[i].mode)) {
      return map[i].mmal_mode;
    }
  }
  return -1;
}

static const char* unmap_xref(const int en, XREF_T* map, int num_refs) {
  int i;

  for (i = 0; i < num_refs; i++) {
    if (en == map[i].mmal_mode) {
      return map[i].mode;
    }
  }
  return NULL;
}

/*static*/ MMAL_PARAM_EXPOSUREMODE_T exposure_mode_from_string(const char* str) {
  int i = map_xref(str, exposure_map, exposure_map_size);

  if (i != -1)
    return (MMAL_PARAM_EXPOSUREMODE_T)i;

  vcos_log_error("Unknown exposure mode: %s", str);
  return MMAL_PARAM_EXPOSUREMODE_AUTO;
}

MMAL_PARAM_AWBMODE_T awb_mode_from_string(const char* str) {
  int i = map_xref(str, awb_map, awb_map_size);

  if (i != -1)
    return (MMAL_PARAM_AWBMODE_T)i;

  vcos_log_error("Unknown awb mode: %s", str);
  return MMAL_PARAM_AWBMODE_AUTO;
}

MMAL_PARAM_IMAGEFX_T imagefx_mode_from_string(const char* str) {
  int i = map_xref(str, imagefx_map, imagefx_map_size);

  if (i != -1)
    return (MMAL_PARAM_IMAGEFX_T)i;

  vcos_log_error("Unknown image fx: %s", str);
  return MMAL_PARAM_IMAGEFX_NONE;
}

MMAL_PARAM_EXPOSUREMETERINGMODE_T metering_mode_from_string(const char* str) {
  int i = map_xref(str, metering_mode_map, metering_mode_map_size);

  if (i != -1)
    return (MMAL_PARAM_EXPOSUREMETERINGMODE_T)i;

  vcos_log_error("Unknown metering mode: %s", str);
  return MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
}

void raspicamcontrol_dump_parameters(const RASPICAM_CAMERA_PARAMETERS& params) {
  const char* exp_mode = unmap_xref(params.exposureMode, exposure_map, exposure_map_size);
  const char* awb_mode = unmap_xref(params.awbMode, awb_map, awb_map_size);
  const char* image_effect = unmap_xref(params.imageEffect, imagefx_map, imagefx_map_size);
  const char* metering_mode = unmap_xref(params.exposureMeterMode, metering_mode_map, metering_mode_map_size);

  fprintf(stderr, "Sharpness %d, Contrast %d, Brightness %d\n", params.sharpness, params.contrast, params.brightness);
  fprintf(stderr, "Saturation %d, ISO %d, Video Stabilisation %s, Exposure "
                  "compensation %d\n",
          params.saturation, params.ISO, params.videoStabilisation ? "Yes" : "No", params.exposureCompensation);
  fprintf(stderr, "Exposure Mode '%s', AWB Mode '%s', Image Effect '%s'\n", exp_mode, awb_mode, image_effect);
  fprintf(stderr, "Metering Mode '%s', Colour Effect Enabled %s with U = %d, V = %d\n", metering_mode,
          params.colourEffects.enable ? "Yes" : "No", params.colourEffects.u, params.colourEffects.v);
  fprintf(stderr, "Rotation %d, hflip %s, vflip %s\n", params.rotation, params.hflip ? "Yes" : "No",
          params.vflip ? "Yes" : "No");
  fprintf(stderr, "ROI x %lf, y %f, w %f h %f\n", params.roi.x, params.roi.y, params.roi.w, params.roi.h);
}

int mmal_status_to_int(MMAL_STATUS_T status) {
  if (status == MMAL_SUCCESS)
    return 0;
  else {
    switch (status) {
      case MMAL_ENOMEM:
        vcos_log_error("Out of memory");
        break;
      case MMAL_ENOSPC:
        vcos_log_error("Out of resources (other than memory)");
        break;
      case MMAL_EINVAL:
        vcos_log_error("Argument is invalid");
        break;
      case MMAL_ENOSYS:
        vcos_log_error("Function not implemented");
        break;
      case MMAL_ENOENT:
        vcos_log_error("No such file or directory");
        break;
      case MMAL_ENXIO:
        vcos_log_error("No such device or address");
        break;
      case MMAL_EIO:
        vcos_log_error("I/O error");
        break;
      case MMAL_ESPIPE:
        vcos_log_error("Illegal seek");
        break;
      case MMAL_ECORRUPT:
        vcos_log_error("Data is corrupt \attention FIXME: not POSIX");
        break;
      case MMAL_ENOTREADY:
        vcos_log_error("Component is not ready \attention FIXME: not POSIX");
        break;
      case MMAL_ECONFIG:
        vcos_log_error("Component is not configured \attention FIXME: not POSIX");
        break;
      case MMAL_EISCONN:
        vcos_log_error("Port is already connected ");
        break;
      case MMAL_ENOTCONN:
        vcos_log_error("Port is disconnected");
        break;
      case MMAL_EAGAIN:
        vcos_log_error("Resource temporarily unavailable. Try again later");
        break;
      case MMAL_EFAULT:
        vcos_log_error("Bad address");
        break;
      default:
        vcos_log_error("Unknown status error");
        break;
    }

    return 1;
  }
}

void raspicamcontrol_set_defaults(RASPICAM_CAMERA_PARAMETERS& params) {
  params.sharpness = 0;
  params.contrast = 0;
  params.brightness = 50;
  params.saturation = 0;
  params.ISO = 400;
  params.videoStabilisation = 0;
  params.exposureCompensation = 0;
  params.exposureMode = MMAL_PARAM_EXPOSUREMODE_AUTO;
  params.exposureMeterMode = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
  params.awbMode = MMAL_PARAM_AWBMODE_AUTO;
  // params.imageEffect = MMAL_PARAM_IMAGEFX_SATURATION;
  params.imageEffect = MMAL_PARAM_IMAGEFX_NONE;
  params.colourEffects.enable = 0;
  params.colourEffects.u = 128;
  params.colourEffects.v = 128;
  params.rotation = 0;
  params.hflip = params.vflip = 0;
  params.roi.x = params.roi.y = 0.0;
  params.roi.w = params.roi.h = 1.0;
  params.shutter_speed = 0;  // automatic
}

int raspicamcontrol_set_all_parameters(MMAL_COMPONENT_T& camera, const RASPICAM_CAMERA_PARAMETERS& params) {
  int result;

  result = raspicamcontrol_set_saturation(camera, params.saturation);
  result += raspicamcontrol_set_sharpness(camera, params.sharpness);
  result += raspicamcontrol_set_contrast(camera, params.contrast);
  result += raspicamcontrol_set_brightness(camera, params.brightness);
  result += raspicamcontrol_set_ISO(camera, params.ISO);
  result += raspicamcontrol_set_video_stabilisation(camera, params.videoStabilisation);
  result += raspicamcontrol_set_exposure_compensation(camera, params.exposureCompensation);
  result += raspicamcontrol_set_exposure_mode(camera, params.exposureMode);
  result += raspicamcontrol_set_metering_mode(camera, params.exposureMeterMode);
  result += raspicamcontrol_set_awb_mode(camera, params.awbMode);
  result += raspicamcontrol_set_imageFX(camera, params.imageEffect);
  result += raspicamcontrol_set_colourFX(camera, &params.colourEffects);
  // result += raspicamcontrol_set_thumbnail_parameters(camera,
  // &params.thumbnailConfig);  TODO Not working for some reason
  result += raspicamcontrol_set_rotation(camera, params.rotation);
  result += raspicamcontrol_set_flips(camera, params.hflip, params.vflip);
  result += raspicamcontrol_set_ROI(camera, params.roi);
  result += raspicamcontrol_set_shutter_speed(camera, params.shutter_speed);
  return result;
}

int raspicamcontrol_set_saturation(MMAL_COMPONENT_T& camera, int saturation) {
  int ret = 0;

  if (saturation >= -100 && saturation <= 100) {
    MMAL_RATIONAL_T value = { saturation, 100 };
    ret = mmal_status_to_int(mmal_port_parameter_set_rational(camera.control, MMAL_PARAMETER_SATURATION, value));
  } else {
    vcos_log_error("Invalid saturation value");
    ret = 1;
  }

  return ret;
}

int raspicamcontrol_set_sharpness(MMAL_COMPONENT_T& camera, int sharpness) {
  int ret = 0;

  if (sharpness >= -100 && sharpness <= 100) {
    MMAL_RATIONAL_T value = { sharpness, 100 };
    ret = mmal_status_to_int(mmal_port_parameter_set_rational(camera.control, MMAL_PARAMETER_SHARPNESS, value));
  } else {
    vcos_log_error("Invalid sharpness value");
    ret = 1;
  }

  return ret;
}

int raspicamcontrol_set_contrast(MMAL_COMPONENT_T& camera, int contrast) {
  int ret = 0;

  if (contrast >= -100 && contrast <= 100) {
    MMAL_RATIONAL_T value = { contrast, 100 };
    ret = mmal_status_to_int(mmal_port_parameter_set_rational(camera.control, MMAL_PARAMETER_CONTRAST, value));
  } else {
    vcos_log_error("Invalid contrast value");
    ret = 1;
  }

  return ret;
}

int raspicamcontrol_set_brightness(MMAL_COMPONENT_T& camera, int brightness) {
  int ret = 0;

  if (brightness >= 0 && brightness <= 100) {
    MMAL_RATIONAL_T value = { brightness, 100 };
    ret = mmal_status_to_int(mmal_port_parameter_set_rational(camera.control, MMAL_PARAMETER_BRIGHTNESS, value));
  } else {
    vcos_log_error("Invalid brightness value");
    ret = 1;
  }

  return ret;
}

int raspicamcontrol_set_ISO(MMAL_COMPONENT_T& camera, int ISO) {
  return mmal_status_to_int(mmal_port_parameter_set_uint32(camera.control, MMAL_PARAMETER_ISO, ISO));
}

int raspicamcontrol_set_metering_mode(MMAL_COMPONENT_T& camera, MMAL_PARAM_EXPOSUREMETERINGMODE_T m_mode) {
  MMAL_PARAMETER_EXPOSUREMETERINGMODE_T meter_mode = { { MMAL_PARAMETER_EXP_METERING_MODE, sizeof(meter_mode) },
                                                       m_mode };

  return mmal_status_to_int(mmal_port_parameter_set(camera.control, &meter_mode.hdr));
}

int raspicamcontrol_set_video_stabilisation(MMAL_COMPONENT_T& camera, int vstabilisation) {
  return mmal_status_to_int(
      mmal_port_parameter_set_boolean(camera.control, MMAL_PARAMETER_VIDEO_STABILISATION, vstabilisation));
}

int raspicamcontrol_set_exposure_compensation(MMAL_COMPONENT_T& camera, int exp_comp) {
  return mmal_status_to_int(mmal_port_parameter_set_int32(camera.control, MMAL_PARAMETER_EXPOSURE_COMP, exp_comp));
}

int raspicamcontrol_set_exposure_mode(MMAL_COMPONENT_T& camera, MMAL_PARAM_EXPOSUREMODE_T mode) {
  MMAL_PARAMETER_EXPOSUREMODE_T exp_mode = { { MMAL_PARAMETER_EXPOSURE_MODE, sizeof(exp_mode) }, mode };

  return mmal_status_to_int(mmal_port_parameter_set(camera.control, &exp_mode.hdr));
}

int raspicamcontrol_set_awb_mode(MMAL_COMPONENT_T& camera, MMAL_PARAM_AWBMODE_T awb_mode) {
  MMAL_PARAMETER_AWBMODE_T param = { { MMAL_PARAMETER_AWB_MODE, sizeof(param) }, awb_mode };

  return mmal_status_to_int(mmal_port_parameter_set(camera.control, &param.hdr));
}

int raspicamcontrol_set_imageFX(MMAL_COMPONENT_T& camera, MMAL_PARAM_IMAGEFX_T imageFX) {
  MMAL_PARAMETER_IMAGEFX_T imgFX = { { MMAL_PARAMETER_IMAGE_EFFECT, sizeof(imgFX) }, imageFX };

  return mmal_status_to_int(mmal_port_parameter_set(camera.control, &imgFX.hdr));
}

/* TODO :what to do with the image effects parameters?
   MMAL_PARAMETER_IMAGEFX_PARAMETERS_T imfx_param =
{{MMAL_PARAMETER_IMAGE_EFFECT_PARAMETERS,sizeof(imfx_param)}, imageFX, 0, {0}};
mmal_port_parameter_set(camera.control, &imfx_param.hdr);
                             */

int raspicamcontrol_set_colourFX(MMAL_COMPONENT_T& camera, const MMAL_PARAM_COLOURFX_T* colourFX) {
  MMAL_PARAMETER_COLOURFX_T colfx = { { MMAL_PARAMETER_COLOUR_EFFECT, sizeof(colfx) }, 0, 0, 0 };

  colfx.enable = colourFX->enable;
  colfx.u = colourFX->u;
  colfx.v = colourFX->v;

  return mmal_status_to_int(mmal_port_parameter_set(camera.control, &colfx.hdr));
}

int raspicamcontrol_set_rotation(MMAL_COMPONENT_T& camera, int rotation) {
  int ret;
  int my_rotation = ((rotation % 360) / 90) * 90;

  ret = mmal_port_parameter_set_int32(camera.output[0], MMAL_PARAMETER_ROTATION, my_rotation);
  mmal_port_parameter_set_int32(camera.output[1], MMAL_PARAMETER_ROTATION, my_rotation);
  mmal_port_parameter_set_int32(camera.output[2], MMAL_PARAMETER_ROTATION, my_rotation);

  return ret;
}

int raspicamcontrol_set_flips(MMAL_COMPONENT_T& camera, int hflip, int vflip) {
  MMAL_PARAMETER_MIRROR_T mirror = { { MMAL_PARAMETER_MIRROR, sizeof(MMAL_PARAMETER_MIRROR_T) },
                                     MMAL_PARAM_MIRROR_NONE };

  if (hflip && vflip)
    mirror.value = MMAL_PARAM_MIRROR_BOTH;
  else if (hflip)
    mirror.value = MMAL_PARAM_MIRROR_HORIZONTAL;
  else if (vflip)
    mirror.value = MMAL_PARAM_MIRROR_VERTICAL;

  mmal_port_parameter_set(camera.output[0], &mirror.hdr);
  mmal_port_parameter_set(camera.output[1], &mirror.hdr);
  return mmal_port_parameter_set(camera.output[2], &mirror.hdr);
}

int raspicamcontrol_set_ROI(MMAL_COMPONENT_T& camera, PARAM_FLOAT_RECT_T rect) {
  MMAL_PARAMETER_INPUT_CROP_T crop = { { MMAL_PARAMETER_INPUT_CROP, sizeof(MMAL_PARAMETER_INPUT_CROP_T) } };

  crop.rect.x = (65536 * rect.x);
  crop.rect.y = (65536 * rect.y);
  crop.rect.width = (65536 * rect.w);
  crop.rect.height = (65536 * rect.h);

  return mmal_port_parameter_set(camera.control, &crop.hdr);
}

int raspicamcontrol_set_shutter_speed(MMAL_COMPONENT_T& camera, int shutter_speed) {
  return mmal_status_to_int(
      mmal_port_parameter_set_uint32(camera.control, MMAL_PARAMETER_SHUTTER_SPEED, shutter_speed));
}

/*static int raspicamcontrol_get_mem_gpu(void)
{
   char response[80] = "";
   int gpu_mem = 0;
   if (vc_gencmd(response, sizeof response, "get_mem gpu") == 0)
      vc_gencmd_number_property(response, "gpu", &gpu_mem);
   return gpu_mem;
}*/

/*static void raspicamcontrol_get_camera(int *supported, int *detected)
{
   char response[80] = "";
   if (vc_gencmd(response, sizeof response, "get_camera") == 0)
   {
      if (supported)
         vc_gencmd_number_property(response, "supported", supported);
      if (detected)
         vc_gencmd_number_property(response, "detected", detected);
   }
}*/

void raspicamcontrol_check_configuration(int min_gpu_mem) {
  int gpu_mem = 256;  // raspicamcontrol_get_mem_gpu();
  int supported = 1, detected = 1;
  // raspicamcontrol_get_camera(&supported, &detected);
  if (!supported)
    vcos_log_error("Camera is not enabled in this build. Try running \"sudo "
                   "raspi-config\" and ensure that \"camera\" has been enabled\n");
  else if (gpu_mem < min_gpu_mem)
    vcos_log_error("Only %dM of gpu_mem is configured. Try running \"sudo "
                   "raspi-config\" and ensure that \"memory_split\" has a value of %d "
                   "or greater\n",
                   gpu_mem, min_gpu_mem);
  else if (!detected)
    vcos_log_error("Camera is not detected. Please check carefully the camera module "
                   "is installed correctly\n");
  else
    vcos_log_error("Failed to run camera app. Please check for firmware updates\n");
}

#endif  // __arm__ || __aarch64__