| /* |
| * 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. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "CameraInput" |
| #include <utils/Log.h> |
| #include <camera/CameraParameters.h> |
| #include <utils/Errors.h> |
| #include <media/mediarecorder.h> |
| #include <surfaceflinger/ISurface.h> |
| #include <camera/ICamera.h> |
| #include <camera/Camera.h> |
| |
| #include "pv_mime_string_utils.h" |
| #include "oscl_dll.h" |
| #include "oscl_tickcount.h" |
| |
| #include "android_camera_input.h" |
| |
| using namespace android; |
| |
| static const int VIEW_FINDER_FREEZE_DETECTION_TOLERANCE = 250; // ms |
| |
| // Define entry point for this DLL |
| OSCL_DLL_ENTRY_POINT_DEFAULT() |
| |
| PVRefBufferAlloc::~PVRefBufferAlloc() |
| { |
| if(numAllocated != 0) |
| { |
| LOGE("Ln %d ERROR PVRefBufferAlloc numAllocated %d",__LINE__, numAllocated ); |
| } |
| } |
| |
| // camera MIO |
| AndroidCameraInput::AndroidCameraInput() |
| : OsclTimerObject(OsclActiveObject::EPriorityNominal, "AndroidCameraInput"), |
| iWriteState(EWriteOK), |
| iAuthorClock(NULL), |
| iClockNotificationsInf(NULL), |
| iAudioFirstFrameTs(0), |
| iAudioLossDuration(0), |
| pPmemInfo(NULL) |
| { |
| LOGV("constructor(%p)", this); |
| iCmdIdCounter = 0; |
| iPeer = NULL; |
| iThreadLoggedOn = false; |
| iDataEventCounter = 0; |
| iTimeStamp = 0; |
| iMilliSecondsPerDataEvent = 0; |
| iMicroSecondsPerDataEvent = 0; |
| iState = STATE_IDLE; |
| mFrameWidth = ANDROID_DEFAULT_FRAME_WIDTH; |
| mFrameHeight= ANDROID_DEFAULT_FRAME_HEIGHT; |
| mFrameRate = ANDROID_DEFAULT_FRAME_RATE; |
| mCamera = NULL; |
| |
| mFlags = 0; |
| iFrameQueue.reserve(5); |
| iFrameQueueMutex.Create(); |
| iAudioLossMutex.Create(); |
| |
| // setup callback listener |
| mListener = new AndroidCameraInputListener(this); |
| } |
| |
| void AndroidCameraInput::ReleaseQueuedFrames() |
| { |
| LOGV("ReleaseQueuedFrames"); |
| iFrameQueueMutex.Lock(); |
| while (!iFrameQueue.empty()) { |
| AndroidCameraInputMediaData data = iFrameQueue[0]; |
| iFrameQueue.erase(iFrameQueue.begin()); |
| #if (LOG_NDEBUG == 0) |
| ssize_t offset = 0; |
| size_t size = 0; |
| sp<IMemoryHeap> heap = data.iFrameBuffer->getMemory(&offset, &size); |
| LOGD("writeComplete: ID = %d, base = %p, offset = %ld, size = %d ReleaseQueuedFrames", heap->getHeapID(), heap->base(), offset, size); |
| #endif |
| mCamera->releaseRecordingFrame(data.iFrameBuffer); |
| } |
| if(pPmemInfo) |
| { |
| delete pPmemInfo; |
| pPmemInfo = NULL; |
| } |
| iFrameQueueMutex.Unlock(); |
| } |
| |
| AndroidCameraInput::~AndroidCameraInput() |
| { |
| LOGV("destructor"); |
| if (mCamera != NULL) { |
| mCamera->setListener(NULL); |
| ReleaseQueuedFrames(); |
| if ((mFlags & FLAGS_HOT_CAMERA) == 0) { |
| LOGV("camera was cold when we started, stopping preview"); |
| mCamera->stopPreview(); |
| } |
| if (mFlags & FLAGS_SET_CAMERA) { |
| LOGV("unlocking camera to return to app"); |
| mCamera->unlock(); |
| } else { |
| LOGV("disconnect from camera"); |
| mCamera->disconnect(); |
| } |
| mFlags = 0; |
| mCamera.clear(); |
| } |
| iFrameQueueMutex.Close(); |
| iAudioLossMutex.Close(); |
| mListener.clear(); |
| } |
| |
| PVMFStatus AndroidCameraInput::connect(PvmiMIOSession& aSession, |
| PvmiMIOObserver* aObserver) |
| { |
| LOGV("connect"); |
| if (!aObserver) { |
| LOGE("observer is a NULL pointer"); |
| return PVMFFailure; |
| } |
| |
| int32 err = 0; |
| OSCL_TRY(err, iObservers.push_back(aObserver)); |
| OSCL_FIRST_CATCH_ANY(err, |
| LOGE("Out of memory"); return PVMFErrNoMemory); |
| |
| // Session ID is the index of observer in the vector |
| aSession = (PvmiMIOSession)(iObservers.size() - 1); |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::disconnect(PvmiMIOSession aSession) |
| { |
| LOGV("disconnect"); |
| uint32 index = (uint32) aSession; |
| uint32 size = iObservers.size(); |
| if (index >= size) { |
| LOGE("Invalid session ID %d. Valid range is [0, %d]", index, size - 1); |
| return PVMFFailure; |
| } |
| |
| iObservers.erase(iObservers.begin() + index); |
| return PVMFSuccess; |
| } |
| |
| PvmiMediaTransfer* AndroidCameraInput::createMediaTransfer( |
| PvmiMIOSession& aSession, |
| PvmiKvp* read_formats, |
| int32 read_flags, |
| PvmiKvp* write_formats, |
| int32 write_flags) |
| { |
| LOGV("createMediaTransfer"); |
| OSCL_UNUSED_ARG(read_formats); |
| OSCL_UNUSED_ARG(read_flags); |
| OSCL_UNUSED_ARG(write_formats); |
| OSCL_UNUSED_ARG(write_flags); |
| |
| uint32 index = (uint32) aSession; |
| uint32 size = iObservers.size(); |
| if (index >= size) { |
| LOGE("Invalid session ID %d. Valid range is [0, %d]", index, size - 1); |
| OSCL_LEAVE(OsclErrArgument); |
| return NULL; |
| } |
| |
| return (PvmiMediaTransfer*)this; |
| } |
| |
| void AndroidCameraInput::deleteMediaTransfer(PvmiMIOSession& aSession, |
| PvmiMediaTransfer* media_transfer) |
| { |
| LOGV("deleteMediaTransfer"); |
| uint32 index = (uint32) aSession; |
| uint32 size = iObservers.size(); |
| if (index >= size) { |
| LOGE("Invalid session ID %d. Valid range is [0, %d]", index, size - 1); |
| OSCL_LEAVE(OsclErrArgument); |
| return; |
| } |
| if (!media_transfer) { |
| LOGE("media transfer is a NULL pointer"); |
| OSCL_LEAVE(OsclErrArgument); |
| } |
| |
| // TODO: |
| // 1. I did not see how the media transfer session has been terminated |
| // after this method call. |
| // 2. according to pvmi_mio_control.h, this should also check with there |
| // is any outstanding buffer? |
| } |
| |
| PVMFCommandId AndroidCameraInput::QueryUUID(const PvmfMimeString& aMimeType, |
| Oscl_Vector<PVUuid, |
| OsclMemAllocator>& aUuids, |
| bool aExactUuidsOnly, |
| const OsclAny* aContext) |
| { |
| LOGV("QueryUUID"); |
| OSCL_UNUSED_ARG(aMimeType); |
| OSCL_UNUSED_ARG(aExactUuidsOnly); |
| |
| int32 err = 0; |
| OSCL_TRY(err, aUuids.push_back(PVMI_CAPABILITY_AND_CONFIG_PVUUID);); |
| OSCL_FIRST_CATCH_ANY(err, |
| LOGE("Out of memory"); OSCL_LEAVE(OsclErrNoMemory)); |
| |
| return AddCmdToQueue(CMD_QUERY_UUID, aContext); |
| } |
| |
| PVMFCommandId AndroidCameraInput::QueryInterface(const PVUuid& aUuid, |
| PVInterface*& aInterfacePtr, |
| const OsclAny* aContext) |
| { |
| LOGV("QueryInterface"); |
| if (aUuid == PVMI_CAPABILITY_AND_CONFIG_PVUUID) { |
| PvmiCapabilityAndConfig* |
| myInterface = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*,this); |
| |
| aInterfacePtr = OSCL_STATIC_CAST(PVInterface*, myInterface); |
| } else { |
| aInterfacePtr = NULL; |
| } |
| |
| return AddCmdToQueue(CMD_QUERY_INTERFACE, |
| aContext, |
| (OsclAny*)&aInterfacePtr); |
| } |
| |
| PVMFCommandId AndroidCameraInput::Init(const OsclAny* aContext) |
| { |
| LOGV("Init"); |
| if (iState != STATE_IDLE) { |
| LOGE("Init called in an invalid state(%d)", iState); |
| OSCL_LEAVE(OsclErrInvalidState); |
| return -1; |
| } |
| |
| return AddCmdToQueue(CMD_INIT, aContext); |
| } |
| |
| |
| PVMFCommandId AndroidCameraInput::Start(const OsclAny* aContext) |
| { |
| LOGV("Start"); |
| if (iState != STATE_INITIALIZED && iState != STATE_PAUSED) { |
| LOGE("Start called in an invalid state(%d)", iState); |
| OSCL_LEAVE(OsclErrInvalidState); |
| return -1; |
| } |
| |
| return AddCmdToQueue(CMD_START, aContext); |
| } |
| |
| PVMFCommandId AndroidCameraInput::Pause(const OsclAny* aContext) |
| { |
| LOGV("Pause"); |
| if (iState != STATE_STARTED) { |
| LOGE("Pause called in an invalid state(%d)", iState); |
| OSCL_LEAVE(OsclErrInvalidState); |
| return -1; |
| } |
| |
| return AddCmdToQueue(CMD_PAUSE, aContext); |
| } |
| |
| PVMFCommandId AndroidCameraInput::Flush(const OsclAny* aContext) |
| { |
| LOGV("Flush"); |
| if (iState != STATE_STARTED && iState != STATE_PAUSED) { |
| LOGE("Flush called in an invalid state(%d)", iState); |
| OSCL_LEAVE(OsclErrInvalidState); |
| return -1; |
| } |
| |
| return AddCmdToQueue(CMD_FLUSH, aContext); |
| } |
| |
| PVMFCommandId AndroidCameraInput::Reset(const OsclAny* aContext) |
| { |
| LOGV("Reset"); |
| return AddCmdToQueue(CMD_RESET, aContext); |
| } |
| |
| PVMFCommandId AndroidCameraInput::DiscardData(PVMFTimestamp aTimestamp, |
| const OsclAny* aContext) |
| { |
| LOGV("DiscardData with time stamp"); |
| OSCL_UNUSED_ARG(aContext); |
| OSCL_UNUSED_ARG(aTimestamp); |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| PVMFCommandId AndroidCameraInput::DiscardData(const OsclAny* aContext) |
| { |
| LOGV("DiscardData"); |
| OSCL_UNUSED_ARG(aContext); |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| PVMFCommandId AndroidCameraInput::Stop(const OsclAny* aContext) |
| { |
| LOGV("Stop"); |
| if (iState != STATE_STARTED && iState != STATE_PAUSED) { |
| LOGE("Stop called in an invalid state(%d)", iState); |
| OSCL_LEAVE(OsclErrInvalidState); |
| return -1; |
| } |
| |
| return AddCmdToQueue(CMD_STOP, aContext); |
| } |
| |
| void AndroidCameraInput::ThreadLogon() |
| { |
| LOGV("ThreadLogon"); |
| if (!iThreadLoggedOn) { |
| AddToScheduler(); |
| iThreadLoggedOn = true; |
| } |
| } |
| |
| void AndroidCameraInput::ThreadLogoff() |
| { |
| LOGV("ThreadLogoff"); |
| if (iThreadLoggedOn) { |
| RemoveFromScheduler(); |
| iThreadLoggedOn = false; |
| } |
| } |
| |
| PVMFCommandId AndroidCameraInput::CancelAllCommands(const OsclAny* aContext) |
| { |
| LOGV("CancelAllCommands"); |
| OSCL_UNUSED_ARG(aContext); |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| PVMFCommandId AndroidCameraInput::CancelCommand(PVMFCommandId aCmdId, |
| const OsclAny* aContext) |
| { |
| LOGV("CancelCommand"); |
| OSCL_UNUSED_ARG(aCmdId); |
| OSCL_UNUSED_ARG(aContext); |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| void AndroidCameraInput::setPeer(PvmiMediaTransfer* aPeer) |
| { |
| LOGV("setPeer iPeer %p aPeer %p", iPeer, aPeer); |
| if(iPeer && aPeer){ |
| LOGE("setPeer iPeer %p aPeer %p", iPeer, aPeer); |
| OSCL_LEAVE(OsclErrGeneral); |
| return; |
| } |
| |
| iPeer = aPeer; |
| } |
| |
| void AndroidCameraInput::useMemoryAllocators(OsclMemAllocator* write_alloc) |
| { |
| LOGV("useMemoryAllocators"); |
| OSCL_UNUSED_ARG(write_alloc); |
| OSCL_LEAVE(OsclErrNotSupported); |
| } |
| |
| PVMFCommandId AndroidCameraInput::writeAsync(uint8 aFormatType, |
| int32 aFormatIndex, |
| uint8* aData, |
| uint32 aDataLen, |
| const PvmiMediaXferHeader& data_header_info, |
| OsclAny* aContext) |
| { |
| LOGV("writeAsync"); |
| OSCL_UNUSED_ARG(aFormatType); |
| OSCL_UNUSED_ARG(aFormatIndex); |
| OSCL_UNUSED_ARG(aData); |
| OSCL_UNUSED_ARG(aDataLen); |
| OSCL_UNUSED_ARG(data_header_info); |
| OSCL_UNUSED_ARG(aContext); |
| // This is an active data source. writeAsync is not supported. |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| void AndroidCameraInput::writeComplete(PVMFStatus aStatus, |
| PVMFCommandId write_cmd_id, |
| OsclAny* aContext) |
| { |
| LOGV("writeComplete"); |
| OSCL_UNUSED_ARG(aContext); |
| |
| iFrameQueueMutex.Lock(); |
| if (iSentMediaData.empty()) { |
| LOGE("Nothing to complete"); |
| iFrameQueueMutex.Unlock(); |
| return; |
| } |
| |
| AndroidCameraInputMediaData data = iSentMediaData[0]; |
| #if (LOG_NDEBUG == 0) |
| ssize_t offset = 0; |
| size_t size = 0; |
| sp<IMemoryHeap> heap = data.iFrameBuffer->getMemory(&offset, &size); |
| LOGD("writeComplete: ID = %d, base = %p, offset = %ld, size = %d", heap->getHeapID(), heap->base(), offset, size); |
| #endif |
| // View finder freeze detection |
| // Note for low frame rate, we don't bother to log view finder freezes |
| int processingTimeInMs = (systemTime()/1000000L - (iAudioFirstFrameTs + iAudioLossDuration)) - data.iXferHeader.timestamp; |
| if (processingTimeInMs >= VIEW_FINDER_FREEZE_DETECTION_TOLERANCE && mFrameRate >= 10.0) { |
| LOGW("Frame %p takes too long (%d ms) to process, staring at %d", data.iFrameBuffer.get(), processingTimeInMs, iAudioFirstFrameTs); |
| } |
| mCamera->releaseRecordingFrame(data.iFrameBuffer); |
| |
| iSentMediaData.erase(iSentMediaData.begin()); |
| iFrameQueueMutex.Unlock(); |
| |
| // reference count is always updated, even if the write fails |
| if (aStatus != PVMFSuccess) { |
| LOGE("writeAsync failed. aStatus=%d", aStatus); |
| } |
| } |
| |
| PVMFCommandId AndroidCameraInput::readAsync(uint8* data, |
| uint32 max_data_len, |
| OsclAny* aContext, |
| int32* formats, |
| uint16 num_formats) |
| { |
| LOGV("readAsync"); |
| OSCL_UNUSED_ARG(data); |
| OSCL_UNUSED_ARG(max_data_len); |
| OSCL_UNUSED_ARG(aContext); |
| OSCL_UNUSED_ARG(formats); |
| OSCL_UNUSED_ARG(num_formats); |
| // This is an active data source. readAsync is not supported. |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| void AndroidCameraInput::readComplete(PVMFStatus aStatus, |
| PVMFCommandId read_cmd_id, |
| int32 format_index, |
| const PvmiMediaXferHeader& data_header_info, |
| OsclAny* aContext) |
| { |
| LOGV("readComplete"); |
| OSCL_UNUSED_ARG(aStatus); |
| OSCL_UNUSED_ARG(read_cmd_id); |
| OSCL_UNUSED_ARG(format_index); |
| OSCL_UNUSED_ARG(data_header_info); |
| OSCL_UNUSED_ARG(aContext); |
| // This is an active data source. readComplete is not supported. |
| OSCL_LEAVE(OsclErrNotSupported); |
| return; |
| } |
| |
| void AndroidCameraInput::statusUpdate(uint32 status_flags) |
| { |
| LOGV("statusUpdate"); |
| if (status_flags != PVMI_MEDIAXFER_STATUS_WRITE) |
| { |
| OSCL_LEAVE(OsclErrNotSupported); |
| } |
| else |
| { |
| // Restart the flow of data |
| iWriteState = EWriteOK; |
| } |
| } |
| |
| void AndroidCameraInput::cancelCommand(PVMFCommandId aCmdId) |
| { |
| LOGV("cancelCommand"); |
| OSCL_UNUSED_ARG(aCmdId); |
| |
| // This cancel command ( with a small "c" in cancel ) is for the media |
| // transfer interface. implementation is similar to the cancel command |
| // of the media I/O interface. |
| OSCL_LEAVE(OsclErrNotSupported); |
| } |
| |
| void AndroidCameraInput::cancelAllCommands() |
| { |
| LOGV("cancelAllCommands"); |
| OSCL_LEAVE(OsclErrNotSupported); |
| } |
| |
| void AndroidCameraInput::setObserver( |
| PvmiConfigAndCapabilityCmdObserver* aObserver) |
| { |
| LOGV("setObserver"); |
| OSCL_UNUSED_ARG(aObserver); |
| } |
| |
| PVMFStatus AndroidCameraInput::getParametersSync(PvmiMIOSession session, |
| PvmiKeyType identifier, |
| PvmiKvp*& params, |
| int& num_params, |
| PvmiCapabilityContext context) |
| { |
| LOGV("getParametersSync"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(context); |
| |
| params = NULL; |
| num_params = 0; |
| PVMFStatus status = PVMFFailure; |
| |
| if (!pv_mime_strcmp(identifier, OUTPUT_FORMATS_CAP_QUERY) || |
| !pv_mime_strcmp(identifier, OUTPUT_FORMATS_CUR_QUERY)) { |
| num_params = 1; |
| status = AllocateKvp(params, (PvmiKeyType)OUTPUT_FORMATS_VALTYPE, num_params); |
| if (status != PVMFSuccess) { |
| LOGE("AllocateKvp failed for OUTPUT_FORMATS_VALTYP"); |
| return status; |
| } |
| params[0].value.pChar_value = (char*)ANDROID_VIDEO_FORMAT; |
| } else if (!pv_mime_strcmp(identifier, VIDEO_OUTPUT_WIDTH_CUR_QUERY)) { |
| num_params = 1; |
| status = AllocateKvp(params, (PvmiKeyType)VIDEO_OUTPUT_WIDTH_CUR_VALUE, num_params); |
| if (status != PVMFSuccess) { |
| LOGE("AllocateKvp failed for VIDEO_OUTPUT_WIDTH_CUR_VALUE"); |
| return status; |
| } |
| params[0].value.uint32_value = mFrameWidth; |
| } else if (!pv_mime_strcmp(identifier, VIDEO_OUTPUT_HEIGHT_CUR_QUERY)) { |
| num_params = 1; |
| status = AllocateKvp(params, (PvmiKeyType)VIDEO_OUTPUT_HEIGHT_CUR_VALUE, num_params); |
| if (status != PVMFSuccess) { |
| LOGE("AllocateKvp failed for VIDEO_OUTPUT_HEIGHT_CUR_VALUE"); |
| return status; |
| } |
| params[0].value.uint32_value = mFrameHeight; |
| } else if (!pv_mime_strcmp(identifier, VIDEO_OUTPUT_FRAME_RATE_CUR_QUERY)) { |
| num_params = 1; |
| status = AllocateKvp(params, |
| (PvmiKeyType)VIDEO_OUTPUT_FRAME_RATE_CUR_VALUE, num_params); |
| if (status != PVMFSuccess) { |
| LOGE("AllocateKvp failed for VIDEO_OUTPUT_FRAME_RATE_CUR_VALUE"); |
| return status; |
| } |
| params[0].value.float_value = mFrameRate; |
| } else if (!pv_mime_strcmp(identifier, OUTPUT_TIMESCALE_CUR_QUERY)) { |
| num_params = 1; |
| status = AllocateKvp(params, (PvmiKeyType)OUTPUT_TIMESCALE_CUR_VALUE, num_params); |
| if (status != PVMFSuccess) { |
| LOGE("AllocateKvp failed for OUTPUT_TIMESCALE_CUR_VALUE"); |
| return status; |
| } |
| // TODO: |
| // is it okay to hardcode this as the timescale? |
| params[0].value.uint32_value = 1000; |
| } else if (!pv_mime_strcmp(identifier, PVMF_BUFFER_ALLOCATOR_KEY)) { |
| /* |
| * if( camera MIO does NOT allocate YUV buffers ) |
| * { |
| * OSCL_LEAVE(OsclErrNotSupported); |
| * return PVMFErrNotSupported; |
| * } |
| */ |
| |
| params = (PvmiKvp*)oscl_malloc(sizeof(PvmiKvp)); |
| if (!params ) |
| { |
| OSCL_LEAVE(OsclErrNoMemory); |
| return PVMFErrNoMemory; |
| } |
| params [0].value.key_specific_value = (PVInterface*)&mbufferAlloc; |
| status = PVMFSuccess; |
| } |
| |
| return status; |
| } |
| |
| PVMFStatus AndroidCameraInput::releaseParameters(PvmiMIOSession session, |
| PvmiKvp* parameters, |
| int num_elements) |
| { |
| LOGV("releaseParameters"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(num_elements); |
| |
| if (!parameters) { |
| LOGE("parameters is a NULL pointer"); |
| return PVMFFailure; |
| } |
| iAlloc.deallocate((OsclAny*)parameters); |
| return PVMFSuccess; |
| } |
| |
| void AndroidCameraInput::createContext(PvmiMIOSession session, |
| PvmiCapabilityContext& context) |
| { |
| LOGV("createContext"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(context); |
| } |
| |
| void AndroidCameraInput::setContextParameters(PvmiMIOSession session, |
| PvmiCapabilityContext& context, |
| PvmiKvp* parameters, |
| int num_parameter_elements) |
| { |
| LOGV("setContextParameters"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(context); |
| OSCL_UNUSED_ARG(parameters); |
| OSCL_UNUSED_ARG(num_parameter_elements); |
| } |
| |
| void AndroidCameraInput::DeleteContext(PvmiMIOSession session, |
| PvmiCapabilityContext& context) |
| { |
| LOGV("DeleteContext"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(context); |
| } |
| |
| void AndroidCameraInput::setParametersSync(PvmiMIOSession session, |
| PvmiKvp* parameters, |
| int num_elements, |
| PvmiKvp*& ret_kvp) |
| { |
| LOGV("setParametersSync"); |
| OSCL_UNUSED_ARG(session); |
| PVMFStatus status = PVMFSuccess; |
| ret_kvp = NULL; |
| for (int32 i = 0; i < num_elements; ++i) { |
| status = VerifyAndSetParameter(&(parameters[i]), true); |
| if (status != PVMFSuccess) { |
| LOGE("VerifiyAndSetParameter failed on parameter #%d", i); |
| ret_kvp = &(parameters[i]); |
| OSCL_LEAVE(OsclErrArgument); |
| return; |
| } |
| } |
| } |
| |
| PVMFCommandId AndroidCameraInput::setParametersAsync(PvmiMIOSession session, |
| PvmiKvp* parameters, |
| int num_elements, |
| PvmiKvp*& ret_kvp, |
| OsclAny* context) |
| { |
| LOGV("setParametersAsync"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(parameters); |
| OSCL_UNUSED_ARG(num_elements); |
| OSCL_UNUSED_ARG(ret_kvp); |
| OSCL_UNUSED_ARG(context); |
| OSCL_LEAVE(OsclErrNotSupported); |
| return -1; |
| } |
| |
| uint32 AndroidCameraInput::getCapabilityMetric (PvmiMIOSession session) |
| { |
| LOGV("getCapabilityMetric"); |
| OSCL_UNUSED_ARG(session); |
| return 0; |
| } |
| |
| PVMFStatus AndroidCameraInput::verifyParametersSync(PvmiMIOSession session, |
| PvmiKvp* parameters, |
| int num_elements) |
| { |
| LOGV("verifyParametersSync"); |
| OSCL_UNUSED_ARG(session); |
| OSCL_UNUSED_ARG(parameters); |
| OSCL_UNUSED_ARG(num_elements); |
| return PVMFErrNotSupported; |
| } |
| |
| |
| void AndroidCameraInput::SetFrameSize(int w, int h) |
| { |
| LOGV("SetFrameSize"); |
| if (iState != STATE_IDLE) { |
| LOGE("SetFrameSize called in an invalid state(%d)", iState); |
| return; |
| } |
| |
| mFrameWidth = w; |
| mFrameHeight = h; |
| FrameSizeChanged(); |
| } |
| |
| void AndroidCameraInput::SetFrameRate(int fps) |
| { |
| LOGV("SetFrameRate"); |
| if (iState != STATE_IDLE) { |
| LOGE("SetFrameRate called in an invalid state(%d)", iState); |
| return; |
| } |
| |
| mFrameRate = (float)fps; |
| } |
| |
| void AndroidCameraInput::FrameSizeChanged() |
| { |
| LOGV("FrameSizeChanged"); |
| if (iState != STATE_IDLE) { |
| LOGE("FrameSizeChanged called in an invalid state(%d)", iState); |
| return; |
| } |
| |
| // Reinitialize the preview surface in case it was set up before now |
| if (mSurface != NULL) { |
| SetPreviewSurface(mSurface); |
| } |
| } |
| |
| void AndroidCameraInput::Run() |
| { |
| LOGV("Run"); |
| |
| // dequeue frame buffers and write to peer |
| if (NULL != iPeer) { |
| if (iState != STATE_STARTED) { |
| ReleaseQueuedFrames(); |
| } |
| iFrameQueueMutex.Lock(); |
| while (!iFrameQueue.empty()) { |
| AndroidCameraInputMediaData data = iFrameQueue[0]; |
| |
| uint32 writeAsyncID = 0; |
| OsclLeaveCode error = OsclErrNone; |
| uint8 *ptr = (uint8*) (data.iFrameBuffer->pointer()); |
| if (ptr) { |
| OSCL_TRY(error,writeAsyncID = iPeer->writeAsync(PVMI_MEDIAXFER_FMT_TYPE_DATA, 0, ptr, |
| data.iFrameSize, data.iXferHeader);); |
| } else { |
| //FIXME Check why camera sends NULL frames |
| LOGE("Ln %d ERROR null pointer", __LINE__); |
| error = OsclErrBadHandle; |
| } |
| |
| if (OsclErrNone == error) { |
| iFrameQueue.erase(iFrameQueue.begin()); |
| data.iId = writeAsyncID; |
| iSentMediaData.push_back(data); |
| LOGV("Ln %d Run writeAsync writeAsyncID %d", __LINE__, writeAsyncID); |
| } else { |
| //FIXME resend the frame later if ( OsclErrBusy == error) |
| LOGE("Ln %d Run writeAsync error %d", __LINE__, error); |
| //release buffer immediately if write fails |
| mCamera->releaseRecordingFrame(data.iFrameBuffer); |
| iFrameQueue.erase(iFrameQueue.begin()); |
| iWriteState = EWriteBusy; |
| break; |
| } |
| } |
| iFrameQueueMutex.Unlock(); |
| } |
| |
| PVMFStatus status = PVMFFailure; |
| |
| if (!iCmdQueue.empty()) { |
| AndroidCameraInputCmd cmd = iCmdQueue[0]; |
| iCmdQueue.erase(iCmdQueue.begin()); |
| |
| switch(cmd.iType) { |
| |
| case CMD_INIT: |
| status = DoInit(); |
| break; |
| |
| case CMD_START: |
| status = DoStart(); |
| break; |
| |
| case CMD_PAUSE: |
| status = DoPause(); |
| break; |
| |
| case CMD_FLUSH: |
| status = DoFlush(cmd); |
| break; |
| |
| case CMD_RESET: |
| status = DoReset(); |
| break; |
| |
| case CMD_STOP: |
| status = DoStop(cmd); |
| break; |
| |
| case DATA_EVENT: |
| // this is internal only - don't send RequestCompleted |
| DoRead(); |
| status = PVMFPending; |
| break; |
| |
| case CMD_QUERY_UUID: |
| case CMD_QUERY_INTERFACE: |
| status = PVMFSuccess; |
| break; |
| |
| // these commands all fail |
| case CMD_CANCEL_ALL_COMMANDS: |
| case CMD_CANCEL_COMMAND: |
| default: |
| break; |
| } |
| // do RequestCompleted unless command is still pending |
| if (status != PVMFPending) { |
| DoRequestCompleted(cmd, status); |
| } |
| } |
| |
| if (!iCmdQueue.empty()) { |
| // Run again if there are more things to process |
| RunIfNotReady(); |
| } |
| } |
| |
| PVMFCommandId AndroidCameraInput::AddCmdToQueue(AndroidCameraInputCmdType aType, |
| const OsclAny* aContext, |
| OsclAny* aData) |
| { |
| LOGV("AddCmdToQueue"); |
| if (aType == DATA_EVENT) { |
| LOGE("Invalid argument"); |
| OSCL_LEAVE(OsclErrArgument); |
| return -1; |
| } |
| |
| AndroidCameraInputCmd cmd; |
| cmd.iType = aType; |
| cmd.iContext = OSCL_STATIC_CAST(OsclAny*, aContext); |
| cmd.iData = aData; |
| cmd.iId = iCmdIdCounter; |
| ++iCmdIdCounter; |
| |
| // TODO: |
| // Check against out of memory failure |
| int err = 0; |
| OSCL_TRY(err, iCmdQueue.push_back(cmd)); |
| OSCL_FIRST_CATCH_ANY(err, LOGE("Out of memory"); return -1;); |
| RunIfNotReady(); |
| return cmd.iId; |
| } |
| |
| void AndroidCameraInput::AddDataEventToQueue(uint32 aMicroSecondsToEvent) |
| { |
| LOGV("AddDataEventToQueue"); |
| AndroidCameraInputCmd cmd; |
| cmd.iType = DATA_EVENT; |
| |
| int err = 0; |
| OSCL_TRY(err, iCmdQueue.push_back(cmd)); |
| OSCL_FIRST_CATCH_ANY(err, LOGE("Out of memory"); return;); |
| RunIfNotReady(aMicroSecondsToEvent); |
| } |
| |
| void AndroidCameraInput::DoRequestCompleted(const AndroidCameraInputCmd& aCmd, PVMFStatus aStatus, OsclAny* aEventData) |
| { |
| LOGV("DoRequestCompleted"); |
| PVMFCmdResp response(aCmd.iId, aCmd.iContext, aStatus, aEventData); |
| |
| for (uint32 i = 0; i < iObservers.size(); i++) { |
| iObservers[i]->RequestCompleted(response); |
| } |
| } |
| |
| PVMFStatus AndroidCameraInput::DoInit() |
| { |
| LOGV("DoInit()"); |
| iState = STATE_INITIALIZED; |
| iMilliSecondsPerDataEvent = (int32)(1000 / mFrameRate); |
| iMicroSecondsPerDataEvent = (int32)(1000000 / mFrameRate); |
| iDataEventCounter = 0; |
| |
| // create a camera if the app didn't supply one |
| if (mCamera == 0) { |
| mCamera = Camera::connect(); |
| } |
| |
| // always call setPreviewDisplay() regardless whether mCamera is just created or not |
| // return failure if no display surface is available |
| if (mCamera != NULL && mSurface != NULL) { |
| mCamera->setPreviewDisplay(mSurface); |
| } else { |
| if (mCamera == NULL) { |
| LOGE("Camera is not available"); |
| } else if (mSurface == NULL) { |
| LOGE("No surface is available for display"); |
| } |
| return PVMFFailure; |
| } |
| |
| LOGD("Intended mFrameWidth=%d, mFrameHeight=%d ",mFrameWidth, mFrameHeight); |
| String8 s = mCamera->getParameters(); |
| if (s.length() == 0) { |
| LOGE("Failed to get camera(%p) parameters", mCamera.get()); |
| return PVMFFailure; |
| } |
| CameraParameters p(s); |
| p.setPreviewSize(mFrameWidth, mFrameHeight); |
| p.setPreviewFrameRate(mFrameRate); |
| s = p.flatten(); |
| if (mCamera->setParameters(s) != NO_ERROR) { |
| LOGE("Failed to set camera(%p) parameters", mCamera.get()); |
| return PVMFFailure; |
| } |
| |
| // Since we may not honor the preview size that app has requested |
| // It is a good idea to get the actual preview size and used it |
| // for video recording. |
| CameraParameters newCameraParam(mCamera->getParameters()); |
| int32 width, height; |
| newCameraParam.getPreviewSize(&width, &height); |
| if (width < 0 || height < 0) { |
| LOGE("Failed to get camera(%p) preview size", mCamera.get()); |
| return PVMFFailure; |
| } |
| if (width != mFrameWidth || height != mFrameHeight) { |
| LOGE("Mismatch between the intended frame size (%dx%d) and the available frame size (%dx%d)", mFrameWidth, mFrameHeight, width, height); |
| return PVMFFailure; |
| } |
| LOGD("Actual mFrameWidth=%d, mFrameHeight=%d ",mFrameWidth, mFrameHeight); |
| if (mCamera->startPreview() != NO_ERROR) { |
| LOGE("Failed to start camera(%p) preview", mCamera.get()); |
| return PVMFFailure; |
| } |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::DoStart() |
| { |
| LOGV("DoStart"); |
| |
| iAudioFirstFrameTs = 0; |
| // Set the clock state observer |
| if (iAuthorClock) { |
| iAuthorClock->ConstructMediaClockNotificationsInterface(iClockNotificationsInf, *this); |
| |
| if (iClockNotificationsInf == NULL) { |
| return PVMFErrNoMemory; |
| } |
| |
| iClockNotificationsInf->SetClockStateObserver(*this); |
| } |
| |
| PVMFStatus status = PVMFFailure; |
| iWriteState = EWriteOK; |
| if (mCamera == NULL) { |
| status = PVMFFailure; |
| LOGE("mCamera is not initialized yet"); |
| } else { |
| mCamera->setListener(mListener); |
| if (mCamera->startRecording() != NO_ERROR) { |
| LOGE("mCamera start recording failed"); |
| status = PVMFFailure; |
| } else { |
| iState = STATE_STARTED; |
| status = PVMFSuccess; |
| } |
| } |
| AddDataEventToQueue(iMilliSecondsPerDataEvent); |
| return status; |
| } |
| |
| PVMFStatus AndroidCameraInput::DoPause() |
| { |
| LOGV("DoPause"); |
| iState = STATE_PAUSED; |
| return PVMFSuccess; |
| } |
| |
| // Does this work for reset? |
| PVMFStatus AndroidCameraInput::DoReset() |
| { |
| LOGD("DoReset: E"); |
| // Remove and destroy the clock state observer |
| RemoveDestroyClockObs(); |
| iDataEventCounter = 0; |
| iAudioLossDuration = 0; |
| iWriteState = EWriteOK; |
| if ( (iState == STATE_STARTED) || (iState == STATE_PAUSED) ) { |
| if (mCamera != NULL) { |
| mCamera->setListener(NULL); |
| mCamera->stopRecording(); |
| ReleaseQueuedFrames(); |
| } |
| } |
| while(!iCmdQueue.empty()) |
| { |
| AndroidCameraInputCmd cmd = iCmdQueue[0]; |
| iCmdQueue.erase(iCmdQueue.begin()); |
| } |
| Cancel(); |
| iState = STATE_IDLE; |
| LOGD("DoReset: X"); |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::DoFlush(const AndroidCameraInputCmd& aCmd) |
| { |
| LOGV("DoFlush"); |
| // This method should stop capturing media data but continue to send |
| // captured media data that is already in buffer and then go to |
| // stopped state. |
| // However, in this case of file input we do not have such a buffer for |
| // captured data, so this behaves the same way as stop. |
| return DoStop(aCmd); |
| } |
| |
| PVMFStatus AndroidCameraInput::DoStop(const AndroidCameraInputCmd& aCmd) |
| { |
| LOGD("DoStop: E"); |
| |
| // Remove and destroy the clock state observer |
| RemoveDestroyClockObs(); |
| |
| iDataEventCounter = 0; |
| iWriteState = EWriteOK; |
| if (mCamera != NULL) { |
| mCamera->setListener(NULL); |
| mCamera->stopRecording(); |
| ReleaseQueuedFrames(); |
| } |
| iState = STATE_STOPPED; |
| LOGD("DoStop: X"); |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::DoRead() |
| { |
| LOGV("DoRead"); |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::AllocateKvp(PvmiKvp*& aKvp, |
| PvmiKeyType aKey, |
| int32 aNumParams) |
| { |
| LOGV("AllocateKvp"); |
| uint8* buf = NULL; |
| uint32 keyLen = oscl_strlen(aKey) + 1; |
| int32 err = 0; |
| |
| OSCL_TRY(err, |
| buf = (uint8*)iAlloc.allocate(aNumParams * (sizeof(PvmiKvp) + keyLen)); |
| if (!buf) { |
| LOGE("Failed to allocate memory to Kvp"); |
| OSCL_LEAVE(OsclErrNoMemory); |
| } |
| ); |
| OSCL_FIRST_CATCH_ANY(err, |
| LOGE("kvp allocation failed"); |
| return PVMFErrNoMemory; |
| ); |
| |
| PvmiKvp* curKvp = aKvp = new (buf) PvmiKvp; |
| buf += sizeof(PvmiKvp); |
| for (int32 i = 1; i < aNumParams; ++i) { |
| curKvp += i; |
| curKvp = new (buf) PvmiKvp; |
| buf += sizeof(PvmiKvp); |
| } |
| |
| for (int32 i = 0; i < aNumParams; ++i) { |
| aKvp[i].key = (char*)buf; |
| oscl_strncpy(aKvp[i].key, aKey, keyLen); |
| buf += keyLen; |
| } |
| |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::VerifyAndSetParameter(PvmiKvp* aKvp, |
| bool aSetParam) |
| { |
| LOGV("VerifyAndSetParameter"); |
| |
| if (!aKvp) { |
| LOGE("Invalid key-value pair"); |
| return PVMFFailure; |
| } |
| |
| if (!pv_mime_strcmp(aKvp->key, OUTPUT_FORMATS_VALTYPE)) { |
| if(pv_mime_strcmp(aKvp->value.pChar_value, ANDROID_VIDEO_FORMAT) == 0) { |
| return PVMFSuccess; |
| } else { |
| LOGE("Unsupported format %d", aKvp->value.uint32_value); |
| return PVMFFailure; |
| } |
| } |
| else if (pv_mime_strcmp(aKvp->key, PVMF_AUTHORING_CLOCK_KEY) == 0) |
| { |
| LOGV("AndroidCameraInput::VerifyAndSetParameter() PVMF_AUTHORING_CLOCK_KEY value %p", aKvp->value.key_specific_value); |
| if( (NULL == aKvp->value.key_specific_value) && ( iAuthorClock ) ) |
| { |
| RemoveDestroyClockObs(); |
| } |
| iAuthorClock = (PVMFMediaClock*)aKvp->value.key_specific_value; |
| return PVMFSuccess; |
| } |
| |
| LOGE("Unsupported parameter(%s)", aKvp->key); |
| return PVMFFailure; |
| } |
| |
| void AndroidCameraInput::SetPreviewSurface(const sp<android::ISurface>& surface) |
| { |
| LOGV("SetPreviewSurface"); |
| mSurface = surface; |
| |
| if (mCamera != NULL) { |
| mCamera->setPreviewDisplay(surface); |
| } |
| } |
| |
| PVMFStatus AndroidCameraInput::SetCamera(const sp<android::ICamera>& camera) |
| { |
| LOGV("SetCamera"); |
| mFlags &= ~ FLAGS_SET_CAMERA | FLAGS_HOT_CAMERA; |
| if (camera == NULL) { |
| LOGV("camera is NULL"); |
| return PVMFErrArgument; |
| } |
| |
| // Connect our client to the camera remote |
| mCamera = Camera::create(camera); |
| if (mCamera == NULL) { |
| LOGE("Unable to connect to camera"); |
| return PVMFErrNoResources; |
| } |
| |
| LOGV("Connected to camera"); |
| mFlags |= FLAGS_SET_CAMERA; |
| if (mCamera->previewEnabled()) { |
| mFlags |= FLAGS_HOT_CAMERA; |
| LOGV("camera is hot"); |
| } |
| return PVMFSuccess; |
| } |
| |
| PVMFStatus AndroidCameraInput::postWriteAsync(nsecs_t timestamp, const sp<IMemory>& frame) |
| { |
| LOGV("postWriteAsync"); |
| |
| if (frame == NULL) { |
| LOGE("frame is a NULL pointer"); |
| return PVMFFailure; |
| } |
| |
| if((!iPeer) || (!isRecorderStarting()) || (iWriteState == EWriteBusy) || (NULL == iAuthorClock) || (iAuthorClock->GetState() != PVMFMediaClock::RUNNING)) { |
| if( NULL == iAuthorClock ) |
| { |
| LOGE("Recording is not ready (iPeer %p iState %d iWriteState %d iAuthorClock NULL), frame dropped", iPeer, iState, iWriteState); |
| } |
| else |
| { |
| LOGE("Recording is not ready (iPeer %p iState %d iWriteState %d iClockState %d), frame dropped", iPeer, iState, iWriteState, iAuthorClock->GetState()); |
| } |
| mCamera->releaseRecordingFrame(frame); |
| return PVMFSuccess; |
| } |
| |
| // Now compare the video timestamp with the AudioFirstTimestamp |
| // if video timestamp is earlier to audio drop it |
| // or else send it downstream with correct timestamp |
| uint32 ts = (uint32)(timestamp / 1000000L); |
| |
| // In cases of Video Only recording iAudioFirstFrameTs will always be zero, |
| // so for such cases assign iAudioFirstFrameTs to Video's first sample TS |
| // which will make Video samples to start with Timestamp zero. |
| if (iAudioFirstFrameTs == 0) |
| iAudioFirstFrameTs = ts; |
| |
| iAudioLossMutex.Lock(); |
| if (ts < iAudioFirstFrameTs + iAudioLossDuration) { |
| // Drop the frame |
| iAudioLossMutex.Unlock(); |
| mCamera->releaseRecordingFrame(frame); |
| return PVMFSuccess; |
| } else { |
| // calculate timestamp as offset from start time plus lost audio |
| ts -= (iAudioFirstFrameTs + iAudioLossDuration); |
| } |
| iAudioLossMutex.Unlock(); |
| |
| // Determine how much video to drop so when we resync to the audio |
| // time we don't go into old video (we need increasing timestamps) |
| if (ts <= iTimeStamp) { |
| LOGD("Dropping video frame to catch up for audio ts %lu, dropUntil %lu", ts, iTimeStamp); |
| mCamera->releaseRecordingFrame(frame); |
| return PVMFSuccess; |
| } |
| |
| // Make sure that no two samples have the same timestamp |
| if (iDataEventCounter != 0) { |
| if (iTimeStamp != ts) { |
| iTimeStamp = ts; |
| } else { |
| ++iTimeStamp; |
| } |
| } |
| |
| // get memory offset for frame buffer |
| ssize_t offset = 0; |
| size_t size = 0; |
| sp<IMemoryHeap> heap = frame->getMemory(&offset, &size); |
| LOGV("postWriteAsync: ID = %d, base = %p, offset = %ld, size = %d pointer %p", heap->getHeapID(), heap->base(), offset, size, frame->pointer()); |
| |
| // queue data to be sent to peer |
| AndroidCameraInputMediaData data; |
| data.iXferHeader.seq_num = iDataEventCounter++; |
| data.iXferHeader.timestamp = iTimeStamp; |
| data.iXferHeader.flags = 0; |
| data.iXferHeader.duration = 0; |
| data.iXferHeader.stream_id = 0; |
| data.iFrameSize = size; |
| data.iFrameBuffer = frame; |
| |
| // lock muteddx and queue frame buffer |
| iFrameQueueMutex.Lock(); |
| {//compose private data |
| //could size be zero? |
| if(NULL == pPmemInfo) |
| { |
| int iCalculateNoOfCameraPreviewBuffer = heap->getSize() / size; |
| LOGV("heap->getSize() = %d, size of each frame= %d, iCalculateNoOfCameraPreviewBuffer = %d", heap->getSize(), size, iCalculateNoOfCameraPreviewBuffer); |
| pPmemInfo = new CAMERA_PMEM_INFO[iCalculateNoOfCameraPreviewBuffer]; |
| if(NULL == pPmemInfo) |
| { |
| LOGE("Failed to allocate the camera pmem info buffer array. iCalculateNoOfCameraPreviewBuffer %d",iCalculateNoOfCameraPreviewBuffer); |
| iFrameQueueMutex.Unlock(); |
| return PVMFFailure; |
| } |
| } |
| |
| int iIndex = offset / size; |
| pPmemInfo[iIndex].pmem_fd = heap->getHeapID(); |
| pPmemInfo[iIndex].offset = offset; |
| data.iXferHeader.private_data_ptr = ((OsclAny*)(&pPmemInfo[iIndex])); |
| LOGV("struct size %d, pmem_info - %x, &pmem_info[iIndex] - %x, iIndex =%d, pmem_info.pmem_fd = %d, pmem_info.offset = %d", sizeof(CAMERA_PMEM_INFO), pPmemInfo, &pPmemInfo[iIndex], iIndex, pPmemInfo[iIndex].pmem_fd, pPmemInfo[iIndex].offset ); |
| } |
| |
| iFrameQueue.push_back(data); |
| iFrameQueueMutex.Unlock(); |
| RunIfNotReady(); |
| |
| return PVMFSuccess; |
| } |
| |
| // Value is expected to be in ms |
| void AndroidCameraInput::setAudioLossDuration(uint32 duration) |
| { |
| iAudioLossMutex.Lock(); |
| LOGD("Update for lost audio for %lu for existing duration %lu", duration, iAudioLossDuration); |
| iAudioLossDuration += duration; |
| iAudioLossMutex.Unlock(); |
| } |
| |
| // camera callback interface |
| void AndroidCameraInputListener::postData(int32_t msgType, const sp<IMemory>& dataPtr) |
| { |
| } |
| |
| void AndroidCameraInputListener::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) |
| { |
| if ((mCameraInput != NULL) && (msgType == CAMERA_MSG_VIDEO_FRAME)) { |
| mCameraInput->postWriteAsync(timestamp, dataPtr); |
| } |
| } |
| |
| void AndroidCameraInput::NotificationsInterfaceDestroyed() |
| { |
| iClockNotificationsInf = NULL; |
| } |
| |
| void AndroidCameraInput::ClockStateUpdated() |
| { |
| PVMFMediaClock::PVMFMediaClockState iClockState = iAuthorClock->GetState(); |
| if ((iClockState == PVMFMediaClock::RUNNING) && (iAudioFirstFrameTs == 0)) { |
| // Get the clock time here |
| // this will be the time of first audio frame capture |
| bool tmpbool = false; |
| iAuthorClock->GetCurrentTime32(iAudioFirstFrameTs, tmpbool, PVMF_MEDIA_CLOCK_MSEC); |
| LOGV("Audio first ts %d", iAudioFirstFrameTs); |
| } |
| } |
| |
| void AndroidCameraInput::RemoveDestroyClockObs() |
| { |
| if (iAuthorClock != NULL) { |
| if (iClockNotificationsInf != NULL) { |
| iClockNotificationsInf->RemoveClockStateObserver(*this); |
| iAuthorClock->DestroyMediaClockNotificationsInterface(iClockNotificationsInf); |
| iClockNotificationsInf = NULL; |
| } |
| } |
| } |
| |
| |
