status_t CameraHardwareStub::takePicture()
{
stopPreview();
if (createThread(beginPictureThread, this) == false)
return UNKNOWN_ERROR;
return NO_ERROR;
}
Camera::~Camera()
{
m_state = CAMERA_SHUTDOWN;
emit stateChanged(m_state);
stopPreview();
if (m_controllerThread != nullptr) {
m_controllerThread->quit();
}
if (m_eventListener)
m_eventListener->stopListening();
if (m_eventListenerThread)
m_eventListenerThread->quit();
if (m_controllerThread) {
// Wait at most 5 seconds for thread to stop
if (!m_controllerThread->wait(5 * 1000))
std::cout << "~Camera(" << m_name.toStdString() << ") timed out while waiting for controller thread" << std::endl;
}
if (m_eventListenerThread) {
// Wait at most 5 seconds for thread to stop
if (!m_eventListenerThread->wait(5 * 1000))
std::cout << "~Camera(" << m_name.toStdString() << ") timed out while waiting for event listener thread" << std::endl;
}
delete m_controller;
delete m_controllerThread;
delete m_eventListener;
delete m_eventListenerThread;
}
bool QFESPIMB040SimpleCameraConfig::lockCamera(QFExtension** extension, QFExtensionCamera** ecamera, int* camera, QString* previewSettingsFilename) {
if (locked || (!actDisConnect->isChecked()) || (!viewData.camera) || (!viewData.extension)) {
*camera=-1;
*extension=NULL;
*ecamera=NULL;
return false;
}
restartPreview=actStartStopPreview->isChecked();
actStartStopPreview->setChecked(false);
stopPreview();
//QApplication::processEvents();
//QApplication::processEvents();
//QApplication::processEvents();
displayStates(QFESPIMB040SimpleCameraConfig::Locked);
QString filename="";
*previewSettingsFilename="";
//if (cmbPreviewConfiguration->currentIndex()>=0) *previewSettingsFilename=cmbPreviewConfiguration->itemData(cmbPreviewConfiguration->currentIndex()).toString();
*previewSettingsFilename=cmbPreviewConfiguration->currentConfigFilename();
*extension=viewData.extension;
*ecamera=viewData.camera;
*camera=viewData.usedCamera;
locked=true;
return true;
}
// -----------------------------------------------------------------------------
// TTCutPreview constructor
// -----------------------------------------------------------------------------
TTCutPreview::TTCutPreview(QWidget* parent, int prevW, int prevH)
: QDialog(parent)
{
setupUi(this);
// set the objects name
setObjectName(c_name);
// message logger instance
log = TTMessageLogger::getInstance();
// set desired video width x height
previewWidth = prevW;
previewHeight = prevH;
// initialize some member
mplayerProc = NULL;
mplexProc = NULL;
isPlaying = false;
// set the frame size according the video size
videoFrame->setMinimumSize( QSize( previewWidth, previewHeight ) );
videoFrame->setMaximumSize( QSize( previewWidth, previewHeight ) );
cbCutPreview->setEditable( false );
cbCutPreview->setMinimumSize( 160, 20 );
cbCutPreview->setInsertPolicy( QComboBox::InsertAfterCurrent );
// connect signals and slots
connect( cbCutPreview, SIGNAL( highlighted(int) ), SLOT( selectCut(int) ) );
connect( pbPlay, SIGNAL( clicked() ), SLOT( playPreview() ) );
connect( pbStop, SIGNAL( clicked() ), SLOT( stopPreview() ) );
connect( pbExit, SIGNAL( clicked() ), SLOT( exitPreview() ) );
}
int SecCamera::startSnapshot(size_t* captureSize)
{
LOG_TIME_START(0);
stopPreview();
LOG_TIME_END(0);
int ret;
LOG_TIME_START(1); // prepare
ret = _v4l2Cam->setupBufs(_snapshotWidth, _snapshotHeight, _snapshotPixfmt,
1, 1);
CHECK_EQ(ret, 1);
ret = _v4l2Cam->mapBuf(0);
CHECK_EQ(ret, 0);
_v4l2Cam->qBuf(0);
_v4l2Cam->startStream(true);
LOG_TIME_END(1);
LOG_CAMERA("%s: stopPreview(%lu), prepare(%lu) us",
__func__, LOG_TIME(0), LOG_TIME(1));
_v4l2Cam->mapBufInfo(0, NULL, captureSize);
return 0;
}
void QAndroidCameraSession::setState(QCamera::State state)
{
// If the application is inactive, the camera shouldn't be started. Save the desired state
// instead and it will be set when the application becomes active.
if (qApp->applicationState() != Qt::ApplicationActive) {
m_savedState = state;
return;
}
if (m_state == state)
return;
switch (state) {
case QCamera::UnloadedState:
close();
break;
case QCamera::LoadedState:
case QCamera::ActiveState:
if (!m_camera && !open()) {
emit error(QCamera::CameraError, QStringLiteral("Failed to open camera"));
return;
}
if (state == QCamera::ActiveState) {
if (!startPreview())
return;
} else if (state == QCamera::LoadedState) {
stopPreview();
}
break;
}
m_state = state;
emit stateChanged(m_state);
}
KbAnim* KbLight::addAnim(const AnimScript *base, const QStringList &keys, const QString& name, const QMap<QString, QVariant>& preset){
// Stop and restart all existing animations
stopPreview();
quint64 timestamp = QDateTime::currentMSecsSinceEpoch();
foreach(KbAnim* anim, _animList){
anim->stop();
anim->trigger(timestamp);
}
void QFESPIMB040SimpleCameraConfig::previewCurrentIndexChanged(int /*index*/) {
emit previewConfigChanged();
if (actStartStopPreview->isChecked()) { // just stop & resume, as this will load the new settings in the resume operation!
stopPreview();
actStartStopPreview->setChecked(true);
startStopPreview();
}
}
void ofApp::keyPressed(int key) {
if(key == ' ') {
switch(mode) {
case PREVIEW: stopPreview(); startRecord(); break;
case RECORD: stopRecord(); startPlayback(); break;
case PLAYBACK: stopPlayback(); startPreview(); break;
}
}
}
void QFESPIMB040SimpleCameraConfig::stop() {
//qDebug()<<"stop";
restartPreview=actStartStopPreview->isChecked();
stopPreview();
QElapsedTimer timer;
timer.start();
while (timer.elapsed()<150) {
QApplication::processEvents();
}
}
void QFESPIMB040SimpleCameraConfig::closeEvent ( QCloseEvent * /*event*/ ) {
stopPreview();
stopTimer();
//QApplication::processEvents();
if (camView) {
camView->hide();
}
// disconnect devices and close camera view:
disconnectDevice();
//qDebug()<<"closed";
}
status_t CameraHardware::takePicture(shutter_callback shutter_cb,
raw_callback raw_cb,
jpeg_callback jpeg_cb,
void* user)
{
stopPreview();
mShutterCallback = shutter_cb;
mRawPictureCallback = raw_cb;
mJpegPictureCallback = jpeg_cb;
mPictureCallbackCookie = user;
if (createThread(beginPictureThread, this) == false)
return -1;
return NO_ERROR;
}
void ResourcePreviewer::preview( ResourceItem * _item )
{
// stop any existing preview sounds
stopPreview();
// disable journalling of changes in our preview track
const bool j = engine::projectJournal()->isJournalling();
engine::projectJournal()->setJournalling( false );
engine::setSuppressMessages( true );
// handle individual resource types
bool handledItem = true;
switch( _item->type() )
{
case ResourceItem::TypePreset:
// restore default settings, in case we're going to load
// an incomplete preset
m_previewTrack->loadTrackSpecificSettings(
m_defaultSettings.content().
firstChild().toElement() );
ResourceAction( _item ).loadPreset( m_previewTrack );
m_previewTrack->midiPort()->setMode( MidiPort::Disabled );
break;
case ResourceItem::TypeSample:
case ResourceItem::TypePluginSpecificResource:
// restore default settings we are going to preview a
// sample (which should be played at a default
// instrument track)
m_previewTrack->loadTrackSpecificSettings(
m_defaultSettings.content().
firstChild().toElement() );
ResourceAction( _item ).loadByPlugin( m_previewTrack );
break;
default:
handledItem = false;
break;
}
// re-enable journalling
engine::setSuppressMessages( false );
engine::projectJournal()->setJournalling( j );
if( handledItem )
{
// playback default note
m_previewTrack->processInEvent(
midiEvent( MidiNoteOn, 0, DefaultKey, MidiMaxVelocity ),
midiTime() );
}
}
void VideoGrabber::Main()
{
if ( !channel ) return ;
PTRACE( 1, "Going to grab from video device" );
while ( run ) {
mutex.Wait();
State s = state;
mutex.Signal();
// prepare for the state...
closeDevices();
switch( s ) {
case SPreview:
if( !openDevices() ) {
stopPreview();
ancaInfo->setInt( VG_STATE, VG_IDLE );
}
break;
case SCall:
openReader();
break;
case SSleep:
break;
}
preparing = false;
// do
switch( s ) {
case SSleep:
case SCall:
goSleep();
break;
case SPreview:
while ( state == SPreview && run && !reconfigure ) {
channel->Read( buffer, bufferSize );
channel->Write( buffer, bufferSize );
Sleep( 50 );
}
}
}
}
int mm_app_open_rdi(int cam_id)
{
int rc = MM_CAMERA_OK;
int value = RDI_MASK;
mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);
if (pme->cam_mode == RDI_MODE) {
return rc;
}
if (MM_CAMERA_OK != (rc = stopPreview(cam_id))) {
CDBG_ERROR("%s:Stop preview err=%d\n", __func__, rc);
goto end;
}
pme->cam_mode = RDI_MODE;
end:
CDBG("%s: END, rc=%d\n", __func__, rc);
return rc;
}
int UVCCamera::release() {
ENTER();
stopPreview();
if (LIKELY(mDeviceHandle)) {
SAFE_DELETE(mPreview);
uvc_close(mDeviceHandle);
mDeviceHandle = NULL;
}
if (LIKELY(mDevice)) {
uvc_unref_device(mDevice);
mDevice = NULL;
}
clearCameraParams();
mCtrlSupports = mPUSupports = 0;
if (LIKELY(mFd)) {
close(mFd);
mFd = 0;
}
RETURN(0, int);
}
void QAndroidCameraSession::close()
{
if (!m_camera)
return;
stopPreview();
m_status = QCamera::UnloadingStatus;
emit statusChanged(m_status);
m_readyForCapture = false;
m_currentImageCaptureId = -1;
m_currentImageCaptureFileName.clear();
m_imageSettingsDirty = true;
m_camera->release();
delete m_camera;
m_camera = 0;
m_status = QCamera::UnloadedStatus;
emit statusChanged(m_status);
}
status_t BnCamera::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
LOGV("DISCONNECT");
CHECK_INTERFACE(ICamera, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_PREVIEW_DISPLAY: {
LOGV("SET_PREVIEW_DISPLAY");
CHECK_INTERFACE(ICamera, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setPreviewDisplay(surface));
return NO_ERROR;
} break;
case SET_FRAME_CALLBACK_FLAG: {
LOGV("SET_FRAME_CALLBACK_TYPE");
CHECK_INTERFACE(ICamera, data, reply);
int frame_callback_flag = data.readInt32();
setFrameCallbackFlag(frame_callback_flag);
return NO_ERROR;
} break;
case START_PREVIEW: {
LOGV("START_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(startPreview());
return NO_ERROR;
} break;
case STOP_PREVIEW: {
LOGV("STOP_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
stopPreview();
return NO_ERROR;
} break;
case AUTO_FOCUS: {
LOGV("AUTO_FOCUS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(autoFocus());
return NO_ERROR;
} break;
case TAKE_PICTURE: {
LOGV("TAKE_PICTURE");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(takePicture());
return NO_ERROR;
} break;
case SET_PARAMETERS: {
LOGV("SET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
String8 params(data.readString8());
reply->writeInt32(setParameters(params));
return NO_ERROR;
} break;
case GET_PARAMETERS: {
LOGV("GET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeString8(getParameters());
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ICamera, data, reply);
sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
reply->writeInt32(connect(cameraClient));
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t CameraHardware::takePicture()
{
stopPreview();
pictureThread();
return NO_ERROR;
}
