1. The document describes the overall structure and process of setting up and starting a camera recording using the StagefrightRecorder and CameraSource classes in Android. 2. It establishes connections between the CameraSource, CameraService, CameraRecordingProxy and Camera classes to initialize the camera and get camera frames. 3. Upon start, it begins recording by starting tracks in the MPEG4Writer, which signals the CameraSource to start the actual camera recording via the CameraRecordingProxy.

1. StagefrightRecorder
(Camera/audioSource setup,start)
박철희
1 /19

2. 1. 전체구조 -mediarecorder
VideoCamera
(a (b
) IMediaRecordClient ) IMediaPlayerService
Aandorid.media.MediaR
ecorder
BnMediaRrecorderClient BnMediaPlayerService
1) 연결
MediaRecorder MediaPlayerService
JNI
BpMediaPlayerService
BpMediaRecorder
2) 생성
5) 연결 (c
4) 연결
) IMediaRecorder
BnMediaRrecorder
MediaRecorderClient
BpMediaRecorderClient 3) 생성
StagefrightRecorder
2 /19

3. 1. 전체구조 -StagefrightRecorder
CameraSerive
CameraSource Camera ::Client
StagefrightRecorder
RecordingProxy
mFrameReceived
Mpeg4writer
theadFunc
OMX Codec new camera
CameraHAL
Video
FILL_ EMPTY_
Video theadEntry(mChunks)
BUFFER_DONE BUFFER_DONE
fillOutput Draininput
buffer buffer
Audio theadEntry(mChunks)
audio AudioSource AudioRecord
EMPTY_ mbufferReceived
FILL_
BUFFER_DONE BUFFER_DONE
fillOutput Draininput
buffer buffer
OMX encoder
AudioHAL
fill empty
buffer buffer
3 /19

4. 1. 전체구조 -CameraHAL
4 /19

5. 1. 전체구조 -CameraHAL
 Qualcomm MSM Camera system
5 /19

6. 1. 전체구조 -CameraHAL
6 /19

7. 2.CamersSource setup
status_t StagefrightRecorder::setCamera(const sp<ICamera> &camera,const sp<ICameraRecordingProxy> &proxy)
{
mCamera = camera;  CameraService::Client 를 가리킴 .
mCameraProxy = proxy; Camera 안의 Recording proxy 객체
return OK;
}
status_t StagefrightRecorder::startMPEG4Recording() {
int32_t totalBitRate;
status_t err = setupMPEG4Recording(mOutputFd, mVideoWidth, mVideoHeight, mVideoBitRate, &totalBitRate, &mWriter);
if (err != OK) {
return err;
}
}
status_t StagefrightRecorder::setupMPEG4Recording(..)
{
if (mVideoSource < VIDEO_SOURCE_LIST_END) {
sp<MediaSource> mediaSource;
err = setupMediaSource(&mediaSource);
if (err != OK) {
return err;
}
}
status_t StagefrightRecorder::setupMediaSource( sp<MediaSource> *mediaSource)
{
status_t err = setupCameraSource(&cameraSource);
*mediaSource = cameraSource;
}
7 /19

8. 2.CamersSource setup
status_t StagefrightRecorder::setupCameraSource(..)
{
*cameraSource = CameraSource::CreateFromCamera(
mCamera, mCameraProxy, mCameraId, videoSize, mFrameRate,
mPreviewSurface, useMeta);
mCamera 는 CameraService::Client 를 가리킴 .
 Camera 안의 Recording proxy 객체를 가리킴 .
}
CameraSource *CameraSource::CreateFromCamera(…)
{
CameraSource *source = new CameraSource(camera, proxy, cameraId,
videoSize, frameRate, surface,
storeMetaDataInVideoBuffers);
return source;
}
CameraSource::CameraSource(…) : …
mInitCheck = init(camera, proxy, cameraId, videoSize, frameRate, storeMetaDataInVideoBuffers);
if (mInitCheck != OK) releaseCamera();
}
status_t CameraSource::init(…)
{
err = initWithCameraAccess(camera, proxy, cameraId, videoSize, frameRate, storeMetaDataInVideoBuffers);
}
status_t CameraSource::initWithCameraAccess(…)
{
if ((err = isCameraAvailable(camera, proxy, cameraId)) != OK)
}
8 /19

9. 2.CamersSource setup
status_t CameraSource::isCameraAvailable(const sp<ICamera>& camera, const sp<ICameraRecordingProxy>& proxy,
int32_t cameraId) {
mCamera = Camera::create(camera); -----------(1)
if (mCamera == 0) return -EBUSY;
mCameraRecordingProxy = proxy; -----------(2)
mCameraFlags |= FLAGS_HOT_CAMERA;
return OK;
}
sp<Camera> Camera::create(const sp<ICamera>& camera)
{
…
sp<Camera> c = new Camera();
if (camera->connect(c) == NO_ERROR) {
c->mStatus = NO_ERROR;
c->mCamera = camera; --------------(4)
camera->asBinder()->linkToDeath(c);
return c;
}
return 0;
}
status_t CameraService::Client::connect(const sp<ICameraClient>& client)
{
mCameraClient = client; ----------------(3)
}
9 /19

10. 2.CamersSource setup
Camera
RecordingProxy
Camerasource
mCamera
(2)
mCamera CameraService::Client
mCameraRecordingproxy (1) new Camera
(4) mCameraClient
mCamera (3)
class Camera : public BnCameraClient, public IBinder::DeathRecipient
{
public:
…
class RecordingProxy : public BnCameraRecordingProxy
{
public:
RecordingProxy(const sp<Camera>& camera);
virtual status_t startRecording(const sp<ICameraRecordingProxyListener>& listener);
virtual void stopRecording();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
private:
sp<Camera> mCamera;
};
10 /19

11. 3.CamersSource start
status_t StagefrightRecorder::startMPEG4Recording() { status_t CameraSource::start(MetaData *meta)
… {
err = mWriter->start(meta.get()); startCameraRecording();
} }
status_t MPEG4Writer::start(MetaData *param) void CameraSource::startCameraRecording()
{ {
err = startTracks(param);
if (err != OK) { if (mCameraFlags & FLAGS_HOT_CAMERA) {
return err; mCamera->unlock();
} mCamera.clear(); new Camera 와 연결 끊음 .
} CHECK_EQ(OK,
mCameraRecordingProxy->startRecording
status_t MPEG4Writer::startTracks(MetaData *params) { (new ProxyListener(this)));
for (List<Track *>::iterator it = mTracks.begin(); }
it != mTracks.end(); ++it) {
status_t err = (*it)->start(params); CameraSource::ProxyListener::ProxyListener(const
} sp<CameraSource>& source) {
mSource = source;
status_t MPEG4Writer::Track::start(MetaData *params) CameraSource 를 proxy listener 로 등록 함 .
{ }
status_t err = mSource->start(meta.get());
} status_t Camera::RecordingProxy::startRecording(const
sp<ICameraRecordingProxyListener>& listener)
OMXCodec.cpp {
status_t OMXCodec::start(MetaData *meta) mCamera->setRecordingProxyListener(listener);
{ mCamera->reconnect();
status_t err = mSource->start(params.get()); return mCamera->startRecording();
} }
11 /19

12. 3.CamersSource start
status_t Camera::reconnect()
{
sp <ICamera> c = mCamera;
if (c == 0) return NO_INIT;
return c->connect(this);
}
status_t CameraService::Client::connect(const sp<ICameraClient>& client)
{
mCameraClient = client;
}
Camera
mCamera
RecordingProxy
Camerasource
mCamera
mCamera CameraService::Client
mCameraRecordingproxy x new Camera
mCameraClient
mCamera x
12 /19

13. 3.CamersSource start
status_t Camera::startRecording()
{ void CameraService::Client::dataCallbackTimestamp(..)
sp <ICamera> c = mCamera; {
if (c == 0) return NO_INIT; client->
return c->startRecording(); handleGenericDataTimestamp
} (timestamp, msgType, dataPtr);
}
status_t CameraService::Client::startRecording()
{ void
return startCameraMode(CAMERA_RECORDING_MODE); CameraService::Client::handleGenericDataTimestamp(..)
} {
sp<ICameraClient> c = mCameraClient;
status_t CameraService::Client::startCameraMode(camera_mode mode) c->
{ dataCallbackTimestamp(timestamp, msgType, dataPtr);
case CAMERA_RECORDING_MODE: }
return startRecordingMode();
} Camera.cpp
void Camera::dataCallbackTimestamp(.. dataPtr)
status_t CameraService::Client::startRecordingMode() {
{ proxylistener->
result = mHardware->startRecording(); dataCallbackTimestamp
} (timestamp, msgType, dataPtr);
CameraHardwareinterface.h ->QualcommCamera2.cpp
->QCameraHWI.cpp 를 거쳐서 }
Proxylistener 는 camerasource.cpp 의
QCameraHWI_record.cpp
status_t QCameraStream_record::processRecordFrame(void *data) proxylistener 를 가리킴 .
{
rcb(timeStamp, CAMERA_MSG_VIDEO_FRAME,
mHalCamCtrl->mRecordingMemory.camera_memory[frame->video.video.idx],
0, mHalCamCtrl->mCallbackCookie);
rcb 는 cameraservice.cpp 의 Client 생성자에서 mHardware->setCallbacks 에 의해
dataCallbackTimestamp 가 등록됨 .
}
13 /19

14. 3.CamersSource start
void CameraSource::ProxyListener::dataCallbackTimestamp( nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
{
mSource->dataCallbackTimestamp(timestamp / 1000, msgType, dataPtr);
mSource 는 CameraSource class 를 가리킴 .
}
void CameraSource::dataCallbackTimestamp(int64_t timestampUs, int32_t msgType, const sp<IMemory> &data)
{
mFramesReceived.push_back(data);
mFrameTimes.push_back(timeUs);
mFrameAvailableCondition.signal();
mFramesReceived vector 에 data 가 채워지면 status_t CameraSource::read 에서 기다리고 있던 mFrameAvailableCondition 에
signal 을 날려 줌 .
}
status_t CameraSource::read(..)
{
mFrameAvailableCondition.waitRelative(mLock, mTimeBetweenFrameCaptureUs * 1000LL + CAMERA_SOURCE_TIMEOUT_NS)
frame = *mFramesReceived.begin();
*buffer = new MediaBuffer(frame->pointer(), frame->size());
 읽은 data 를 MediaBuffer class 로 만들어서 OMXCodec 으로 넘긴다 .
}
OMXCodec.cpp
bool OMXCodec::drainInputBuffer(BufferInfo *info)
{
err = mSource->read(&srcBuffer);
srcBuffer 로 data 를 읽어서
err = mOMX->emptyBuffer(mNode, info->mBuffer, 0, offset,flags, timestampUs);
emptybuffer 에 넣는다 .
14 /19

15. 3.CamersSource start
emptybuffer 가 다 채워지면 omx_message::EMPTY_BUFFER_DONE 가 전달된다 .
void OMXCodec::on_message(const omx_message &msg)
{
case omx_message::EMPTY_BUFFER_DONE:
drainInputBuffer(&buffers->editItemAt(i));
 다시 read 를 한 후 emptybuffer 에 채워 넣는다 .
}
emptybuffer 에 채워진 data 가 encoding 이 되어 fillbuffer 에 채워지면 omx_message::FILL_BUFFER_DONE
가 전달된다 .
void OMXCodec::on_message(const omx_message &msg)
{
case omx_message::FILL_BUFFER_DONE:
mFilledBuffers.push_back(i);
mBufferFilled.signal();
OMXCodec::read 의 waitForBufferFilled_l 함수에서 기다리고 있던 mBufferFilled 를 풀어준다 .
}
status_t OMXCodec::read(MediaBuffer **buffer, const ReadOptions *options)
{
waitForBufferFilled_l();
size_t index = *mFilledBuffers.begin();
BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);
*buffer = info->mMediaBuffer;
mpeg4wrtier 의 read 로 buffer 를 넘긴다 .
}
status_t MPEG4Writer::Track::threadEntry()
{
while (!mDone && (err = mSource->read(&buffer)) == OK) {
15 /19

16. 3.CamersSource start
MediaBuffer *copy = new MediaBuffer(buffer->range_length());
memcpy(copy->data(), (uint8_t *)buffer->data() + buffer->range_offset(),buffer->range_length());
mChunkSamples.push_back(copy);
bufferChunk(timestampUs);
}
void MPEG4Writer::Track::bufferChunk(int64_t timestampUs) {
Chunk chunk(this, timestampUs, mChunkSamples);
mOwner->bufferChunk(chunk);
mChunkSamples.clear();
}
void MPEG4Writer::bufferChunk(const Chunk& chunk) {
for (List<ChunkInfo>::iterator it = mChunkInfos.begin(); it != mChunkInfos.end(); ++it) {
if (chunk.mTrack == it->mTrack) { // Found owner
it->mChunks.push_back(chunk);
mChunkReadyCondition.signal();
return;
}
}
void MPEG4Writer::threadFunc() {
while (!mDone && !(chunkFound = findChunkToWrite(&chunk))) {
mChunkReadyCondition.wait(mLock);
}
writeChunkToFile(&chunk);
}
16 /19

17. 4.AudioSource setup
status_t StagefrightRecorder::setupMPEG4Recording(..)
{
err = setupAudioEncoder(writer);
}
status_t StagefrightRecorder::setupAudioEncoder(..)
{
sp<MediaSource> audioEncoder = createAudioSource();
if (audioEncoder == NULL) {
return UNKNOWN_ERROR;
}
writer->addSource(audioEncoder);
}
sp<MediaSource> StagefrightRecorder::createAudioSource()
{
sp<AudioSource> audioSource =new AudioSource( mAudioSource, mSampleRate, mAudioChannels);
sp<MediaSource> audioEncoder = OMXCodec::Create(client.interface(), encMeta, true /* createEncoder */, audioSource);
}
AudioSource::AudioSource(…)
{
mRecord = new AudioRecord(...AudioRecordCallbackFunction,);
audio data 에 대한 callback 을 정의 한다 .(AudioRecordCallbackFunction)
}
static void AudioRecordCallbackFunction(int event, void *user, void *info) {
switch (event) {
case AudioRecord::EVENT_MORE_DATA: {
source->dataCallbackTimestamp(*((AudioRecord::Buffer *) info), systemTime() / 1000);
17 /19

18. 4.AudioSource start
status_t AudioSource::start(MetaData *params) {
status_t err = mRecord->start();
}
AudioRecord.cpp
status_t AudioRecord::start()
{
t->run("ClientRecordThread", ANDROID_PRIORITY_AUDIO);
t 는 ClientRecordThread 를 가리킴
}
bool AudioRecord::ClientRecordThread::threadLoop()
{
return mReceiver.processAudioBuffer(this);
}
bool AudioRecord::processAudioBuffer(const sp<ClientRecordThread>& thread)
{
do {
status_t err = obtainBuffer(&audioBuffer, 1);
mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
AudioSource.cpp 의 AudioRecordCallbackFunction 를 가리킴 .
}
}
static void AudioRecordCallbackFunction(int event, void *user, void *info) {
switch (event) {
case AudioRecord::EVENT_MORE_DATA: {
source->dataCallbackTimestamp(*((AudioRecord::Buffer *) info), systemTime() / 1000);
}
18 /19

19. 4.AudioSource start
status_t AudioSource::dataCallbackTimestamp(const AudioRecord::Buffer& audioBuffer, int64_t timeUs)
{
MediaBuffer *buffer = new MediaBuffer(bufferSize);
memcpy((uint8_t *) buffer->data() + numLostBytes,audioBuffer.i16, audioBuffer.size);
mBuffersReceived.push_back(buffer);
mFrameAvailableCondition.signal();
}
status_t AudioSource::read( MediaBuffer **out, const ReadOptions *options)
{
while (mStarted && mBuffersReceived.empty()) {
mFrameAvailableCondition.wait(mLock);
}
MediaBuffer *buffer = *mBuffersReceived.begin();
*out = buffer;
}
 이후의 과정은 CameraSource 와 동일 (page 10 OMXCodec::drainInputBuffer(BufferInfo *info))
19 /19