339 lines
10 KiB
C++
339 lines
10 KiB
C++
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef DOM_CAMERA_ICAMERACONTROL_H
|
|
#define DOM_CAMERA_ICAMERACONTROL_H
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsString.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "base/basictypes.h"
|
|
|
|
struct DeviceStorageFileDescriptor;
|
|
|
|
namespace mozilla {
|
|
|
|
class CameraControlListener;
|
|
|
|
// XXXmikeh - In some future patch this should move into the ICameraControl
|
|
// class as well, and the names updated to the 'k'-style;
|
|
// e.g. kParamPreviewSize, etc.
|
|
enum {
|
|
// current settings
|
|
CAMERA_PARAM_PREVIEWSIZE,
|
|
CAMERA_PARAM_PREVIEWFORMAT,
|
|
CAMERA_PARAM_PREVIEWFRAMERATE,
|
|
CAMERA_PARAM_VIDEOSIZE,
|
|
CAMERA_PARAM_PICTURE_SIZE,
|
|
CAMERA_PARAM_PICTURE_FILEFORMAT,
|
|
CAMERA_PARAM_PICTURE_ROTATION,
|
|
CAMERA_PARAM_PICTURE_LOCATION,
|
|
CAMERA_PARAM_PICTURE_DATETIME,
|
|
CAMERA_PARAM_PICTURE_QUALITY,
|
|
CAMERA_PARAM_EFFECT,
|
|
CAMERA_PARAM_WHITEBALANCE,
|
|
CAMERA_PARAM_SCENEMODE,
|
|
CAMERA_PARAM_FLASHMODE,
|
|
CAMERA_PARAM_FOCUSMODE,
|
|
CAMERA_PARAM_ZOOM,
|
|
CAMERA_PARAM_METERINGAREAS,
|
|
CAMERA_PARAM_FOCUSAREAS,
|
|
CAMERA_PARAM_FOCALLENGTH,
|
|
CAMERA_PARAM_FOCUSDISTANCENEAR,
|
|
CAMERA_PARAM_FOCUSDISTANCEOPTIMUM,
|
|
CAMERA_PARAM_FOCUSDISTANCEFAR,
|
|
CAMERA_PARAM_EXPOSURECOMPENSATION,
|
|
CAMERA_PARAM_THUMBNAILSIZE,
|
|
CAMERA_PARAM_THUMBNAILQUALITY,
|
|
CAMERA_PARAM_SENSORANGLE,
|
|
CAMERA_PARAM_ISOMODE,
|
|
CAMERA_PARAM_LUMINANCE,
|
|
CAMERA_PARAM_SCENEMODE_HDR_RETURNNORMALPICTURE,
|
|
CAMERA_PARAM_RECORDINGHINT,
|
|
CAMERA_PARAM_PREFERRED_PREVIEWSIZE_FOR_VIDEO,
|
|
CAMERA_PARAM_METERINGMODE,
|
|
|
|
// supported features
|
|
CAMERA_PARAM_SUPPORTED_PREVIEWSIZES,
|
|
CAMERA_PARAM_SUPPORTED_PICTURESIZES,
|
|
CAMERA_PARAM_SUPPORTED_VIDEOSIZES,
|
|
CAMERA_PARAM_SUPPORTED_PICTUREFORMATS,
|
|
CAMERA_PARAM_SUPPORTED_WHITEBALANCES,
|
|
CAMERA_PARAM_SUPPORTED_SCENEMODES,
|
|
CAMERA_PARAM_SUPPORTED_EFFECTS,
|
|
CAMERA_PARAM_SUPPORTED_FLASHMODES,
|
|
CAMERA_PARAM_SUPPORTED_FOCUSMODES,
|
|
CAMERA_PARAM_SUPPORTED_MAXFOCUSAREAS,
|
|
CAMERA_PARAM_SUPPORTED_MAXMETERINGAREAS,
|
|
CAMERA_PARAM_SUPPORTED_MINEXPOSURECOMPENSATION,
|
|
CAMERA_PARAM_SUPPORTED_MAXEXPOSURECOMPENSATION,
|
|
CAMERA_PARAM_SUPPORTED_EXPOSURECOMPENSATIONSTEP,
|
|
CAMERA_PARAM_SUPPORTED_ZOOM,
|
|
CAMERA_PARAM_SUPPORTED_ZOOMRATIOS,
|
|
CAMERA_PARAM_SUPPORTED_MAXDETECTEDFACES,
|
|
CAMERA_PARAM_SUPPORTED_JPEG_THUMBNAIL_SIZES,
|
|
CAMERA_PARAM_SUPPORTED_ISOMODES,
|
|
CAMERA_PARAM_SUPPORTED_METERINGMODES
|
|
};
|
|
|
|
class ICameraControl
|
|
{
|
|
public:
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ICameraControl)
|
|
|
|
// Returns the number of cameras supported by the system.
|
|
//
|
|
// Return values:
|
|
// - NS_OK on success;
|
|
// - NS_ERROR_FAILURE if the camera count cannot be retrieved.
|
|
static nsresult GetNumberOfCameras(int32_t& aDeviceCount);
|
|
|
|
// Gets the (possibly-meaningful) name of a particular camera.
|
|
//
|
|
// Return values:
|
|
// - NS_OK on success;
|
|
// - NS_ERROR_INVALID_ARG if 'aDeviceNum' is not a valid camera number;
|
|
// - NS_ERROR_NOT_AVAILABLE if 'aDeviceNum' is valid but the camera name
|
|
// could still not be retrieved.
|
|
static nsresult GetCameraName(uint32_t aDeviceNum, nsCString& aDeviceName);
|
|
|
|
// Returns a list of names of all cameras supported by the system.
|
|
//
|
|
// Return values:
|
|
// - NS_OK on success, even if no camera names are returned (in which
|
|
// case 'aList' will be empty);
|
|
// - NS_ERROR_NOT_AVAILABLE if the list of cameras cannot be retrieved.
|
|
static nsresult GetListOfCameras(nsTArray<nsString>& aList);
|
|
|
|
enum Mode {
|
|
kUnspecifiedMode,
|
|
kPictureMode,
|
|
kVideoMode,
|
|
};
|
|
|
|
struct Size {
|
|
uint32_t width;
|
|
uint32_t height;
|
|
|
|
bool Equals(const Size& aSize) const
|
|
{
|
|
return width == aSize.width && height == aSize.height;
|
|
}
|
|
};
|
|
|
|
struct Region {
|
|
int32_t top;
|
|
int32_t left;
|
|
int32_t bottom;
|
|
int32_t right;
|
|
uint32_t weight;
|
|
};
|
|
|
|
struct Position {
|
|
double latitude;
|
|
double longitude;
|
|
double altitude;
|
|
double timestamp;
|
|
};
|
|
|
|
struct StartRecordingOptions {
|
|
uint32_t rotation;
|
|
uint64_t maxFileSizeBytes;
|
|
uint64_t maxVideoLengthMs;
|
|
bool autoEnableLowLightTorch;
|
|
bool createPoster;
|
|
};
|
|
|
|
struct Configuration {
|
|
Mode mMode;
|
|
Size mPreviewSize;
|
|
Size mPictureSize;
|
|
nsString mRecorderProfile;
|
|
};
|
|
|
|
struct Point {
|
|
int32_t x;
|
|
int32_t y;
|
|
};
|
|
|
|
struct Face {
|
|
uint32_t id;
|
|
uint32_t score;
|
|
Region bound;
|
|
bool hasLeftEye;
|
|
Point leftEye;
|
|
bool hasRightEye;
|
|
Point rightEye;
|
|
bool hasMouth;
|
|
Point mouth;
|
|
};
|
|
|
|
class RecorderProfile
|
|
{
|
|
public:
|
|
class Video
|
|
{
|
|
public:
|
|
Video() { }
|
|
virtual ~Video() { }
|
|
|
|
const nsString& GetCodec() const { return mCodec; }
|
|
const Size& GetSize() const { return mSize; }
|
|
uint32_t GetBitsPerSecond() const { return mBitsPerSecond; }
|
|
uint32_t GetFramesPerSecond() const { return mFramesPerSecond; }
|
|
|
|
protected:
|
|
nsString mCodec;
|
|
Size mSize;
|
|
uint32_t mBitsPerSecond;
|
|
uint32_t mFramesPerSecond;
|
|
|
|
private:
|
|
DISALLOW_EVIL_CONSTRUCTORS(Video);
|
|
};
|
|
|
|
class Audio
|
|
{
|
|
public:
|
|
Audio() { }
|
|
virtual ~Audio() { }
|
|
|
|
const nsString& GetCodec() const { return mCodec; }
|
|
|
|
uint32_t GetChannels() const { return mChannels; }
|
|
uint32_t GetBitsPerSecond() const { return mBitsPerSecond; }
|
|
uint32_t GetSamplesPerSecond() const { return mSamplesPerSecond; }
|
|
|
|
protected:
|
|
nsString mCodec;
|
|
uint32_t mChannels;
|
|
uint32_t mBitsPerSecond;
|
|
uint32_t mSamplesPerSecond;
|
|
|
|
private:
|
|
DISALLOW_EVIL_CONSTRUCTORS(Audio);
|
|
};
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RecorderProfile)
|
|
|
|
RecorderProfile()
|
|
{ }
|
|
|
|
const nsString& GetName() const { return mName; }
|
|
const nsString& GetContainer() const { return mContainer; }
|
|
const nsString& GetMimeType() const { return mMimeType; }
|
|
uint32_t GetPriority() const { return mPriority; }
|
|
|
|
virtual const Video& GetVideo() const = 0;
|
|
virtual const Audio& GetAudio() const = 0;
|
|
|
|
protected:
|
|
virtual ~RecorderProfile() { }
|
|
|
|
nsString mName;
|
|
nsString mContainer;
|
|
nsString mMimeType;
|
|
uint32_t mPriority;
|
|
|
|
private:
|
|
DISALLOW_EVIL_CONSTRUCTORS(RecorderProfile);
|
|
};
|
|
|
|
static already_AddRefed<ICameraControl> Create(uint32_t aCameraId);
|
|
|
|
virtual void AddListener(CameraControlListener* aListener) = 0;
|
|
virtual void RemoveListener(CameraControlListener* aListener) = 0;
|
|
|
|
// Camera control methods.
|
|
//
|
|
// Return values:
|
|
// - NS_OK on success (if the method requires an asynchronous process,
|
|
// this value indicates that the process has begun successfully);
|
|
// - NS_ERROR_INVALID_ARG if one or more arguments is invalid;
|
|
// - NS_ERROR_FAILURE if an asynchronous method could not be dispatched.
|
|
virtual nsresult Start(const Configuration* aInitialConfig = nullptr) = 0;
|
|
virtual nsresult Stop() = 0;
|
|
virtual nsresult SetConfiguration(const Configuration& aConfig) = 0;
|
|
virtual nsresult StartPreview() = 0;
|
|
virtual nsresult StopPreview() = 0;
|
|
virtual nsresult AutoFocus() = 0;
|
|
virtual nsresult TakePicture() = 0;
|
|
virtual nsresult StartRecording(DeviceStorageFileDescriptor* aFileDescriptor,
|
|
const StartRecordingOptions* aOptions = nullptr) = 0;
|
|
virtual nsresult StopRecording() = 0;
|
|
virtual nsresult PauseRecording() = 0;
|
|
virtual nsresult ResumeRecording() = 0;
|
|
virtual nsresult StartFaceDetection() = 0;
|
|
virtual nsresult StopFaceDetection() = 0;
|
|
virtual nsresult ResumeContinuousFocus() = 0;
|
|
|
|
// Camera parameter getters and setters. 'aKey' must be one of the
|
|
// CAMERA_PARAM_* values enumerated above.
|
|
//
|
|
// Return values:
|
|
// - NS_OK on success;
|
|
// - NS_ERROR_INVALID_ARG if 'aValue' contains an invalid value;
|
|
// - NS_ERROR_NOT_IMPLEMENTED if 'aKey' is invalid;
|
|
// - NS_ERROR_NOT_AVAILABLE if the getter fails to retrieve a valid value,
|
|
// or if a setter fails because it requires one or more values that
|
|
// could not be retrieved;
|
|
// - NS_ERROR_FAILURE on unexpected internal failures.
|
|
virtual nsresult Set(uint32_t aKey, const nsAString& aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, nsAString& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, double aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, double& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, int32_t aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, int32_t& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, int64_t aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, int64_t& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, bool aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, bool& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, const Size& aValue) = 0;
|
|
virtual nsresult Get(uint32_t aKey, Size& aValue) = 0;
|
|
virtual nsresult Set(uint32_t aKey, const nsTArray<Region>& aRegions) = 0;
|
|
virtual nsresult Get(uint32_t aKey, nsTArray<Region>& aRegions) = 0;
|
|
|
|
virtual nsresult SetLocation(const Position& aLocation) = 0;
|
|
|
|
virtual nsresult Get(uint32_t aKey, nsTArray<Size>& aSizes) = 0;
|
|
virtual nsresult Get(uint32_t aKey, nsTArray<nsString>& aValues) = 0;
|
|
virtual nsresult Get(uint32_t aKey, nsTArray<double>& aValues) = 0;
|
|
|
|
virtual nsresult GetRecorderProfiles(nsTArray<nsString>& aProfiles) = 0;
|
|
virtual RecorderProfile* GetProfileInfo(const nsAString& aProfile) = 0;
|
|
|
|
protected:
|
|
virtual ~ICameraControl() { }
|
|
|
|
friend class ICameraControlParameterSetAutoEnter;
|
|
|
|
virtual void BeginBatchParameterSet() = 0;
|
|
virtual void EndBatchParameterSet() = 0;
|
|
};
|
|
|
|
// Helper class to make it easy to update a batch of camera parameters;
|
|
// the parameters are applied atomically when this object goes out of
|
|
// scope.
|
|
class ICameraControlParameterSetAutoEnter
|
|
{
|
|
public:
|
|
explicit ICameraControlParameterSetAutoEnter(ICameraControl* aCameraControl)
|
|
: mCameraControl(aCameraControl)
|
|
{
|
|
mCameraControl->BeginBatchParameterSet();
|
|
}
|
|
virtual ~ICameraControlParameterSetAutoEnter()
|
|
{
|
|
mCameraControl->EndBatchParameterSet();
|
|
}
|
|
|
|
protected:
|
|
RefPtr<ICameraControl> mCameraControl;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // DOM_CAMERA_ICAMERACONTROL_H
|