void QLinuxFbScreenPrivate::openTty()
{
const char *const devs[] = {"/dev/tty0", "/dev/tty", "/dev/console", 0};
if (ttyDevice.isEmpty()) {
for (const char * const *dev = devs; *dev; ++dev) {
ttyfd = QT_OPEN(*dev, O_RDWR);
if (ttyfd != -1)
break;
}
} else {
ttyfd = QT_OPEN(ttyDevice.toAscii().constData(), O_RDWR);
}
if (ttyfd == -1)
return;
if (doGraphicsMode) {
ioctl(ttyfd, KDGETMODE, &oldKdMode);
if (oldKdMode != KD_GRAPHICS) {
int ret = ioctl(ttyfd, KDSETMODE, KD_GRAPHICS);
if (ret == -1)
doGraphicsMode = false;
}
}
// No blankin' screen, no blinkin' cursor!, no cursor!
const char termctl[] = "\033[9;0]\033[?33l\033[?25l\033[?1c";
QT_WRITE(ttyfd, termctl, sizeof(termctl));
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
{
Q_Q(QFSFileEngine);
qint64 result;
qint64 written = 0;
do {
// Write blocks of 4k to avoid platform limitations (Windows commonly
// bails out if you read or write too large blocks at once).
qint64 bytesToWrite = qMin<qint64>(4096, len - written);
if (fh) {
do {
// Buffered stdlib mode.
result = qint64(fwrite(data + written, 1, size_t(bytesToWrite), fh));
} while (result == 0 && errno == EINTR);
if (bytesToWrite > 0 && result == 0)
result = -1;
} else {
do {
// Unbuffered stdio mode.
result = QT_WRITE(fd, data + written, bytesToWrite);
} while (result == -1 && errno == EINTR);
}
if (result > 0)
written += qint64(result);
} while (written < len && result > 0);
// If we read anything, return that with success. Otherwise, set an error,
// and return the last return value.
if (result > 0)
return written;
q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
return result;
}
static void resetTty(int ttyfd, int oldMode)
{
ioctl(ttyfd, KDSETMODE, oldMode);
// Blankin' screen, blinkin' cursor!
const char termctl[] = "\033[9;15]\033[?33h\033[?25h\033[?0c";
QT_WRITE(ttyfd, termctl, sizeof(termctl));
QT_CLOSE(ttyfd);
}
void init()
{
int n;
uchar reply[20];
if (tcflush(fd,TCIOFLUSH) == -1) {
#ifdef QWS_MOUSE_DEBUG
perror("QWSPcMouseSubHandler_intellimouse: pre-init tcflush");
#endif
}
static const uchar initseq[] = { 243, 200, 243, 100, 243, 80 };
static const uchar query[] = { 0xf2 };
if (QT_WRITE(fd, initseq, sizeof(initseq))!=sizeof(initseq)) {
badness = 100;
return;
}
usleep(10000);
if (tcflush(fd,TCIOFLUSH) == -1) {
#ifdef QWS_MOUSE_DEBUG
perror("QWSPcMouseSubHandler_intellimouse: post-init tcflush");
#endif
}
if (QT_WRITE(fd, query, sizeof(query))!=sizeof(query)) {
badness = 100;
return;
}
usleep(10000);
n = QT_READ(fd, reply, 20);
if (n > 0) {
goodness = 10;
switch (reply[n-1]) {
case 3:
case 4:
packetsize = 4;
break;
default:
packetsize = 3;
}
} else {
badness = 100;
}
}
static bool switchToGraphicsMode(int ttyfd, int *oldMode)
{
ioctl(ttyfd, KDGETMODE, oldMode);
if (*oldMode != KD_GRAPHICS) {
if (ioctl(ttyfd, KDSETMODE, KD_GRAPHICS) != 0)
return false;
}
// No blankin' screen, no blinkin' cursor!, no cursor!
const char termctl[] = "\033[9;0]\033[?33l\033[?25l\033[?1c";
QT_WRITE(ttyfd, termctl, sizeof(termctl));
return true;
}
void QLinuxFbScreenPrivate::closeTty()
{
if (ttyfd == -1)
return;
if (doGraphicsMode)
ioctl(ttyfd, KDSETMODE, oldKdMode);
// Blankin' screen, blinkin' cursor!
const char termctl[] = "\033[9;15]\033[?33h\033[?25h\033[?0c";
QT_WRITE(ttyfd, termctl, sizeof(termctl));
QT_CLOSE(ttyfd);
ttyfd = -1;
}
void init()
{
if (tcflush(fd,TCIOFLUSH) == -1) {
#ifdef QWS_MOUSE_DEBUG
perror("QWSPcMouseSubHandler_mouseman: initial tcflush");
#endif
}
QT_WRITE(fd,"",1);
usleep(50000);
QT_WRITE(fd,"@EeI!",5);
usleep(10000);
static const char ibuf[] = { 246, 244 };
QT_WRITE(fd,ibuf,1);
QT_WRITE(fd,ibuf+1,1);
if (tcflush(fd,TCIOFLUSH) == -1) {
#ifdef QWS_MOUSE_DEBUG
perror("QWSPcMouseSubHandler_mouseman: tcflush");
#endif
}
usleep(10000);
char buf[100];
while (QT_READ(fd, buf, 100) > 0) { } // eat unwanted replies
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::WriteError, qt_error_string(EINVAL));
return -1;
}
qint64 writtenBytes = 0;
if (fh) {
// Buffered stdlib mode.
size_t result;
do {
result = fwrite(data + writtenBytes, 1, size_t(len - writtenBytes), fh);
writtenBytes += result;
} while (result == 0 ? errno == EINTR : writtenBytes < len);
} else if (fd != -1) {
// Unbuffered stdio mode.
SignedIOType result;
do {
// calculate the chunk size
// on Windows or 32-bit no-largefile Unix, we'll need to read in chunks
// we limit to the size of the signed type, otherwise we could get a negative number as a result
quint64 wantedBytes = quint64(len) - quint64(writtenBytes);
UnsignedIOType chunkSize = std::numeric_limits<SignedIOType>::max();
if (chunkSize > wantedBytes)
chunkSize = wantedBytes;
result = QT_WRITE(fd, data + writtenBytes, chunkSize);
} while (result > 0 && (writtenBytes += result) < len);
}
if (len && writtenBytes == 0) {
writtenBytes = -1;
q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
} else {
// reset the cached size, if any
metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
}
return writtenBytes;
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::WriteError, qt_error_string(EINVAL));
return -1;
}
qint64 writtenBytes = 0;
if (fh) {
// Buffered stdlib mode.
size_t result;
do {
result = fwrite(data + writtenBytes, 1, size_t(len - writtenBytes), fh);
writtenBytes += result;
} while (result == 0 ? errno == EINTR : writtenBytes < len);
} else if (fd != -1) {
// Unbuffered stdio mode.
#ifdef Q_OS_WIN
int result;
#else
ssize_t result;
#endif
do {
result = QT_WRITE(fd, data + writtenBytes, size_t(len - writtenBytes));
} while ((result == -1 && errno == EINTR)
|| (result > 0 && (writtenBytes += result) < len));
}
if (len && writtenBytes == 0) {
writtenBytes = -1;
q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
}
return writtenBytes;
}
void decode_mov(decode_t *decode)
{
quicktime_t *qt_handle=NULL;
unsigned char **p_raw_buffer;
char *p_v_codec=NULL,*p_a_codec=NULL,*p_buffer=NULL,*p_tmp=NULL;
int s_width=0,s_height=0,s_channel=0,s_bits=0,s_buff_size=0,s_audio_size=0,s_video_size=0,s_sample=0;
int s_cont,s_frames;
double s_fps=0;
long s_audio_rate,s_qt_pos;
uint16_t *p_mask1, *p_mask2;
char msgbuf[TC_BUF_MIN];
qt_handle = quicktime_open((char * )decode->name, 1, 0);
if (qt_handle == NULL) {
QT_ABORT("can't open quicktime!");
}
quicktime_set_preload(qt_handle, 10240000);
s_fps = quicktime_frame_rate(qt_handle, 0);
if (decode->format == TC_CODEC_PCM) {
if (quicktime_audio_tracks(qt_handle) == 0) {
QT_ABORT("no audio track in quicktime found!");
}
s_channel = quicktime_track_channels(qt_handle, 0);
s_audio_rate = quicktime_sample_rate(qt_handle, 0);
s_bits = quicktime_audio_bits(qt_handle, 0);
s_audio_size = quicktime_audio_length(qt_handle,0);
p_a_codec = quicktime_audio_compressor(qt_handle, 0);
if (decode->frame_limit[1] < s_audio_size) {
s_audio_size = decode->frame_limit[1] - decode->frame_limit[0];
} else {
s_audio_size -= decode->frame_limit[0];
}
if (decode->verbose) {
tc_log_info(__FILE__, "Audio codec=%s, rate=%ld Hz, bits=%d, channels=%d",
p_a_codec, s_audio_rate, s_bits, s_channel);
}
if ((s_bits != 8) && (s_bits != 16)) {
tc_snprintf(msgbuf, sizeof(msgbuf), "unsupported %d bit rate"
" in quicktime!", s_bits);
QT_ABORT(msgbuf);
}
if (s_channel > 2) {
tc_snprintf(msgbuf, sizeof(msgbuf), "too many audio tracks "
"(%d) found in quicktime!", s_channel);
QT_ABORT(msgbuf);
}
if (strlen(p_a_codec) == 0) {
QT_ABORT("unsupported codec (empty!) in quicktime!");
}
if (quicktime_supported_audio(qt_handle, 0) != 0) {
s_qt_pos = quicktime_audio_position(qt_handle,0);
s_sample = (1.00 * s_channel * s_bits *s_audio_rate)/(s_fps * 8);
s_buff_size = s_sample * sizeof(uint16_t);
p_buffer = tc_malloc(s_buff_size);
if (s_bits == 16)
s_sample /= 2;
if (s_channel == 1) {
p_mask1=(uint16_t *)p_buffer;
quicktime_set_audio_position(qt_handle, s_qt_pos + decode->frame_limit[0], 0);
for (; s_audio_size > 0; s_audio_size -= s_sample) {
if (quicktime_decode_audio(qt_handle, p_mask1, NULL, s_sample, 0) < 0) {
QT_ABORT("error reading quicktime audio frame");
}
QT_WRITE(decode->fd_out, p_buffer, s_buff_size);
}
} else {
s_sample /= 2;
p_mask1 = (uint16_t *)p_buffer;
p_mask2 = tc_malloc(s_sample * sizeof(uint16_t));
s_qt_pos += decode->frame_limit[0];
quicktime_set_audio_position(qt_handle, s_qt_pos, 0);
for (; s_audio_size > 0; s_audio_size -= s_sample) {
if (quicktime_decode_audio(qt_handle, p_mask1, NULL, s_sample, 0) < 0) {
QT_ABORT("error reading quicktime audio frame");
}
quicktime_set_audio_position(qt_handle, s_qt_pos, 0);
if (quicktime_decode_audio(qt_handle,p_mask2, NULL,s_sample, 1) < 0) {
QT_ABORT("error reading quicktime audio frame");
}
for (s_cont = s_sample - 1; s_cont >= 0; s_cont--)
p_mask1[s_cont<<1] = p_mask1[s_cont];
for (s_cont = 0; s_cont < s_sample; s_cont++)
p_mask1[1+(s_cont<<1)] = p_mask2[s_cont];
s_qt_pos += s_sample;
QT_WRITE(decode->fd_out, p_buffer, s_buff_size >> 1);
}
free(p_mask2);
}
free(p_buffer);
}
#if !defined(LIBQUICKTIME_000904)
else if ((strcasecmp(p_a_codec, QUICKTIME_RAW) == 0)
