/*
* native public static long elapsedRealtimeNano();
*/
int64_t elapsedRealtimeNano()
{
#ifdef HAVE_ANDROID_OS
struct timespec ts;
int result;
int64_t timestamp;
#if DEBUG_TIMESTAMP
static volatile int64_t prevTimestamp;
static volatile int prevMethod;
#endif
static int s_fd = -1;
if (s_fd == -1) {
int fd = open("/dev/alarm", O_RDONLY);
if (android_atomic_cmpxchg(-1, fd, &s_fd)) {
close(fd);
}
}
result = ioctl(s_fd,
ANDROID_ALARM_GET_TIME(ANDROID_ALARM_ELAPSED_REALTIME), &ts);
if (result == 0) {
timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod, METHOD_IOCTL);
return timestamp;
}
// /dev/alarm doesn't exist, fallback to CLOCK_BOOTTIME
result = clock_gettime(CLOCK_BOOTTIME, &ts);
if (result == 0) {
timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod,
METHOD_CLOCK_GETTIME);
return timestamp;
}
// XXX: there was an error, probably because the driver didn't
// exist ... this should return
// a real error, like an exception!
timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod,
METHOD_SYSTEMTIME);
return timestamp;
#else
return systemTime(SYSTEM_TIME_MONOTONIC);
#endif
}
/*
* native public static long elapsedRealtime();
*/
int64_t elapsedRealtime()
{
#ifdef HAVE_ANDROID_OS
static int s_fd = -1;
if (s_fd == -1) {
int fd = open("/dev/alarm", O_RDONLY);
if (android_atomic_cmpxchg(-1, fd, &s_fd)) {
close(fd);
}
}
struct timespec ts;
int result = ioctl(s_fd,
ANDROID_ALARM_GET_TIME(ANDROID_ALARM_ELAPSED_REALTIME), &ts);
if (result == 0) {
int64_t when = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
return (int64_t) nanoseconds_to_milliseconds(when);
} else {
// XXX: there was an error, probably because the driver didn't
// exist ... this should return
// a real error, like an exception!
int64_t when = systemTime(SYSTEM_TIME_MONOTONIC);
return (int64_t) nanoseconds_to_milliseconds(when);
}
#else
int64_t when = systemTime(SYSTEM_TIME_MONOTONIC);
return (int64_t) nanoseconds_to_milliseconds(when);
#endif
}
/*
* native public static long elapsedRealtimeNano();
*/
int64_t elapsedRealtimeNano() {
#if defined(__linux__)
struct timespec ts;
int err = clock_gettime(CLOCK_BOOTTIME, &ts);
if (CC_UNLIKELY(err)) {
// This should never happen, but just in case ...
ALOGE("clock_gettime(CLOCK_BOOTTIME) failed: %s", strerror(errno));
return 0;
}
return seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
#else
return systemTime(SYSTEM_TIME_MONOTONIC);
#endif
}
status_t QCameraStream_preview::processPreviewFrame (
mm_camera_super_buf_t *frame)
{
ALOGV("%s",__func__);
int err = 0;
int msgType = 0;
int i;
camera_frame_metadata_t *metadata = NULL;
Mutex::Autolock lock(mLock);
if(!mActive) {
ALOGE("Preview Stopped. Returning callback");
return NO_ERROR;
}
if(mHalCamCtrl==NULL) {
ALOGE("%s: X: HAL control object not set",__func__);
/*Call buf done*/
return BAD_VALUE;
}
nsecs_t timeStamp = seconds_to_nanoseconds(frame->bufs[0]->ts.tv_sec) ;
timeStamp += frame->bufs[0]->ts.tv_nsec;
if(mFirstFrameRcvd == false) {
//mm_camera_util_profile("HAL: First preview frame received");
mFirstFrameRcvd = true;
}
// dumpFrameToFile(frame->bufs[0]);
mPreviewMemoryLock.lock();
mNotifyBuffer[frame->bufs[0]->buf_idx] = *frame;
ALOGE("processPreviewFrame: timeStamp = %lld", (int64_t)timeStamp);
err = mPreviewWindow->enqueue_buffer(mPreviewWindow, (int64_t)timeStamp,
&mPreviewMemory.buffer_handle[frame->bufs[0]->buf_idx]);
if(err != 0) {
ALOGE("%s: enqueue_buffer failed, err = %d", __func__, err);
}
mPreviewMemory.local_flag[frame->bufs[0]->buf_idx] = BUFFER_NOT_OWNED;
buffer_handle_t *buffer_handle = NULL;
err = mPreviewWindow->dequeue_buffer(mPreviewWindow, &buffer_handle);
if (err == NO_ERROR && buffer_handle != NULL) {
int rc = MM_CAMERA_OK;
ALOGD("%s: dequed buf hdl =%p", __func__, *buffer_handle);
for(i = 0; i < mPreviewMemory.buffer_count; i++) {
if(mPreviewMemory.buffer_handle[i] == *buffer_handle) {
ALOGE("<DEBUG2>:Found buffer in idx:%d",i);
break;
}
}
if (mPreviewMemory.local_flag[i] == BUFFER_NOT_REGGED) {
mm_camera_buf_def_t buf = mDisplayBuf[i];
mPreviewMemory.local_flag[i] = BUFFER_OWNED;
rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, &buf);
} else {
mPreviewMemory.local_flag[i] = BUFFER_OWNED;
rc = p_mm_ops->ops->qbuf(mCameraHandle, mChannelId, mNotifyBuffer[i].bufs[0]);
}
if(rc != MM_CAMERA_OK) {
/* how to handle the error of qbuf? */
ALOGE("BUF DONE FAILED");
}
}
/* Save the last displayed frame. We'll be using it to fill the gap between
when preview stops and postview start during snapshot.*/
mLastQueuedFrame = &(mDisplayBuf[frame->bufs[0]->buf_idx]);
mPreviewMemoryLock.unlock();
return NO_ERROR;
}
EGLuint64NV eglGetSystemTimeFrequencyNV() {
// Number of "ticks" per second.
return seconds_to_nanoseconds(1);
}
