void mythread::run() { //ovde thread krece sa izvrsavanjem threadFrame myFrame; QTimer *timer = new QTimer(0); timer->start(10); qDebug() << socketDescriptor << "Starting thread"; socket = new QTcpSocket(); if (!socket->setSocketDescriptor(this->socketDescriptor)) { emit error(socket->error()); return; } myFrame.frame = *sysFrame; myFrame.socketDescriptor=this->socketDescriptor; sysFrameList->append(myFrame); connect(socket,SIGNAL(readyRead()),this,SLOT(readyRead()),Qt::DirectConnection); connect(socket,SIGNAL(disconnected()),this,SLOT(disconnected()),Qt::DirectConnection); connect(timer,SIGNAL(timeout()),this,SLOT(timeUp()),Qt::DirectConnection); //still need this. connect(this,SIGNAL(timeSig()),this,SLOT(readyWrite()),Qt::DirectConnection); qDebug() << socketDescriptor << "Client connected."; QMutex lock; exec(); //thread will stay alive until we tell it to close }
qint64 ThreadedSSLSocket::writeData(const char* data, qint64 len) { bytesToWriteLock.lock(); qint64 out = writeBuffer.write(data, len); bytesToWriteLock.unlock(); emit readyWrite(); return out; }
bool OpenGL2Writer::processParams(bool *) { bool doResizeEvent = false; const double aspectRatio = getParam("AspectRatio").toDouble(); const double zoom = getParam("Zoom").toDouble(); const bool spherical = getParam("Spherical").toBool(); const int flip = getParam("Flip").toInt(); const bool rotate90 = getParam("Rotate90").toBool(); const VideoAdjustment videoAdjustment = { (qint16)getParam("Brightness").toInt(), (qint16)getParam("Contrast").toInt(), (qint16)getParam("Saturation").toInt(), (qint16)getParam("Hue").toInt(), (qint16)getParam("Sharpness").toInt() }; const int verticesIdx = rotate90 * 4 + flip; drawable->Deinterlace = getParam("Deinterlace").toInt(); if (drawable->aspectRatio != aspectRatio || drawable->zoom != zoom || drawable->sphericalView != spherical || drawable->verticesIdx != verticesIdx || drawable->videoAdjustment != videoAdjustment) { drawable->zoom = zoom; drawable->aspectRatio = aspectRatio; drawable->verticesIdx = verticesIdx; drawable->videoAdjustment = videoAdjustment; drawable->setSpherical(spherical); doResizeEvent = drawable->widget()->isVisible(); } if (getParam("ResetOther").toBool()) { drawable->videoOffset = drawable->osdOffset = QPointF(); modParam("ResetOther", false); if (!doResizeEvent) doResizeEvent = drawable->widget()->isVisible(); } const int outW = getParam("W").toInt(); const int outH = getParam("H").toInt(); if (outW != drawable->outW || outH != drawable->outH) { drawable->clearImg(); if (outW > 0 && outH > 0) { drawable->outW = outW; drawable->outH = outH; } emit QMPlay2Core.dockVideo(drawable->widget()); } if (doResizeEvent) drawable->newSize(); else drawable->doReset = true; return readyWrite(); }
bool VAApiWriter::processParams( bool * ) { zoom = getParam( "Zoom" ).toDouble(); deinterlace = getParam( "Deinterlace" ).toInt(); aspect_ratio = getParam( "AspectRatio" ).toDouble(); const int _Hue = getParam( "Hue" ).toInt(); const int _Saturation = getParam( "Saturation" ).toInt(); const int _Brightness = getParam( "Brightness" ).toInt(); const int _Contrast = getParam( "Contrast" ).toInt(); if ( _Hue != Hue || _Saturation != Saturation || _Brightness != Brightness || _Contrast != Contrast ) { Hue = _Hue; Saturation = _Saturation; Brightness = _Brightness; Contrast = _Contrast; int num_attribs = vaMaxNumDisplayAttributes( VADisp ); VADisplayAttribute attribs[ num_attribs ]; if ( !vaQueryDisplayAttributes( VADisp, attribs, &num_attribs ) ) { for ( int i = 0 ; i < num_attribs ; ++i ) { switch ( attribs[ i ].type ) { case VADisplayAttribHue: attribs[ i ].value = Functions::scaleEQValue( Hue, attribs[ i ].min_value, attribs[ i ].max_value ); break; case VADisplayAttribSaturation: attribs[ i ].value = Functions::scaleEQValue( Saturation, attribs[ i ].min_value, attribs[ i ].max_value ); break; case VADisplayAttribBrightness: attribs[ i ].value = Functions::scaleEQValue( Brightness, attribs[ i ].min_value, attribs[ i ].max_value ); break; case VADisplayAttribContrast: attribs[ i ].value = Functions::scaleEQValue( Contrast, attribs[ i ].min_value, attribs[ i ].max_value ); break; default: break; } } vaSetDisplayAttributes( VADisp, attribs, num_attribs ); } } if ( !isVisible() ) QMPlay2Core.dockVideo( this ); else { resizeEvent( NULL ); if ( paused ) draw(); } return readyWrite(); }
UpdateChecker::UpdateChecker(QObject *parent) : QObject(parent) { _socket = new QTcpSocket; QObject::connect(_socket,SIGNAL(error(QAbstractSocket::SocketError)), this,SLOT(connectionError(QAbstractSocket::SocketError))); QObject::connect(_socket,SIGNAL(connected()),this, SLOT(readyWrite())); QObject::connect(_socket,SIGNAL(readyRead()),this,SLOT(processData())); }
qint64 ALSAWriter::write(const QByteArray &arr) { if (!readyWrite()) return 0; const int samples = arr.size() / sizeof(float); const int to_write = samples / channels; const int bytes = samples * sample_size; if (int_samples.size() < bytes) int_samples.resize(bytes); switch (sample_size) { case 4: convert_samples((const float *)arr.constData(), samples, (qint32 *)int_samples.constData(), mustSwapChn ? channels : 0); break; case 2: convert_samples((const float *)arr.constData(), samples, (qint16 *)int_samples.constData(), mustSwapChn ? channels : 0); break; case 1: convert_samples((const float *)arr.constData(), samples, (qint8 *)int_samples.constData(), mustSwapChn ? channels : 0); break; } switch (snd_pcm_state(snd)) { case SND_PCM_STATE_XRUN: if (!snd_pcm_prepare(snd)) { const int silence = snd_pcm_avail(snd) - to_write; if (silence > 0) { QByteArray silenceArr(silence * channels * sample_size, 0); snd_pcm_writei(snd, silenceArr.constData(), silence); } } break; case SND_PCM_STATE_PAUSED: snd_pcm_pause(snd, false); break; default: break; } int ret = snd_pcm_writei(snd, int_samples.constData(), to_write); if (ret < 0 && ret != -EPIPE && snd_pcm_recover(snd, ret, false)) { QMPlay2Core.logError("ALSA :: " + tr("Playback error")); err = true; return 0; } return arr.size(); }
qint64 Socket::writeData(const char * data, qint64 maxSize) { qint64 bytesWritten = 0; // Mutex lock here. QMutexLocker locker(sendLock_); QByteArray writeData(data, maxSize); outputBuffer_->write(writeData); bytesWritten = maxSize; locker.unlock(); // Mutex unlock. emit readyWrite(bytesWritten); return bytesWritten; }
void DccTransferRecv::startReceiving() { kdDebug() << "DccTransferRecv::startReceiving()" << endl; m_recvSocket->setBlocking( false ); // asynchronous mode connect( m_recvSocket, SIGNAL( readyRead() ), this, SLOT( readData() ) ); connect( m_recvSocket, SIGNAL( readyWrite() ), this, SLOT( sendAck() ) ); connect( m_recvSocket, SIGNAL( closed() ), this, SLOT( slotSocketClosed() ) ); setStatus( Transferring ); m_transferStartPosition = m_transferringPosition; m_recvSocket->enableRead( true ); m_recvSocket->enableWrite( false ); startTransferLogger(); // initialize CPS counter, ETA counter, etc... }
bool UDPSocket::open(OpenMode mode) { int err = 0; int flags = FD_CLOSE; switch (mode) { case QIODevice::ReadOnly: flags |= FD_READ; break; case QIODevice::WriteOnly: flags |= FD_WRITE; break; case QIODevice::ReadWrite: flags |= FD_READ | FD_WRITE; break; case QIODevice::NotOpen: flags = 0; break; case QIODevice::Append: case QIODevice::Truncate: case QIODevice::Text: case QIODevice::Unbuffered: default: return false; break; } if ((err = WSAAsyncSelect(socket_, hWnd_, WM_WSAASYNC_UDP, flags)) == SOCKET_ERROR) { qDebug("UDPSocket::open(): Error setting up async select."); return false; } QIODevice::connect(this, SIGNAL(readyWrite(qint64)), this, SLOT(slotWriteData(qint64))); return QIODevice::open(mode); }
bool ALSAWriter::processParams(bool *paramsCorrected) { const unsigned chn = getParam("chn").toUInt(); const unsigned rate = getParam("rate").toUInt(); const bool resetAudio = channels != chn || sample_rate != rate; channels = chn; sample_rate = rate; if (resetAudio || err) { snd_pcm_hw_params_t *params; snd_pcm_hw_params_alloca(¶ms); close(); QString chosenDevName = devName; if (autoFindMultichannelDevice && channels > 2) { bool mustAutoFind = true, forceStereo = false; if (!snd_pcm_open(&snd, chosenDevName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0)) { if (snd_pcm_type(snd) == SND_PCM_TYPE_HW) { unsigned max_chn = 0; snd_pcm_hw_params_any(snd, params); mustAutoFind = snd_pcm_hw_params_get_channels_max(params, &max_chn) || max_chn < channels; } #ifdef HAVE_CHMAP else if (paramsCorrected) { snd_pcm_chmap_query_t **chmaps = snd_pcm_query_chmaps(snd); if (chmaps) snd_pcm_free_chmaps(chmaps); else forceStereo = true; } #endif snd_pcm_close(snd); snd = NULL; } if (mustAutoFind) { QString newDevName; if (channels <= 4) newDevName = "surround40"; else if (channels <= 6) newDevName = "surround51"; else newDevName = "surround71"; if (!newDevName.isEmpty() && newDevName != chosenDevName) { if (ALSACommon::getDevices().first.contains(newDevName)) chosenDevName = newDevName; else if (forceStereo) { channels = 2; *paramsCorrected = true; } } } } if (!chosenDevName.isEmpty()) { bool sndOpen = !snd_pcm_open(&snd, chosenDevName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0); if (devName != chosenDevName) { if (sndOpen) QMPlay2Core.logInfo("ALSA :: " + devName + "\" -> \"" + chosenDevName + "\""); else { sndOpen = !snd_pcm_open(&snd, devName.toLocal8Bit(), SND_PCM_STREAM_PLAYBACK, 0); QMPlay2Core.logInfo("ALSA :: " + tr("Cannot open") + " \"" + chosenDevName + "\", " + tr("back to") + " \"" + devName + "\""); } } if (sndOpen) { snd_pcm_hw_params_any(snd, params); snd_pcm_format_t fmt = SND_PCM_FORMAT_UNKNOWN; if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S32)) { fmt = SND_PCM_FORMAT_S32; sample_size = 4; } else if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S16)) { fmt = SND_PCM_FORMAT_S16; sample_size = 2; } else if (!snd_pcm_hw_params_test_format(snd, params, SND_PCM_FORMAT_S8)) { fmt = SND_PCM_FORMAT_S8; sample_size = 1; } unsigned delay_us = round(delay * 1000000.0); if (fmt != SND_PCM_FORMAT_UNKNOWN && set_snd_pcm_hw_params(snd, params, fmt, channels, sample_rate, delay_us)) { bool err2 = false; if (channels != chn || sample_rate != rate) { if (paramsCorrected) *paramsCorrected = true; else err2 = true; } if (!err2) { err2 = snd_pcm_hw_params(snd, params); if (err2 && paramsCorrected) //jakiś błąd, próba zmiany sample_rate { snd_pcm_hw_params_any(snd, params); err2 = snd_pcm_hw_params_set_rate_resample(snd, params, false) || !set_snd_pcm_hw_params(snd, params, fmt, channels, sample_rate, delay_us) || snd_pcm_hw_params(snd, params); if (!err2) *paramsCorrected = true; } if (!err2) { modParam("delay", delay_us / 1000000.0); if (paramsCorrected && *paramsCorrected) { modParam("chn", channels); modParam("rate", sample_rate); } canPause = snd_pcm_hw_params_can_pause(params) && snd_pcm_hw_params_can_resume(params); mustSwapChn = channels == 6 || channels == 8; #ifdef HAVE_CHMAP if (mustSwapChn) { snd_pcm_chmap_query_t **chmaps = snd_pcm_query_chmaps(snd); if (chmaps) { for (int i = 0; chmaps[i]; ++i) { if (chmaps[i]->map.channels >= channels) { for (uint j = 0; j < channels; ++j) { mustSwapChn &= chmaps[i]->map.pos[j] == j + SND_CHMAP_FL; if (!mustSwapChn) break; } break; } } snd_pcm_free_chmaps(chmaps); } } #endif return true; } } } } } err = true; QMPlay2Core.logError("ALSA :: " + tr("Cannot open audio output stream")); } return readyWrite(); }