00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
#include "kfilterdev.h"
00020
#include "kfilterbase.h"
00021
#include <kdebug.h>
00022
#include <stdio.h>
00023
#include <stdlib.h>
00024
#include <assert.h>
00025
#include <qfile.h>
00026
00027
#define BUFFER_SIZE 8*1024
00028
00029
class KFilterDev::KFilterDevPrivate
00030 {
00031
public:
00032 KFilterDevPrivate() : bNeedHeader(true), bSkipHeaders(false),
00033 autoDeleteFilterBase(false), bOpenedUnderlyingDevice(false),
00034 bIgnoreData(false){}
00035
bool bNeedHeader;
00036
bool bSkipHeaders;
00037
bool autoDeleteFilterBase;
00038
bool bOpenedUnderlyingDevice;
00039
bool bIgnoreData;
00040
QByteArray buffer;
00041
QCString ungetchBuffer;
00042
QCString origFileName;
00043 KFilterBase::Result result;
00044 };
00045
00046 KFilterDev::KFilterDev(
KFilterBase * _filter,
bool autoDeleteFilterBase )
00047 : filter(_filter)
00048 {
00049 assert(filter);
00050 d =
new KFilterDevPrivate;
00051 d->autoDeleteFilterBase = autoDeleteFilterBase;
00052 }
00053
00054 KFilterDev::~KFilterDev()
00055 {
00056
if ( isOpen() )
00057
close();
00058
if ( d->autoDeleteFilterBase )
00059
delete filter;
00060
delete d;
00061 }
00062
00063
#ifndef KDE_NO_COMPAT
00064
00065
00066 QIODevice*
KFilterDev::createFilterDevice(
KFilterBase* base,
QFile* file)
00067 {
00068
if (file==0)
00069
return 0;
00070
00071
00072
if (base==0)
00073
return new QFile(file->name());
00074
00075 base->
setDevice(file);
00076
return new KFilterDev(base);
00077 }
00078
#endif
00079
00080
00081 QIODevice *
KFilterDev::deviceForFile(
const QString & fileName,
const QString & mimetype,
00082
bool forceFilter )
00083 {
00084
QFile * f =
new QFile( fileName );
00085
KFilterBase * base = mimetype.isEmpty() ?
KFilterBase::findFilterByFileName( fileName )
00086 :
KFilterBase::findFilterByMimeType( mimetype );
00087
if ( base )
00088 {
00089 base->
setDevice(f,
true);
00090
return new KFilterDev(base,
true);
00091 }
00092
if(!forceFilter)
00093
return f;
00094
else
00095 {
00096
delete f;
00097
return 0L;
00098 }
00099 }
00100
00101 QIODevice *
KFilterDev::device(
QIODevice* inDevice,
const QString & mimetype)
00102 {
00103
return device( inDevice, mimetype,
true );
00104 }
00105
00106 QIODevice *
KFilterDev::device(
QIODevice* inDevice,
const QString & mimetype,
bool autoDeleteInDevice )
00107 {
00108
if (inDevice==0)
00109
return 0;
00110
KFilterBase * base =
KFilterBase::findFilterByMimeType(mimetype);
00111
if ( base )
00112 {
00113 base->
setDevice(inDevice, autoDeleteInDevice);
00114
return new KFilterDev(base,
true );
00115 }
00116
return 0;
00117 }
00118
00119 bool KFilterDev::open(
int mode )
00120 {
00121
00122
if ( mode == IO_ReadOnly )
00123 {
00124 d->buffer.resize(0);
00125 d->ungetchBuffer.resize(0);
00126 }
00127
else
00128 {
00129 d->buffer.resize( BUFFER_SIZE );
00130 filter->
setOutBuffer( d->buffer.data(), d->buffer.size() );
00131 }
00132 d->bNeedHeader = !d->bSkipHeaders;
00133 filter->
init( mode );
00134 d->bOpenedUnderlyingDevice = !filter->
device()->isOpen();
00135
bool ret = d->bOpenedUnderlyingDevice ? filter->
device()->open( mode ) :
true;
00136 d->result = KFilterBase::OK;
00137
00138
if ( !ret )
00139
kdWarning(7005) <<
"KFilterDev::open: Couldn't open underlying device" <<
endl;
00140
else
00141 {
00142 setState( IO_Open );
00143 setMode( mode );
00144 }
00145 ioIndex = 0;
00146
return ret;
00147 }
00148
00149 void KFilterDev::close()
00150 {
00151
00152
if ( filter->
mode() == IO_WriteOnly )
00153 writeBlock( 0L, 0 );
00154
00155
00156 filter->
terminate();
00157
if ( d->bOpenedUnderlyingDevice )
00158 filter->
device()->close();
00159
00160 setState( 0 );
00161 }
00162
00163
void KFilterDev::flush()
00164 {
00165
00166 filter->
device()->flush();
00167
00168 }
00169
00170 QIODevice::Offset KFilterDev::size()
const
00171
{
00172
00173
00174
00175
00176
00177
00178
kdWarning(7005) <<
"KFilterDev::size - can't be implemented !!!!!!!! Returning -1 " <<
endl;
00179
00180
return (uint)-1;
00181 }
00182
00183 QIODevice::Offset
KFilterDev::at()
const
00184
{
00185
return ioIndex;
00186 }
00187
00188 bool KFilterDev::at( QIODevice::Offset pos )
00189 {
00190
00191
00192
if ( ioIndex == pos )
00193
return true;
00194
00195 Q_ASSERT ( filter->
mode() == IO_ReadOnly );
00196
00197
if ( pos == 0 )
00198 {
00199 ioIndex = 0;
00200
00201 d->ungetchBuffer.resize(0);
00202 d->bNeedHeader = !d->bSkipHeaders;
00203 d->result = KFilterBase::OK;
00204 filter->
setInBuffer(0L,0);
00205 filter->
reset();
00206
return filter->
device()->reset();
00207 }
00208
00209
if ( ioIndex < pos )
00210 pos = pos - ioIndex;
00211
else
00212 {
00213
00214
00215
if (!
at(0))
00216
return false;
00217 }
00218
00219
00220
QByteArray dummy( QMIN( pos, 3*BUFFER_SIZE ) );
00221 d->bIgnoreData =
true;
00222
bool result = ( (QIODevice::Offset)readBlock( dummy.data(), pos ) == pos );
00223 d->bIgnoreData =
false;
00224
return result;
00225 }
00226
00227
bool KFilterDev::atEnd()
const
00228
{
00229
return filter->
device()->atEnd() && (d->result == KFilterBase::END)
00230 && d->ungetchBuffer.isEmpty();
00231 }
00232
00233 Q_LONG KFilterDev::readBlock(
char *data, Q_ULONG maxlen )
00234 {
00235 Q_ASSERT ( filter->
mode() == IO_ReadOnly );
00236
00237
00238 uint dataReceived = 0;
00239
if ( !d->ungetchBuffer.isEmpty() )
00240 {
00241 Q_ULONG len = d->ungetchBuffer.length();
00242
if ( !d->bIgnoreData )
00243 {
00244
while ( ( dataReceived < len ) && ( dataReceived < maxlen ) )
00245 {
00246 *data = d->ungetchBuffer[ len - dataReceived - 1 ];
00247 data++;
00248 dataReceived++;
00249 }
00250 }
00251
else
00252 {
00253 dataReceived = QMIN( len, maxlen );
00254 }
00255 d->ungetchBuffer.truncate( len - dataReceived );
00256 ioIndex += dataReceived;
00257 }
00258
00259
00260
00261
if ( d->result == KFilterBase::END )
00262
return dataReceived;
00263
00264
00265
if ( d->result != KFilterBase::OK )
00266
return -1;
00267
00268
00269 Q_ULONG outBufferSize;
00270
if ( d->bIgnoreData )
00271 {
00272 outBufferSize = QMIN( maxlen, 3*BUFFER_SIZE );
00273 }
00274
else
00275 {
00276 outBufferSize = maxlen;
00277 }
00278 outBufferSize -= dataReceived;
00279 Q_ULONG availOut = outBufferSize;
00280 filter->
setOutBuffer( data, outBufferSize );
00281
00282
bool decompressedAll =
false;
00283
while ( dataReceived < maxlen )
00284 {
00285
if (filter->
inBufferEmpty())
00286 {
00287
00288
00289 d->buffer.resize( BUFFER_SIZE );
00290
00291
int size = filter->
device()->readBlock( d->buffer.data(),
00292 d->buffer.size() );
00293
if ( size )
00294 filter->
setInBuffer( d->buffer.data(), size );
00295
else {
00296
if ( decompressedAll )
00297 {
00298
00299
00300 d->result = KFilterBase::END;
00301
break;
00302 }
00303 }
00304
00305 }
00306
if (d->bNeedHeader)
00307 {
00308 (
void) filter->
readHeader();
00309 d->bNeedHeader =
false;
00310 }
00311
00312 d->result = filter->
uncompress();
00313
00314
if (d->result == KFilterBase::ERROR)
00315 {
00316
kdWarning(7005) <<
"KFilterDev: Error when uncompressing data" <<
endl;
00317
break;
00318 }
00319
00320
00321 uint outReceived = availOut - filter->
outBufferAvailable();
00322
00323
if( availOut < (uint)filter->
outBufferAvailable() )
00324
kdWarning(7005) <<
" last availOut " << availOut <<
" smaller than new avail_out=" << filter->
outBufferAvailable() <<
" !" <<
endl;
00325
00326 dataReceived += outReceived;
00327
if ( !d->bIgnoreData )
00328 {
00329 data += outReceived;
00330 availOut = maxlen - dataReceived;
00331 }
00332
else if ( maxlen - dataReceived < outBufferSize )
00333 {
00334 availOut = maxlen - dataReceived;
00335 }
00336 ioIndex += outReceived;
00337
if (d->result == KFilterBase::END)
00338 {
00339
00340
break;
00341 }
00342
if (filter->
inBufferEmpty() && filter->
outBufferAvailable() != 0 )
00343 {
00344 decompressedAll =
true;
00345 }
00346 filter->
setOutBuffer( data, availOut );
00347 }
00348
00349
return dataReceived;
00350 }
00351
00352 Q_LONG KFilterDev::writeBlock(
const char *data , Q_ULONG len )
00353 {
00354 Q_ASSERT ( filter->
mode() == IO_WriteOnly );
00355
00356
if ( d->result != KFilterBase::OK )
00357
return 0;
00358
00359
bool finish = (data == 0L);
00360
if (!finish)
00361 {
00362 filter->
setInBuffer( data, len );
00363
if (d->bNeedHeader)
00364 {
00365 (
void)filter->
writeHeader( d->origFileName );
00366 d->bNeedHeader =
false;
00367 }
00368 }
00369
00370 uint dataWritten = 0;
00371 uint availIn = len;
00372
while ( dataWritten < len || finish )
00373 {
00374
00375 d->result = filter->
compress( finish );
00376
00377
if (d->result == KFilterBase::ERROR)
00378 {
00379
kdWarning(7005) <<
"KFilterDev: Error when compressing data" <<
endl;
00380
00381
break;
00382 }
00383
00384
00385
if (filter->
inBufferEmpty() || (d->result == KFilterBase::END))
00386 {
00387
00388 uint wrote = availIn - filter->
inBufferAvailable();
00389
00390
00391
00392
00393 data += wrote;
00394 dataWritten += wrote;
00395 ioIndex += wrote;
00396
00397 availIn = len - dataWritten;
00398
00399
if ( availIn > 0 )
00400 filter->
setInBuffer( data, availIn );
00401 }
00402
00403
if (filter->
outBufferFull() || (d->result == KFilterBase::END))
00404 {
00405
00406
int towrite = d->buffer.size() - filter->
outBufferAvailable();
00407
if ( towrite > 0 )
00408 {
00409
00410
int size = filter->
device()->writeBlock( d->buffer.data(), towrite );
00411
if ( size != towrite ) {
00412
kdWarning(7005) <<
"KFilterDev::writeBlock. Could only write " << size <<
" out of " << towrite <<
" bytes" <<
endl;
00413
return 0;
00414 }
00415
00416
00417 }
00418 d->buffer.resize( 8*1024 );
00419 filter->
setOutBuffer( d->buffer.data(), d->buffer.size() );
00420
if (d->result == KFilterBase::END)
00421 {
00422
00423 Q_ASSERT(finish);
00424
break;
00425 }
00426 }
00427 }
00428
00429
return dataWritten;
00430 }
00431
00432
int KFilterDev::getch()
00433 {
00434 Q_ASSERT ( filter->
mode() == IO_ReadOnly );
00435
00436
if ( !d->ungetchBuffer.isEmpty() ) {
00437
int len = d->ungetchBuffer.length();
00438
int ch = d->ungetchBuffer[ len-1 ];
00439 d->ungetchBuffer.truncate( len - 1 );
00440 ioIndex++;
00441
00442
return ch;
00443 }
00444
char buf[1];
00445
int ret = readBlock( buf, 1 ) == 1 ? buf[0] : EOF;
00446
00447
return ret;
00448 }
00449
00450
int KFilterDev::putch(
int c )
00451 {
00452
00453
char buf[1];
00454 buf[0] = c;
00455
return writeBlock( buf, 1 ) == 1 ? c : -1;
00456 }
00457
00458
int KFilterDev::ungetch(
int ch )
00459 {
00460
00461
if ( ch == EOF )
00462
return ch;
00463
00464
00465 d->ungetchBuffer +=ch;
00466 ioIndex--;
00467
return ch;
00468 }
00469
00470 void KFilterDev::setOrigFileName(
const QCString & fileName )
00471 {
00472 d->origFileName = fileName;
00473 }
00474
00475 void KFilterDev::setSkipHeaders()
00476 {
00477 d->bSkipHeaders =
true;
00478 }