void MplayerProcess::takeScreenshot(ScreenshotType t, bool include_subtitles) {
if (t == Single) {
writeToStdin(pausing_prefix + " screenshot 0");
} else {
writeToStdin("screenshot 1");
}
}
int Q3Process::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: readyReadStdout(); break;
case 1: readyReadStderr(); break;
case 2: processExited(); break;
case 3: wroteToStdin(); break;
case 4: launchFinished(); break;
case 5: tryTerminate(); break;
case 6: kill(); break;
case 7: writeToStdin((*reinterpret_cast< const QByteArray(*)>(_a[1]))); break;
case 8: writeToStdin((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 9: closeStdin(); break;
case 10: socketRead((*reinterpret_cast< int(*)>(_a[1]))); break;
case 11: socketWrite((*reinterpret_cast< int(*)>(_a[1]))); break;
case 12: timeout(); break;
case 13: closeStdinLaunch(); break;
}
_id -= 14;
}
return _id;
}
/*! \internal
*/
bool QProcessPrivate::canWrite()
{
Q_Q(QProcess);
#if defined QPROCESS_DEBUG
qDebug("QProcessPrivate::canWrite()");
#endif
if (writeSocketNotifier)
writeSocketNotifier->setEnabled(false);
if (writeBuffer.isEmpty())
return false;
qint64 written = writeToStdin(writeBuffer.readPointer(),
writeBuffer.nextDataBlockSize());
if (written < 0) {
destroyPipe(writePipe);
processError = QProcess::WriteError;
q->setErrorString(QT_TRANSLATE_NOOP(QProcess, QLatin1String("Error writing to process")));
emit q->error(processError);
return false;
}
writeBuffer.free(written);
if (!emittedBytesWritten) {
emittedBytesWritten = true;
emit q->bytesWritten(written);
emittedBytesWritten = false;
}
if (writeSocketNotifier && !writeBuffer.isEmpty())
writeSocketNotifier->setEnabled(true);
if (writeBuffer.isEmpty() && writeChannelClosing)
closeWriteChannel();
return true;
}
void MplayerProcess::setSubtitle(int type, int ID) {
switch (type) {
case SubData::Vob:
writeToStdin( "sub_vob " + QString::number(ID) );
break;
case SubData::Sub:
writeToStdin( "sub_demux " + QString::number(ID) );
break;
case SubData::File:
writeToStdin( "sub_file " + QString::number(ID) );
break;
default: {
qWarning("MplayerProcess::setSubtitle: unknown type!");
}
}
}
bool QProcess::qt_invoke( int _id, QUObject* _o )
{
switch ( _id - staticMetaObject()->slotOffset() ) {
case 0: tryTerminate(); break;
case 1: kill(); break;
case 2: writeToStdin((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
case 3: writeToStdin((const QString&)static_QUType_QString.get(_o+1)); break;
case 4: closeStdin(); break;
case 5: socketRead((int)static_QUType_int.get(_o+1)); break;
case 6: socketWrite((int)static_QUType_int.get(_o+1)); break;
case 7: timeout(); break;
case 8: closeStdinLaunch(); break;
default:
return QObject::qt_invoke( _id, _o );
}
return TRUE;
}
Error run(const std::string& input, ProcessResult* pResult)
{
// sync child processes don't support pseudoterminal mode
#ifndef _WIN32
if (options().pseudoterminal)
{
return systemError(boost::system::errc::not_supported,
ERROR_LOCATION);
}
#endif
// run the process
Error error = ChildProcess::run();
if (error)
return error;
// write input
if (!input.empty())
{
error = writeToStdin(input, true);
if (error)
{
Error terminateError = terminate();
if (terminateError)
LOG_ERROR(terminateError);
}
}
// bail if we aren't waiting for results
if (pResult == NULL)
return Success();
// read standard out if we didn't have a previous problem
if (!error)
error = readStdOut(&(pResult->stdOut));
// read standard error if we didn't have a previous problem
if (!error)
error = readStdErr(&(pResult->stdErr));
// wait on exit and get exit status. note we always need to do this
// even if we called terminate due to an earlier error (so we always
// reap the child)
Error waitError = waitForExit(&(pResult->exitStatus));
if (waitError)
{
if (!error)
error = waitError;
else
LOG_ERROR(waitError);
}
// return error status
return error;
}
/*!
\overload
The data \a buf is written to standard input with writeToStdin()
using the QString::local8Bit() representation of the strings.
*/
bool QProcess::launch( const QString& buf, QStringList *env )
{
if ( start( env ) ) {
if ( !buf.isEmpty() ) {
connect( this, SIGNAL(wroteToStdin()),
this, SLOT(closeStdinLaunch()) );
writeToStdin( buf );
} else {
closeStdin();
emit launchFinished();
}
return TRUE;
} else {
emit launchFinished();
return FALSE;
}
}
void MplayerProcess::setAspect(double aspect) {
writeToStdin("switch_ratio " + QString::number(aspect));
}
void MplayerProcess::setFullscreen(bool b) {
writeToStdin(QString("vo_fullscreen %1").arg(b ? "1" : "0"));
}
void MplayerProcess::discSetMousePos(int x, int y) {
writeToStdin(QString("set_mouse_pos %1 %2").arg(x).arg(y));
}
void MplayerProcess::discButtonPressed(const QString & button_name) {
writeToStdin("dvdnav " + button_name);
}
void MplayerProcess::setSubForcedOnly(bool b) {
writeToStdin(QString("forced_subs_only %1").arg(b ? 1 : 0));
}
void MplayerProcess::setSubScale(double value) {
writeToStdin("sub_scale " + QString::number(value) + " 1");
}
void MplayerProcess::setSubDelay(double delay) {
writeToStdin(pausing_prefix + " sub_delay " + QString::number(delay) +" 1");
}
void MplayerProcess::askForLength() {
writeToStdin(pausing_prefix + " get_property length");
}
void MplayerProcess::enableVolnorm(bool b, const QString & option) {
if (b) writeToStdin("af_add volnorm=" + option); else writeToStdin("af_del volnorm");
}
void MplayerProcess::setAudioEqualizer(const QString & values) {
writeToStdin("af_cmdline equalizer " + values);
}
void MplayerProcess::enableExtrastereo(bool b) {
if (b) writeToStdin("af_add extrastereo"); else writeToStdin("af_del extrastereo");
}
void MplayerProcess::enableKaraoke(bool b) {
if (b) writeToStdin("af_add karaoke"); else writeToStdin("af_del karaoke");
}
void MplayerProcess::setSpeed(double value) {
writeToStdin("speed_set " + QString::number(value));
}
void MplayerProcess::setTSProgram(int ID) {
writeToStdin("set_property switch_program " + QString::number(ID) );
writeToStdin("get_property switch_audio");
writeToStdin("get_property switch_video");
}
void MplayerProcess::setGamma(int value) {
writeToStdin(pausing_prefix + " gamma " + QString::number(value) + " 1");
}
void MplayerProcess::toggleDeinterlace() {
writeToStdin("step_property deinterlace");
}
/*!
\overload
The string \a buf is handled as text using the
QString::local8Bit() representation.
*/
void QProcess::writeToStdin( const QString& buf )
{
QByteArray tmp = buf.local8Bit();
tmp.resize( qstrlen( tmp.data() ) );
writeToStdin( tmp );
}
void MplayerProcess::setExternalSubtitleFile(const QString & filename) {
writeToStdin("sub_load \""+ filename +"\"");
}
void MplayerProcess::setSubStep(int value) {
writeToStdin("sub_step " + QString::number(value));
}
void MplayerProcess::setChapter(int ID) {
writeToStdin("seek_chapter " + QString::number(ID) +" 1");
}
void MplayerProcess::setTitle(int ID) {
writeToStdin("switch_title " + QString::number(ID));
}
void MplayerProcess::setLoop(int v) {
writeToStdin(QString("loop %1 1").arg(v));
}
void MplayerProcess::setSubPos(int pos) {
writeToStdin("sub_pos " + QString::number(pos) + " 1");
}
