1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* 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_CAMERA2_STREAMINGPROCESSOR_H
#define ANDROID_SERVERS_CAMERA_CAMERA2_STREAMINGPROCESSOR_H
#include <utils/Mutex.h>
#include <utils/String16.h>
#include <gui/BufferItemConsumer.h>
#include "camera/CameraMetadata.h"
namespace android {
class Camera2Client;
class CameraDeviceBase;
class IMemory;
namespace camera2 {
class Parameters;
class Camera2Heap;
/**
* Management and processing for preview and recording streams
*/
class StreamingProcessor:
public Thread, public BufferItemConsumer::FrameAvailableListener {
public:
StreamingProcessor(sp<Camera2Client> client);
~StreamingProcessor();
status_t setPreviewWindow(sp<ANativeWindow> window);
bool haveValidPreviewWindow() const;
status_t updatePreviewRequest(const Parameters ¶ms);
status_t updatePreviewStream(const Parameters ¶ms);
status_t deletePreviewStream();
int getPreviewStreamId() const;
status_t setRecordingBufferCount(size_t count);
status_t setRecordingFormat(int format, android_dataspace_t dataspace);
status_t updateRecordingRequest(const Parameters ¶ms);
// If needsUpdate is set to true, a updateRecordingStream call with params will recreate
// recording stream
status_t recordingStreamNeedsUpdate(const Parameters ¶ms, bool *needsUpdate);
status_t updateRecordingStream(const Parameters ¶ms);
status_t deleteRecordingStream();
int getRecordingStreamId() const;
enum StreamType {
NONE,
PREVIEW,
RECORD
};
status_t startStream(StreamType type,
const Vector<int32_t> &outputStreams);
// Toggle between paused and unpaused. Stream must be started first.
status_t togglePauseStream(bool pause);
status_t stopStream();
// Returns the request ID for the currently streaming request
// Returns 0 if there is no active request.
status_t getActiveRequestId() const;
status_t incrementStreamingIds();
// Callback for new recording frames from HAL
virtual void onFrameAvailable(const BufferItem& item);
// Callback from stagefright which returns used recording frames
void releaseRecordingFrame(const sp<IMemory>& mem);
status_t dump(int fd, const Vector<String16>& args);
private:
mutable Mutex mMutex;
enum {
NO_STREAM = -1
};
wp<Camera2Client> mClient;
wp<CameraDeviceBase> mDevice;
int mId;
StreamType mActiveRequest;
bool mPaused;
Vector<int32_t> mActiveStreamIds;
// Preview-related members
int32_t mPreviewRequestId;
int mPreviewStreamId;
CameraMetadata mPreviewRequest;
sp<ANativeWindow> mPreviewWindow;
// Recording-related members
static const nsecs_t kWaitDuration = 50000000; // 50 ms
int32_t mRecordingRequestId;
int mRecordingStreamId;
int mRecordingFrameCount;
sp<BufferItemConsumer> mRecordingConsumer;
sp<ANativeWindow> mRecordingWindow;
CameraMetadata mRecordingRequest;
sp<camera2::Camera2Heap> mRecordingHeap;
bool mRecordingFrameAvailable;
Condition mRecordingFrameAvailableSignal;
static const size_t kDefaultRecordingHeapCount = 8;
size_t mRecordingHeapCount;
Vector<BufferItem> mRecordingBuffers;
size_t mRecordingHeapHead, mRecordingHeapFree;
static const int kDefaultRecordingFormat =
HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
int mRecordingFormat;
static const android_dataspace kDefaultRecordingDataSpace =
HAL_DATASPACE_BT709;
android_dataspace mRecordingDataSpace;
static const int kDefaultRecordingGrallocUsage =
GRALLOC_USAGE_HW_VIDEO_ENCODER;
int mRecordingGrallocUsage;
virtual bool threadLoop();
status_t processRecordingFrame();
// Unilaterally free any buffers still outstanding to stagefright
void releaseAllRecordingFramesLocked();
// Determine if the specified stream is currently in use
static bool isStreamActive(const Vector<int32_t> &streams,
int32_t recordingStreamId);
};
}; // namespace camera2
}; // namespace android
#endif
|
