225 lines
8.6 KiB
C++
225 lines
8.6 KiB
C++
/*
|
|
**
|
|
** Copyright (C) 2008, The Android Open Source Project
|
|
** Copyright (C) 2008 HTC Inc.
|
|
**
|
|
** 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 ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
|
|
#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
|
|
|
|
#include <ui/ICameraService.h>
|
|
#include <ui/CameraHardwareInterface.h>
|
|
#include <ui/Camera.h>
|
|
|
|
namespace android {
|
|
|
|
class MemoryHeapBase;
|
|
class MediaPlayer;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
|
|
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
|
|
|
|
// When enabled, this feature allows you to send an event to the CameraService
|
|
// so that you can cause all references to the heap object gWeakHeap, defined
|
|
// below, to be printed. You will also need to set DEBUG_REFS=1 and
|
|
// DEBUG_REFS_ENABLED_BY_DEFAULT=0 in libutils/RefBase.cpp. You just have to
|
|
// set gWeakHeap to the appropriate heap you want to track.
|
|
|
|
#define DEBUG_HEAP_LEAKS 0
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class CameraService : public BnCameraService
|
|
{
|
|
class Client;
|
|
|
|
public:
|
|
static void instantiate();
|
|
|
|
// ICameraService interface
|
|
virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient);
|
|
|
|
virtual status_t dump(int fd, const Vector<String16>& args);
|
|
|
|
void removeClient(const sp<ICameraClient>& cameraClient);
|
|
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
|
|
|
private:
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class Client : public BnCamera {
|
|
|
|
public:
|
|
virtual void disconnect();
|
|
|
|
// connect new client with existing camera remote
|
|
virtual status_t connect(const sp<ICameraClient>& client);
|
|
|
|
// prevent other processes from using this ICamera interface
|
|
virtual status_t lock();
|
|
|
|
// allow other processes to use this ICamera interface
|
|
virtual status_t unlock();
|
|
|
|
// pass the buffered ISurface to the camera service
|
|
virtual status_t setPreviewDisplay(const sp<ISurface>& surface);
|
|
|
|
// set the preview callback flag to affect how the received frames from
|
|
// preview are handled.
|
|
virtual void setPreviewCallbackFlag(int callback_flag);
|
|
|
|
// start preview mode, must call setPreviewDisplay first
|
|
virtual status_t startPreview();
|
|
|
|
// stop preview mode
|
|
virtual void stopPreview();
|
|
|
|
// get preview state
|
|
virtual bool previewEnabled();
|
|
|
|
// start recording mode
|
|
virtual status_t startRecording();
|
|
|
|
// stop recording mode
|
|
virtual void stopRecording();
|
|
|
|
// get recording state
|
|
virtual bool recordingEnabled();
|
|
|
|
// release a recording frame
|
|
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
|
|
|
|
// auto focus
|
|
virtual status_t autoFocus();
|
|
|
|
// cancel auto focus
|
|
virtual status_t cancelAutoFocus();
|
|
|
|
// take a picture - returns an IMemory (ref-counted mmap)
|
|
virtual status_t takePicture();
|
|
|
|
// set preview/capture parameters - key/value pairs
|
|
virtual status_t setParameters(const String8& params);
|
|
|
|
// get preview/capture parameters - key/value pairs
|
|
virtual String8 getParameters() const;
|
|
|
|
// send command to camera driver
|
|
virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
|
|
|
|
// our client...
|
|
const sp<ICameraClient>& getCameraClient() const { return mCameraClient; }
|
|
|
|
private:
|
|
friend class CameraService;
|
|
Client(const sp<CameraService>& cameraService,
|
|
const sp<ICameraClient>& cameraClient,
|
|
pid_t clientPid);
|
|
Client();
|
|
virtual ~Client();
|
|
|
|
status_t checkPid();
|
|
|
|
static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);
|
|
static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, void* user);
|
|
static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType,
|
|
const sp<IMemory>& dataPtr, void* user);
|
|
|
|
static sp<Client> getClientFromCookie(void* user);
|
|
|
|
void handlePreviewData(const sp<IMemory>&);
|
|
void handleShutter(image_rect_type *image);
|
|
void handlePostview(const sp<IMemory>&);
|
|
void handleRawPicture(const sp<IMemory>&);
|
|
void handleCompressedPicture(const sp<IMemory>&);
|
|
|
|
void copyFrameAndPostCopiedFrame(const sp<ICameraClient>& client,
|
|
const sp<IMemoryHeap>& heap, size_t offset, size_t size);
|
|
|
|
// camera operation mode
|
|
enum camera_mode {
|
|
CAMERA_PREVIEW_MODE = 0, // frame automatically released
|
|
CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame()
|
|
};
|
|
status_t startCameraMode(camera_mode mode);
|
|
status_t startPreviewMode();
|
|
status_t startRecordingMode();
|
|
status_t setOverlay();
|
|
status_t registerPreviewBuffers();
|
|
|
|
// Ensures atomicity among the public methods
|
|
mutable Mutex mLock;
|
|
|
|
// mSurfaceLock synchronizes access to mSurface between
|
|
// setPreviewSurface() and postPreviewFrame(). Note that among
|
|
// the public methods, all accesses to mSurface are
|
|
// syncrhonized by mLock. However, postPreviewFrame() is called
|
|
// by the CameraHardwareInterface callback, and needs to
|
|
// access mSurface. It cannot hold mLock, however, because
|
|
// stopPreview() may be holding that lock while attempting
|
|
// to stop preview, and stopPreview itself will block waiting
|
|
// for a callback from CameraHardwareInterface. If this
|
|
// happens, it will cause a deadlock.
|
|
mutable Mutex mSurfaceLock;
|
|
mutable Condition mReady;
|
|
sp<CameraService> mCameraService;
|
|
sp<ISurface> mSurface;
|
|
sp<MemoryHeapBase> mPreviewBuffer;
|
|
int mPreviewCallbackFlag;
|
|
|
|
sp<MediaPlayer> mMediaPlayerClick;
|
|
sp<MediaPlayer> mMediaPlayerBeep;
|
|
|
|
// these are immutable once the object is created,
|
|
// they don't need to be protected by a lock
|
|
sp<ICameraClient> mCameraClient;
|
|
sp<CameraHardwareInterface> mHardware;
|
|
pid_t mClientPid;
|
|
bool mUseOverlay;
|
|
|
|
sp<OverlayRef> mOverlayRef;
|
|
int mOverlayW;
|
|
int mOverlayH;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
CameraService();
|
|
virtual ~CameraService();
|
|
|
|
// We use a count for number of clients (shoule only be 0 or 1).
|
|
volatile int32_t mUsers;
|
|
virtual void incUsers();
|
|
virtual void decUsers();
|
|
|
|
mutable Mutex mServiceLock;
|
|
wp<Client> mClient;
|
|
|
|
#if DEBUG_HEAP_LEAKS
|
|
wp<IMemoryHeap> gWeakHeap;
|
|
#endif
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|
|
|
|
#endif
|