bool AudioOutputPortAudio::close()
{
    DPTR_D(AudioOutputPortAudio);
    QMutexLocker lock(&d.mutex);
    Q_UNUSED(lock);
    resetStatus();
    bool available_old = d.available;
    d.available = false;
    PaError err = paNoError;
    if (!d.stream) {
        return true;
    }
    err = Pa_StopStream(d.stream); //may be already stopped: paStreamIsStopped
    if (err != paNoError) {
        d.available = available_old;
        qWarning("Stop portaudio stream error: %s", Pa_GetErrorText(err));
        //return err == paStreamIsStopped;
    }
    err = Pa_CloseStream(d.stream);
    if (err != paNoError) {
        d.available = available_old;
        qWarning("Close portaudio stream error: %s", Pa_GetErrorText(err));
        return false;
    }
    d.stream = NULL;
    return true;
}
Exemple #2
0
void Q3Socket::close()
{
    if ( !isOpen() || d->state == Idle )	// already closed
	return;
    if ( d->state == Closing )
	return;
    if ( !d->rsn || !d->wsn )
	return;
#if defined(Q3SOCKET_DEBUG)
    qDebug( "Q3Socket (%s): close socket", name() );
#endif
    if ( d->socket && d->wsize ) {		// there's data to be written
	d->state = Closing;
	if ( d->rsn )
	    d->rsn->setEnabled( false );
	if ( d->wsn )
	    d->wsn->setEnabled( true );
	d->rba.clear();				// clear incoming data
	return;
    }
    resetStatus();
    setOpenMode(NotOpen);
    d->close();
    d->state = Idle;
}
Exemple #3
0
bool Character::afflictStatus(const std::string& status, int duration)
{
  auto it = getStatusEffectIterator(status);

  if (it == m_status.end())
  {
    // Dead status removes all other statuses.
    if (status == "Dead")
    {
      resetStatus();
    }

    if (hasStatus("Normal"))
    {
      m_status.clear();
    }

    m_status.push_back(get_status_effect(status));

    if (duration > 0)
    {
      m_statusDurations[get_status_effect(status)] = duration;
    }

    return true;
  }

  return false;
}
Exemple #4
0
void Q3Socket::setSocketIntern( int socket )
{
    if ( state() != Idle ) {
	clearPendingData();
        close();
    }
    Q_ULONG oldBufferSize = d ? d->readBufferSize : 0;
    delete d;

    d = new Q3SocketPrivate;
    if (oldBufferSize)
        d->readBufferSize = oldBufferSize;
    if ( socket >= 0 ) {
	Q3SocketDevice *sd = new Q3SocketDevice( socket, Q3SocketDevice::Stream );
	sd->setBlocking( false );
	sd->setAddressReusable( true );
	d->setSocketDevice( this, sd );
    }
    d->state = Idle;

    // Initialize the IO device flags
    resetStatus();
    open( IO_ReadWrite );

    // hm... this is not very nice.
    d->host.clear();
    d->port = 0;
#ifndef QT_NO_DNS
    delete d->dns4;
    d->dns4 = 0;
    delete d->dns6;
    d->dns6 = 0;
#endif
}
bool ExpandableBlockStreamExchangeEpoll::close()
{
	logging_->log("[%ld] Close: nexhausted lowers=%d, nlower=%d", state.exchange_id_, nexhausted_lowers, nlowers);

	CancelReceiverThread();

	CloseTheSocket();

	/* free the temporary resource/ */
	for (unsigned i = 0; i < nlowers; i++)
	{
		delete block_for_socket_[i];
		;
	}
	delete received_block_stream_;
	delete buffer;
	delete[] block_for_socket_;

	/* rest the status of this iterator instance, such that the following calling of open() and next() can
	 * act correctly.
	 */
	resetStatus();

	Environment::getInstance()->getExchangeTracker()->LogoutExchange(ExchangeID(state.exchange_id_, partition_offset));
	logging_->log("[%ld] ExchangeUpper is closed!", state.exchange_id_);

	return true;
}
bool AudioOutputDSound::close()
{
    DPTR_D(AudioOutputDSound);
    resetStatus();
    d.destroy();
    return true;
}
bool AudioOutputOpenSL::close()
{
    DPTR_D(AudioOutputOpenSL);
    d.available = false;
    resetStatus();
    if (d.m_playItf)
        (*d.m_playItf)->SetPlayState(d.m_playItf, SL_PLAYSTATE_STOPPED);

    if (d.m_bufferQueueItf && SL_RESULT_SUCCESS != (*d.m_bufferQueueItf)->Clear(d.m_bufferQueueItf))
        qWarning("Unable to clear buffer");

    if (d.m_playerObject) {
        (*d.m_playerObject)->Destroy(d.m_playerObject);
        d.m_playerObject = NULL;
    }
    if (d.m_outputMixObject) {
        (*d.m_outputMixObject)->Destroy(d.m_outputMixObject);
        d.m_outputMixObject = NULL;
    }

    d.m_playItf = NULL;
    d.m_volumeItf = NULL;
    d.m_bufferQueueItf = NULL;
    return true;
}
void SeahubNotificationsMonitor::refresh()
{
    if (in_refresh_) {
        return;
    }

    const Account& account = seafApplet->accountManager()->currentAccount();
    if (!account.isValid()) {
        resetStatus();
        return;
    }

    in_refresh_ = true;

    if (check_messages_req_) {
        delete check_messages_req_;
    }

    check_messages_req_ = new GetUnseenSeahubNotificationsRequest(account);

    connect(check_messages_req_, SIGNAL(success(int)),
            this, SLOT(onRequestSuccess(int)));
    connect(check_messages_req_, SIGNAL(failed(const ApiError&)),
            this, SLOT(onRequestFailed(const ApiError&)));

    check_messages_req_->send();
}
Exemple #9
0
void QSocket::close()
{
    if ( !isOpen() || d->state == Idle )	// already closed
	return;
    if ( d->state == Closing )
	return;
    if ( !d->rsn || !d->wsn )
	return;
#if defined(QSOCKET_DEBUG)
    qDebug( "QSocket (%s): close socket", name() );
#endif
    if ( d->socket && d->wsize ) {		// there's data to be written
	d->state = Closing;
	if ( d->rsn )
	    d->rsn->setEnabled( FALSE );
	if ( d->wsn )
	    d->wsn->setEnabled( TRUE );
	d->rba.clear();				// clear incoming data
	return;
    }
    setFlags( IO_Sequential );
    resetStatus();
    setState( 0 );
    d->close();
    d->state = Idle;
}
QString LongStream::detach()
{
    QString detachedName = fileName();

    delete ts;

    tmpFile->setAutoRemove(false);
    tmpFile->close();
    delete tmpFile;

    QString tmpName( LongStream::tempDir() + QLatin1String( "/qtopiamail" ) );

    tmpFile = new QTemporaryFile( tmpName + QLatin1String( ".XXXXXX" ));
    tmpFile->open();
    tmpFile->setPermissions(QFile::ReadOwner | QFile::WriteOwner);

    ts = new QDataStream( tmpFile );
    len = 0;
    appendedBytes = minCheck;

    c = QChar::Null;
    resetStatus();

    return detachedName;
}
Exemple #11
0
QSocket::QSocket( QObject *parent, const char *name )
    : QObject( parent, name )
{
    d = new QSocketPrivate;
    setSocketDevice( 0 );
    setFlags( IO_Direct );
    resetStatus();
}
Exemple #12
0
Q3Socket::Q3Socket( QObject *parent, const char *name )
    : QIODevice( parent )
{
    setObjectName(QLatin1String(name));
    d = new Q3SocketPrivate;
    setSocketDevice( 0 );
    resetStatus();
}
void SeahubNotificationsMonitor::refresh(bool force)
{
    if (force) {
        resetStatus();
        in_refresh_ = false;
    }

    refresh();
}
void ImageProcessSystem::cancelOperation()
{
	srcImage=images.top();
	currentDisplayImageImproper=false;
	BasisOperation::qimage2Mat(srcImage,srcMat.get());
	images.pop();
	resetStatus();
	updateToolBar();
	updateDisplayImage();
}
bool AudioOutputDSound::open()
{
    DPTR_D(AudioOutputDSound);
    resetStatus();
    if (!d.init())
        return false;
    if (!d.createDSoundBuffers())
        return false;
    return true;
}
void SeahubNotificationsMonitor::start()
{
    resetStatus();

    refresh_timer_->start(kRefreshSeahubMessagesInterval);

    connect(seafApplet->accountManager(), SIGNAL(accountsChanged()),
            this, SLOT(onAccountChanged()));
    refresh();
}
Exemple #17
0
int list_delete(list_t * self, int index)
{
    resetStatus(self);
    if(!isEmpty(self) && index - 1 <= self->size - 1)
    {
        shift_left(self, index);
        (self->size)--;
    }
    else
        self->status = LIST_EMPTY;
}
void SeahubNotificationsMonitor::openNotificationsPageInBrowser()
{
    const Account& account = seafApplet->accountManager()->currentAccount();
    if (!account.isValid()) {
        return;
    }

    QDesktopServices::openUrl(account.getAbsoluteUrl(kNotificationsUrl));

    resetStatus();
}
void SeahubNotificationsMonitor::openNotificationsPageInBrowser()
{
    const Account& account = seafApplet->accountManager()->currentAccount();
    if (!account.isValid()) {
        return;
    }

    AutoLoginService::instance()->startAutoLogin(kNotificationsUrl);

    resetStatus();
}
void ImageProcessSystem::listWidgetClicked(QListWidgetItem *item)
{
	int r=ui.listWidget->row(item);
	fileName=fileNames[r];
	resetStatus();
	interactiveHasProduceResult=false;
	loadImage();
	updateToolBar();
	initMat();
	initImageLabel();
}
void ImageProcessSystem::openFile()
{
	fileName=QFileDialog::getOpenFileName(this,"Open File",QDir::currentPath(),"Images (*.bmp *.gif *.jpg *.jpeg *.png *.tiff)");
	if(!loadImage())
		return ;
	resetStatus();
	interactiveHasProduceResult=false;
	updateToolBar();
	initMat();
	delete ImageLabel;
	ImageLabel=new OriginalImageLabel(ui.centralWidget);
	initImageLabel();
}
Exemple #22
0
bool QFile::open( int m, FILE *f )
{
    if ( isOpen() ) {
#if defined(QT_CHECK_RANGE)
	qWarning( "QFile::open: File already open" );
#endif
	return FALSE;
    }
    init();
    setMode( m &~IO_Raw );
    setState( IO_Open );
    fh = f;
    ext_f = TRUE;
    struct stat st;
    ::fstat( fileno(fh), &st );
#if defined(QT_LARGEFILE_SUPPORT)
#if !defined(QT_ABI_QT4)
    off_t tmp = ftello( fh );
    ioIndex = tmp > UINT_MAX ? UINT_MAX : (Offset)tmp;
#else
    ioIndex = (Offset)ftello( fh );
#endif
#else
    ioIndex = (Offset)ftell( fh );
#endif
    if ( (st.st_mode & S_IFMT) != S_IFREG || f == stdin ) { //stdin is non seekable
	// non-seekable
	setType( IO_Sequential );
	length = INT_MAX;
	ioIndex = 0;
    } else {
#if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_QT4)
	length = st.st_size > UINT_MAX ? UINT_MAX : (Offset)st.st_size;
#else
	length = (Offset)st.st_size;
#endif
	if ( !(flags()&IO_Truncate) && length == 0 && isReadable() ) {
	    // try if you can read from it (if you can, it's a sequential
	    // device; e.g. a file in the /proc filesystem)
	    int c = getch();
	    if ( c != -1 ) {
		ungetch(c);
		setType( IO_Sequential );
		length = INT_MAX;
		ioIndex = 0;
	    }
	    resetStatus();
	}
    }
    return TRUE;
}
bool AudioOutputOpenSL::open()
{
    DPTR_D(AudioOutputOpenSL);
    d.available = false;
    resetStatus();
    SLDataLocator_BufferQueue bufferQueueLocator = { SL_DATALOCATOR_BUFFERQUEUE, (SLuint32)d.nb_buffers };
    SLDataFormat_PCM pcmFormat = audioFormatToSL(audioFormat());
    SLDataSource audioSrc = { &bufferQueueLocator, &pcmFormat };
    // OutputMix
    SL_RUN_CHECK_FALSE((*d.engine)->CreateOutputMix(d.engine, &d.m_outputMixObject, 0, NULL, NULL));
    SL_RUN_CHECK_FALSE((*d.m_outputMixObject)->Realize(d.m_outputMixObject, SL_BOOLEAN_FALSE));
    SLDataLocator_OutputMix outputMixLocator = { SL_DATALOCATOR_OUTPUTMIX, d.m_outputMixObject };
    SLDataSink audioSink = { &outputMixLocator, NULL };

    const SLInterfaceID ids[] = { SL_IID_BUFFERQUEUE};//, SL_IID_VOLUME };
    const SLboolean req[] = { SL_BOOLEAN_TRUE};//, SL_BOOLEAN_TRUE };
    // AudioPlayer
    SL_RUN_CHECK_FALSE((*d.engine)->CreateAudioPlayer(d.engine, &d.m_playerObject, &audioSrc, &audioSink, sizeof(ids)/sizeof(ids[0]), ids, req));
    SL_RUN_CHECK_FALSE((*d.m_playerObject)->Realize(d.m_playerObject, SL_BOOLEAN_FALSE));
    // Buffer interface
    SL_RUN_CHECK_FALSE((*d.m_playerObject)->GetInterface(d.m_playerObject, SL_IID_BUFFERQUEUE, &d.m_bufferQueueItf));
    SL_RUN_CHECK_FALSE((*d.m_bufferQueueItf)->RegisterCallback(d.m_bufferQueueItf, AudioOutputOpenSLPrivate::bufferQueueCallback, &d));
    // Play interface
    SL_RUN_CHECK_FALSE((*d.m_playerObject)->GetInterface(d.m_playerObject, SL_IID_PLAY, &d.m_playItf));
    // call when SL_PLAYSTATE_STOPPED
    SL_RUN_CHECK_FALSE((*d.m_playItf)->RegisterCallback(d.m_playItf, AudioOutputOpenSLPrivate::playCallback, this));

#if 0
    SLuint32 mask = SL_PLAYEVENT_HEADATEND;
    // TODO: what does this do?
    SL_RUN_CHECK_FALSE((*d.m_playItf)->SetPositionUpdatePeriod(d.m_playItf, 100));
    SL_RUN_CHECK_FALSE((*d.m_playItf)->SetCallbackEventsMask(d.m_playItf, mask));
#endif
    // Volume interface
    //SL_RUN_CHECK_FALSE((*d.m_playerObject)->GetInterface(d.m_playerObject, SL_IID_VOLUME, &d.m_volumeItf));

    const int kBufferSize = 1024*4;
    static char init_data[kBufferSize];
    memset(init_data, 0, sizeof(init_data));
    for (quint32 i = 0; i < d.nb_buffers; ++i) {
        SL_RUN_CHECK_FALSE((*d.m_bufferQueueItf)->Enqueue(d.m_bufferQueueItf, init_data, sizeof(init_data)));
        d.nextEnqueueInfo().data_size = sizeof(init_data);
        d.nextEnqueueInfo().timestamp = 0;
        d.bufferAdded();
        d.buffers_queued++;
    }
    SL_RUN_CHECK_FALSE((*d.m_playItf)->SetPlayState(d.m_playItf, SL_PLAYSTATE_PLAYING));
    d.available = true;
    return true;
}
void Q3SocketDevice::close()
{
    if ( fd == -1 || !isOpen() )		// already closed
	return;
    resetStatus();
    setOpenMode(NotOpen);
    ::close( fd );
#if defined(QSOCKETDEVICE_DEBUG)
    qDebug( "Q3SocketDevice::close: Closed socket %x", fd );
#endif
    fd = -1;
    fetchConnectionParameters();
    QIODevice::close();
}
Exemple #25
0
int RpcEngine::serveClient() {

	DWORD status;
	DWORD nCount;
	SignalingQueue<callNS::Call>* outgoingQueue = APP_CONTEXT.getRpcOutgoingQueue();
	HANDLE queueHandle = outgoingQueue->getSignalHandle();
	HANDLE events[3];

	nCount = 0;
	events[nCount++] = mhStopEvent;
	events[nCount++] = mhClientPipe;
	events[nCount++] = queueHandle;

	int retValue = 0;

	while (1) {
		status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);

		if (WaitForSingleObject(mhStopEvent, 0) == WAIT_OBJECT_0) {
			retValue = CLIENT_ERROR;
			break;
		}

		if (WaitForSingleObject(mhClientPipe, 0) == WAIT_OBJECT_0) {
			retValue = read();
			if (retValue) {
				break;
			}
			// process the data
			if (mPayloadRead == mPacktLength) {
				processData();
				resetStatus();
			}

		}

		if (WaitForSingleObject(queueHandle, 0) == WAIT_OBJECT_0) {
			outgoingQueue->resetEventAndLockQueue();
			callNS::Call * currentCall = outgoingQueue->getElementLockFree();
			while (currentCall != NULL) {
				processOutgoingCall(currentCall);
				currentCall = outgoingQueue->getElementLockFree();
			}
			outgoingQueue->unlockQueue();
		}

	}

	return retValue;
}
void LongStream::reset()
{
    delete ts;

    tmpFile->resize( 0 );
    tmpFile->close();
    tmpFile->open();

    ts = new QDataStream( tmpFile );
    len = 0;
    appendedBytes = minCheck;

    c = QChar::Null;
    resetStatus();
}
/*!
    Sets the socket device to operate on the existing socket \a
    socket.

    The \a type argument must match the actual socket type; use \c
    Q3SocketDevice::Stream for a reliable, connection-oriented TCP
    socket, or Q3SocketDevice::Datagram for an unreliable,
    connectionless UDP socket.

    Any existing socket is closed.

    \sa isValid(), close()
*/
void Q3SocketDevice::setSocket( int socket, Type type )
{
    if ( fd != -1 )			// close any open socket
	close();
#if defined(Q3SOCKETDEVICE_DEBUG)
    qDebug( "Q3SocketDevice::setSocket: socket %x, type %d", socket, type );
#endif
    t = type;
    fd = socket;
    d->protocol = Unknown;
    e = NoError;
    resetStatus();
    open( ReadWrite );
    fetchConnectionParameters();
}
KviHttpRequest::KviHttpRequest()
: QObject()
{
	m_p = new KviHttpRequestPrivate();
	m_p->pSocket = NULL;
	m_p->bIsSSL = false;
	m_p->pConnectTimeoutTimer = NULL;
	m_p->pBuffer = new KviDataBuffer();
	m_p->pFile = NULL;

	m_pPrivateData = 0;
	m_bHeaderProcessed = false;
	m_uConnectionTimeout = 60;

	resetStatus();
	resetData();
}
Exemple #29
0
void list_add(list_t * self, int value, int index)
{
    resetStatus(self);
    if(isFull(self))
    {
        self->status = LIST_FULL;
        return;
    }
    if(index - 1 >= MAX_LIST_SIZE || index - 1 >= self->size - 1){
        self->arr[(self->size)++] = value;
        return;
    }
    if(index - 1 < self->size - 1)
        shift_right(self, index);
    self->arr[index - 1] = value;
    (self->size)++;
}
//TODO: call open after audio format changed?
bool AudioOutputPortAudio::open()
{
    DPTR_D(AudioOutputPortAudio);
    QMutexLocker lock(&d.mutex);
    Q_UNUSED(lock);
    resetStatus();
    d.outputParameters->sampleFormat = toPaSampleFormat(audioFormat().sampleFormat());
    d.outputParameters->channelCount = audioFormat().channels();
    PaError err = Pa_OpenStream(&d.stream, NULL, d.outputParameters, audioFormat().sampleRate(), 0, paNoFlag, NULL, NULL);
    if (err == paNoError) {
        d.outputLatency = Pa_GetStreamInfo(d.stream)->outputLatency;
        d.available = true;
    } else {
        qWarning("Open portaudio stream error: %s", Pa_GetErrorText(err));
        d.available = false;
    }
    return err == paNoError;
}