Google is committed to advancing racial equity for Black communities. See how.

Programming Camera Control Parameters

In the previous Extended View System (EVS) 1.0 release, camera devices were considered read-only devices and, therefore, no method existed that would enable the application to change camera control parameters such as zoom or brightness.

As this could constrain the capability of EVS applications, the new EVS 1.1 introduces new methods and enables the application to program several camera control parameters, all of which are defined in enum CameraParam:

/**
 * EVS Camera Parameter
 */
enum CameraParam : uint32_t {
    /**
     * The brightness of image frames
     */
    BRIGHTNESS,
    /**
     * The contrast of image frames
     */
    CONTRAST,
    /**
     * Automatic gain/exposure control
     */
    AUTOGAIN,
    /**
     * Gain control
     */
    GAIN,
    /**
     * Automatic Whitebalance
     */
    AUTO_WHITE_BALANCE,
    /**
     * Manual white balance setting as a color temperature in Kelvin.
     */
    WHITE_BALANCE_TEMPERATURE,
    /**
     * Image sharpness adjustment
     */
    SHARPNESS,
    /**
     * Auto Exposure Control modes; auto, manual, shutter priority, or
     * aperture priority.
     */
    AUTO_EXPOSURE,
    /**
     * Manual exposure time of the camera
     */
    ABSOLUTE_EXPOSURE,
    /**
     * Set the focal point of the camera to the specified position. This
     * parameter may not be effective when auto focus is enabled.
     */
    ABSOLUTE_FOCUS,
    /**
     * Enables continuous automatic focus adjustments.
     */
    AUTO_FOCUS,
    /**
     * Specify the objective lens focal length as an absolute value.
     */
    ABSOLUTE_ZOOM,
};

Methods are defined as:

/**
 * Requests to be a master client.
 *
 * When multiple clients subscribe to a single camera hardware and one of
 * them adjusts a camera parameter such as the contrast, it may disturb
 * other clients' operations. Therefore, the client must call this method
 * to be a master client. Once it becomes a master, it will be able to
 * change camera parameters until either it dies or explicitly gives up the
 * role.
 *
 * @return result EvsResult::OK if a master role is granted.
 *                EvsResult::OWNERSHIP_LOST if there is already a
 *                master client.
 */
setMaster() generates (EvsResult result);

/**
 * Sets to be a master client forcibly.
 *
 * The client, which owns the display, has a high priority and can take over
 * a master role from other clients without the display.
 *
 * @param  display IEvsDisplay handle. If this is valid, the calling client
 *                 is considered as the high priority client and therefore
 *                 it would take over a master role.
 *
 * @return result  EvsResult::OK if a master role is granted.
 *                 EvsResult::OWNERSHIP_LOST if there is already a
 *                 master client with the display.
 */
forceMaster(IEvsDisplay display) generates (EvsResult result);

/**
 * Retires from a master client role.
 *
 * @return result EvsResult::OK if this call is successful.
 *                EvsResult::INVALID_ARG if the caller client is not a
 *                master client.
 */
unsetMaster() generates (EvsResult result);

/**
 * Retrieves a list of parameters this camera supports.
 *
 * @return params A list of CameraParam that this camera supports.
 */
getParameterList() generates (vec<CameraParam> params);

/**
 * Requests a valid value range of a camera parameter
 *
 * @param  id    The identifier of camera parameter, CameraParam enum.
 *
 * @return min   The lower bound of the valid parameter value range.
 * @return max   The upper bound of the valid parameter value range.
 * @return step  The resolution of values in valid range.
 */
getIntParameterRange(CameraParam id)
    generates (int32_t min, int32_t max, int32_t step);

/**
 * Requests to set a camera parameter.
 *
 * @param  id             The identifier of camera parameter,
 *                        CameraParam enum.
 *         value          A desired parameter value.
 * @return result         EvsResult::OK if it succeeds to set a parameter.
 *                        EvsResult::INVALID_ARG if either a requested
 *                        parameter is not supported or a given value is out
 *                        of bounds.
 *         effectiveValue A programmed parameter value. This may differ
 *                        from what the client gives if, for example, the
 *                        driver does not support a target parameter.
 */
setIntParameter(CameraParam id, int32_t value)
    generates (EvsResult result, int32_t effectiveValue);

/**
 * Retrieves a value of given camera parameter.
 *
 * @param  id     The identifier of camera parameter, CameraParam enum.
 * @return result EvsResult::OK if it succeeds to read a parameter.
 *                EvsResult::INVALID_ARG if either a requested parameter is
 *                not supported.
 *         value  A value of requested camera parameter.
 */
getIntParameter(CameraParam id) generates(EvsResult result, int32_t value);

getParameterList() returns a list of parameters (CameraParam enum) a client can read and write (if the client is a master), and getIntParameterRange() relays the valid value range and resolution. When a master client changes a camera parameter, all other clients on the same camera hardware will be notified by getting a PARAMETER_CHANGED event with a parameter ID and new value.

Note: The sensor driver may handle invalid parameter values differently. It may simply return an error code or clip the value in the valid range and apply. Therefore, the setIntParameter() method returns an effective value and the client can use this value to confirm how the request was handled.

Request Arbitration Between Multiple Camera Clients

Because the previous EVS design allowed multiple applications to simultaneously subscribe to a single camera hardware, it is possible that one application can disturb the operations of other applications by changing a camera parameter. Also, multiple clients may want to adjust the same parameter differently and thereby cause unexpected behaviors in running camera services.

To avoid such problems, the EVS manager allows that only master client to program a camera parameter. Before trying to adjust any camera parameter, the client MUST become a master client by calling the setMaster() method. If this fails, then it means there is already an active master client on that camera hardware. Until the current master client dies, or explicitly gives up a master role through unsetMaster(), no other client will be permitted to change a camera parameter. When a master client returns its privilege, all other applications will be notified by a MASTER_RELEASED event.

Clients with High Priority

The EVS manager handles the client that owns the display with the high priority and allows it to steal a master role from a current master. Because EVS display ownership is based on recency, the new client can even take over from the current client with the display.

High priority clients must call IEvsCamera::forceMaster(sp<IEvsDisplay>& display) to attain a master role. The EVS manager examines the state of a given display handle and, if (and only if) its state is valid and neither DisplayState::NOT_OPEN nor DisplayState::DEAD replaces a master. The client, which just loses the master role, will be notified by a MASTER_RELEASED event and MUST handle this properly.