305 lines
9.0 KiB
C++
305 lines
9.0 KiB
C++
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
* Copyright (C) 2015 Mozilla Foundation
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef DOM_CAMERA_FALLBACKCAMERAPLATFORM_H
|
|
#define DOM_CAMERA_FALLBACKCAMERAPLATFORM_H
|
|
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
|
|
typedef struct {
|
|
int32_t id;
|
|
int32_t score;
|
|
int32_t rect[4];
|
|
int32_t left_eye[2];
|
|
int32_t right_eye[2];
|
|
int32_t mouth[2];
|
|
} camera_face_t;
|
|
|
|
typedef struct {
|
|
uint32_t number_of_faces;
|
|
camera_face_t* faces;
|
|
} camera_frame_metadata_t;
|
|
|
|
namespace android {
|
|
enum camcorder_quality {
|
|
CAMCORDER_QUALITY_LOW,
|
|
CAMCORDER_QUALITY_HIGH,
|
|
CAMCORDER_QUALITY_QCIF,
|
|
CAMCORDER_QUALITY_CIF,
|
|
CAMCORDER_QUALITY_480P,
|
|
CAMCORDER_QUALITY_720P,
|
|
CAMCORDER_QUALITY_1080P,
|
|
CAMCORDER_QUALITY_QVGA,
|
|
CAMCORDER_QUALITY_VGA,
|
|
CAMCORDER_QUALITY_LIST_START = CAMCORDER_QUALITY_LOW,
|
|
CAMCORDER_QUALITY_LIST_END = CAMCORDER_QUALITY_VGA
|
|
};
|
|
|
|
enum output_format {
|
|
OUTPUT_FORMAT_THREE_GPP,
|
|
OUTPUT_FORMAT_MPEG_4
|
|
};
|
|
|
|
enum video_encoder {
|
|
VIDEO_ENCODER_H263,
|
|
VIDEO_ENCODER_H264,
|
|
VIDEO_ENCODER_MPEG_4_SP
|
|
};
|
|
|
|
enum audio_encoder {
|
|
AUDIO_ENCODER_AMR_WB,
|
|
AUDIO_ENCODER_AMR_NB,
|
|
AUDIO_ENCODER_AAC
|
|
};
|
|
|
|
template <class T>
|
|
class sp final
|
|
{
|
|
public:
|
|
sp()
|
|
: mPtr(nullptr)
|
|
{ }
|
|
|
|
sp(T *aPtr)
|
|
: mPtr(aPtr)
|
|
{ }
|
|
|
|
virtual ~sp() { }
|
|
T* get() const { return mPtr; }
|
|
void clear() { mPtr = nullptr; }
|
|
T* operator->() const { return get(); }
|
|
|
|
private:
|
|
RefPtr<T> mPtr;
|
|
};
|
|
|
|
typedef uint64_t nsecs_t;
|
|
|
|
enum error_t {
|
|
OK = 0,
|
|
UNKNOWN_ERROR,
|
|
INVALID_OPERATION
|
|
};
|
|
|
|
enum camera_msg_t {
|
|
CAMERA_MSG_SHUTTER,
|
|
CAMERA_MSG_COMPRESSED_IMAGE
|
|
};
|
|
|
|
class String8 final
|
|
{
|
|
public:
|
|
String8() { }
|
|
String8(const char* aData) { mData.AssignASCII(aData); }
|
|
virtual ~String8() { }
|
|
const char* string() const { return mData.Data(); }
|
|
|
|
private:
|
|
nsCString mData;
|
|
};
|
|
|
|
enum camera_facing_t {
|
|
CAMERA_FACING_BACK,
|
|
CAMERA_FACING_FRONT
|
|
};
|
|
|
|
struct CameraInfo {
|
|
camera_facing_t facing;
|
|
};
|
|
|
|
class Camera final : public nsISupports
|
|
{
|
|
public:
|
|
NS_DECL_ISUPPORTS;
|
|
|
|
void disconnect() { }
|
|
String8 getParameters() { return String8(); }
|
|
int setParameters(const String8& aParams) { return UNKNOWN_ERROR; }
|
|
int storeMetaDataInBuffers(bool aEnabled) { return UNKNOWN_ERROR; }
|
|
int autoFocus() { return UNKNOWN_ERROR; }
|
|
int cancelAutoFocus() { return UNKNOWN_ERROR; }
|
|
int takePicture(uint32_t flags) { return UNKNOWN_ERROR; }
|
|
int startPreview() { return UNKNOWN_ERROR; }
|
|
int stopPreview() { return UNKNOWN_ERROR; }
|
|
int startRecording() { return UNKNOWN_ERROR; }
|
|
int stopRecording() { return UNKNOWN_ERROR; }
|
|
int startFaceDetection() { return UNKNOWN_ERROR; }
|
|
int stopFaceDetection() { return UNKNOWN_ERROR; }
|
|
static int32_t getNumberOfCameras() { return 2; }
|
|
|
|
static int getCameraInfo(int32_t aDevice, CameraInfo* aInfo)
|
|
{
|
|
switch (aDevice) {
|
|
case 0:
|
|
aInfo->facing = CAMERA_FACING_BACK;
|
|
break;
|
|
case 1:
|
|
aInfo->facing = CAMERA_FACING_FRONT;
|
|
break;
|
|
default:
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
protected:
|
|
Camera() { }
|
|
virtual ~Camera() { }
|
|
|
|
private:
|
|
Camera(const Camera&) = delete;
|
|
Camera& operator=(const Camera&) = delete;
|
|
};
|
|
|
|
class CameraParameters final
|
|
{
|
|
public:
|
|
static const char KEY_PREVIEW_SIZE[];
|
|
static const char KEY_SUPPORTED_PREVIEW_SIZES[];
|
|
static const char KEY_PREVIEW_FPS_RANGE[];
|
|
static const char KEY_SUPPORTED_PREVIEW_FPS_RANGE[];
|
|
static const char KEY_PREVIEW_FORMAT[];
|
|
static const char KEY_SUPPORTED_PREVIEW_FORMATS[];
|
|
static const char KEY_PREVIEW_FRAME_RATE[];
|
|
static const char KEY_SUPPORTED_PREVIEW_FRAME_RATES[];
|
|
static const char KEY_PICTURE_SIZE[];
|
|
static const char KEY_SUPPORTED_PICTURE_SIZES[];
|
|
static const char KEY_PICTURE_FORMAT[];
|
|
static const char KEY_SUPPORTED_PICTURE_FORMATS[];
|
|
static const char KEY_JPEG_THUMBNAIL_WIDTH[];
|
|
static const char KEY_JPEG_THUMBNAIL_HEIGHT[];
|
|
static const char KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES[];
|
|
static const char KEY_JPEG_THUMBNAIL_QUALITY[];
|
|
static const char KEY_JPEG_QUALITY[];
|
|
static const char KEY_ROTATION[];
|
|
static const char KEY_GPS_LATITUDE[];
|
|
static const char KEY_GPS_LONGITUDE[];
|
|
static const char KEY_GPS_ALTITUDE[];
|
|
static const char KEY_GPS_TIMESTAMP[];
|
|
static const char KEY_GPS_PROCESSING_METHOD[];
|
|
static const char KEY_WHITE_BALANCE[];
|
|
static const char KEY_SUPPORTED_WHITE_BALANCE[];
|
|
static const char KEY_EFFECT[];
|
|
static const char KEY_SUPPORTED_EFFECTS[];
|
|
static const char KEY_ANTIBANDING[];
|
|
static const char KEY_SUPPORTED_ANTIBANDING[];
|
|
static const char KEY_SCENE_MODE[];
|
|
static const char KEY_SUPPORTED_SCENE_MODES[];
|
|
static const char KEY_FLASH_MODE[];
|
|
static const char KEY_SUPPORTED_FLASH_MODES[];
|
|
static const char KEY_FOCUS_MODE[];
|
|
static const char KEY_SUPPORTED_FOCUS_MODES[];
|
|
static const char KEY_MAX_NUM_FOCUS_AREAS[];
|
|
static const char KEY_FOCUS_AREAS[];
|
|
static const char KEY_FOCAL_LENGTH[];
|
|
static const char KEY_HORIZONTAL_VIEW_ANGLE[];
|
|
static const char KEY_VERTICAL_VIEW_ANGLE[];
|
|
static const char KEY_EXPOSURE_COMPENSATION[];
|
|
static const char KEY_MAX_EXPOSURE_COMPENSATION[];
|
|
static const char KEY_MIN_EXPOSURE_COMPENSATION[];
|
|
static const char KEY_EXPOSURE_COMPENSATION_STEP[];
|
|
static const char KEY_AUTO_EXPOSURE_LOCK[];
|
|
static const char KEY_AUTO_EXPOSURE_LOCK_SUPPORTED[];
|
|
static const char KEY_AUTO_WHITEBALANCE_LOCK[];
|
|
static const char KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED[];
|
|
static const char KEY_MAX_NUM_METERING_AREAS[];
|
|
static const char KEY_METERING_AREAS[];
|
|
static const char KEY_ZOOM[];
|
|
static const char KEY_MAX_ZOOM[];
|
|
static const char KEY_ZOOM_RATIOS[];
|
|
static const char KEY_ZOOM_SUPPORTED[];
|
|
static const char KEY_SMOOTH_ZOOM_SUPPORTED[];
|
|
static const char KEY_FOCUS_DISTANCES[];
|
|
static const char KEY_VIDEO_SIZE[];
|
|
static const char KEY_SUPPORTED_VIDEO_SIZES[];
|
|
static const char KEY_MAX_NUM_DETECTED_FACES_HW[];
|
|
static const char KEY_MAX_NUM_DETECTED_FACES_SW[];
|
|
static const char KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[];
|
|
static const char KEY_VIDEO_FRAME_FORMAT[];
|
|
static const char KEY_RECORDING_HINT[];
|
|
static const char KEY_VIDEO_SNAPSHOT_SUPPORTED[];
|
|
static const char KEY_VIDEO_STABILIZATION[];
|
|
static const char KEY_VIDEO_STABILIZATION_SUPPORTED[];
|
|
static const char KEY_LIGHTFX[];
|
|
};
|
|
|
|
class MediaProfiles final
|
|
{
|
|
public:
|
|
static MediaProfiles* getInstance() {
|
|
if (!sMediaProfiles) {
|
|
sMediaProfiles = new MediaProfiles();
|
|
}
|
|
return sMediaProfiles;
|
|
}
|
|
|
|
bool hasCamcorderProfile(int aCameraId, camcorder_quality aQuality) const {
|
|
switch (aQuality) {
|
|
case CAMCORDER_QUALITY_LOW:
|
|
case CAMCORDER_QUALITY_HIGH:
|
|
case CAMCORDER_QUALITY_QVGA:
|
|
case CAMCORDER_QUALITY_VGA:
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int getCamcorderProfileParamByName(const char* aParameter, int aCameraId, camcorder_quality aQuality) const {
|
|
switch (aQuality) {
|
|
case CAMCORDER_QUALITY_LOW:
|
|
case CAMCORDER_QUALITY_QVGA:
|
|
if (strcmp(aParameter, "vid.width") == 0) {
|
|
return 320;
|
|
} else if (strcmp(aParameter, "vid.height") == 0) {
|
|
return 240;
|
|
} else if (strcmp(aParameter, "vid.fps") == 0) {
|
|
return 30;
|
|
}
|
|
return 0;
|
|
case CAMCORDER_QUALITY_HIGH:
|
|
case CAMCORDER_QUALITY_VGA:
|
|
if (strcmp(aParameter, "vid.width") == 0) {
|
|
return 640;
|
|
} else if (strcmp(aParameter, "vid.height") == 0) {
|
|
return 480;
|
|
} else if (strcmp(aParameter, "vid.fps") == 0) {
|
|
return 30;
|
|
}
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
protected:
|
|
MediaProfiles() { }
|
|
virtual ~MediaProfiles() { }
|
|
|
|
private:
|
|
MediaProfiles(const MediaProfiles&) = delete;
|
|
MediaProfiles& operator=(const MediaProfiles&) = delete;
|
|
|
|
static MediaProfiles* sMediaProfiles;
|
|
};
|
|
}
|
|
|
|
#endif
|