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();
}
