You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1838 lines
51 KiB
1838 lines
51 KiB
15 years ago
|
//C- -*- C++ -*-
|
||
|
//C- -------------------------------------------------------------------
|
||
|
//C- DjVuLibre-3.5
|
||
|
//C- Copyright (c) 2002 Leon Bottou and Yann Le Cun.
|
||
|
//C- Copyright (c) 2001 AT&T
|
||
|
//C-
|
||
|
//C- This software is subject to, and may be distributed under, the
|
||
|
//C- GNU General Public License, Version 2. The license should have
|
||
|
//C- accompanied the software or you may obtain a copy of the license
|
||
|
//C- from the Free Software Foundation at http://www.fsf.org .
|
||
|
//C-
|
||
|
//C- This program is distributed in the hope that it will be useful,
|
||
|
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
//C- GNU General Public License for more details.
|
||
|
//C-
|
||
|
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library
|
||
|
//C- distributed by Lizardtech Software. On July 19th 2002, Lizardtech
|
||
|
//C- Software authorized us to replace the original DjVu(r) Reference
|
||
|
//C- Library notice by the following text (see doc/lizard2002.djvu):
|
||
|
//C-
|
||
|
//C- ------------------------------------------------------------------
|
||
|
//C- | DjVu (r) Reference Library (v. 3.5)
|
||
|
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
|
||
|
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
|
||
|
//C- | 6,058,214 and patents pending.
|
||
|
//C- |
|
||
|
//C- | This software is subject to, and may be distributed under, the
|
||
|
//C- | GNU General Public License, Version 2. The license should have
|
||
|
//C- | accompanied the software or you may obtain a copy of the license
|
||
|
//C- | from the Free Software Foundation at http://www.fsf.org .
|
||
|
//C- |
|
||
|
//C- | The computer code originally released by LizardTech under this
|
||
|
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
|
||
|
//C- | ORIGINAL CODE." Subject to any third party intellectual property
|
||
|
//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
|
||
|
//C- | non-exclusive license to make, use, sell, or otherwise dispose of
|
||
|
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
|
||
|
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
|
||
|
//C- | General Public License. This grant only confers the right to
|
||
|
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
|
||
|
//C- | the extent such infringement is reasonably necessary to enable
|
||
|
//C- | recipient to make, have made, practice, sell, or otherwise dispose
|
||
|
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
|
||
|
//C- | any greater extent that may be necessary to utilize further
|
||
|
//C- | modifications or combinations.
|
||
|
//C- |
|
||
|
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
|
||
|
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||
|
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
|
||
|
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
//C- +------------------------------------------------------------------
|
||
|
//
|
||
|
// $Id: DataPool.cpp,v 1.11 2004/08/06 15:11:29 leonb Exp $
|
||
|
// $Name: release_3_5_15 $
|
||
|
|
||
|
#ifdef HAVE_CONFIG_H
|
||
|
# include "config.h"
|
||
|
#endif
|
||
|
#if NEED_GNUG_PRAGMAS
|
||
|
# pragma implementation
|
||
|
#endif
|
||
|
|
||
|
#include "DataPool.h"
|
||
|
#include "IFFByteStream.h"
|
||
|
#include "GString.h"
|
||
|
#include "GOS.h"
|
||
|
#include "GURL.h"
|
||
|
#include "debug.h"
|
||
|
|
||
|
#ifndef macintosh
|
||
|
# include <sys/types.h>
|
||
|
#endif
|
||
|
|
||
|
#ifdef HAVE_NAMESPACES
|
||
|
namespace DJVU {
|
||
|
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
|
||
|
}
|
||
|
#endif
|
||
|
#endif
|
||
|
|
||
|
const char * DataPool::Stop = ERR_MSG("STOP");
|
||
|
|
||
|
static void
|
||
|
// call_callback(void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data)
|
||
|
call_callback(void (* callback)(void *), void *cl_data)
|
||
|
{
|
||
|
G_TRY
|
||
|
{
|
||
|
if (callback)
|
||
|
callback(cl_data);
|
||
|
} G_CATCH_ALL {} G_ENDCATCH;
|
||
|
}
|
||
|
|
||
|
|
||
|
//****************************************************************************
|
||
|
//****************************** OpenFiles ***********************************
|
||
|
//****************************************************************************
|
||
|
|
||
|
#define MAX_OPEN_FILES 15
|
||
|
|
||
|
/** The purpose of this class is to limit the number of files open by
|
||
|
connected DataPools. Now, when a DataPool is connected to a file, it
|
||
|
doesn't necessarily has it open. Every time it needs access to data
|
||
|
it's supposed to ask this file for the ByteStream. It should
|
||
|
also inform the class when it's going to die (so that the file can
|
||
|
be closed). OpenFiles makes sure, that the number of open files
|
||
|
doesn't exceed MAX_OPEN_FILES. When it does, it looks for the oldest
|
||
|
file, closes it and asks all DataPools working with it to ZERO
|
||
|
their GP<> pointers. */
|
||
|
class DataPool::OpenFiles_File : public GPEnabled
|
||
|
{
|
||
|
public:
|
||
|
GURL url;
|
||
|
GP<ByteStream> stream; // Stream connected to 'url'
|
||
|
GCriticalSection stream_lock;
|
||
|
GPList<DataPool> pools_list; // List of pools using this stream
|
||
|
GCriticalSection pools_lock;
|
||
|
unsigned long open_time; // Time when stream was open
|
||
|
|
||
|
int add_pool(GP<DataPool> &pool);
|
||
|
int del_pool(GP<DataPool> &pool);
|
||
|
|
||
|
OpenFiles_File(const GURL &url, GP<DataPool> &pool);
|
||
|
virtual ~OpenFiles_File(void);
|
||
|
void clear_stream(void);
|
||
|
};
|
||
|
|
||
|
class DataPool::OpenFiles : public GPEnabled
|
||
|
{
|
||
|
private:
|
||
|
static OpenFiles * global_ptr;
|
||
|
|
||
|
GPList<DataPool::OpenFiles_File> files_list;
|
||
|
GCriticalSection files_lock;
|
||
|
public:
|
||
|
static OpenFiles * get(void);
|
||
|
|
||
|
// Opend the specified file if necessary (or finds an already open one)
|
||
|
// and returns it. The caller (pool) is stored in the list associated
|
||
|
// with the stream. Whenever OpenFiles decides, that this stream
|
||
|
// had better be closed, it will order every pool from the list to
|
||
|
// ZERO their references to it
|
||
|
GP<DataPool::OpenFiles_File> request_stream(const GURL &url, GP<DataPool> pool);
|
||
|
// If there are more than MAX_STREAM_FILES open, close the oldest.
|
||
|
void prune(void);
|
||
|
// Removes the pool from the list associated with the stream.
|
||
|
// If there is nobody else using this stream, the stream will
|
||
|
// be closed too.
|
||
|
void stream_released(GP<ByteStream> &stream, GP<DataPool> pool);
|
||
|
|
||
|
void close_all(void);
|
||
|
};
|
||
|
|
||
|
DataPool::OpenFiles * DataPool::OpenFiles::global_ptr;
|
||
|
|
||
|
DataPool::OpenFiles_File::OpenFiles_File(const GURL &xurl, GP<DataPool> &pool) : url(xurl)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles_File::OpenFiles_File(): Opening file '" << url << "'\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
open_time=GOS::ticks();
|
||
|
stream=ByteStream::create(url,"rb");
|
||
|
add_pool(pool);
|
||
|
}
|
||
|
|
||
|
DataPool::OpenFiles_File::~OpenFiles_File(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles_File::~OpenFiles_File(): Closing file '" << url << "'\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
clear_stream();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::OpenFiles_File::clear_stream(void)
|
||
|
{
|
||
|
GCriticalSectionLock lock(&pools_lock);
|
||
|
for(GPosition pos=pools_list;pos;++pos)
|
||
|
if(pools_list[pos])
|
||
|
pools_list[pos]->clear_stream(false);
|
||
|
pools_list.empty();
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::OpenFiles_File::add_pool(GP<DataPool> &pool)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles_File::add_pool: pool=" << (void *) pool << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&pools_lock);
|
||
|
if (!pools_list.contains(pool))
|
||
|
pools_list.append(pool);
|
||
|
return pools_list.size();
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::OpenFiles_File::del_pool(GP<DataPool> &pool)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles_File::del_pool: pool=" << (void *) pool << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&pools_lock);
|
||
|
GPosition pos;
|
||
|
if (pools_list.search(pool, pos))
|
||
|
pools_list.del(pos);
|
||
|
return pools_list.size();
|
||
|
}
|
||
|
|
||
|
inline DataPool::OpenFiles *
|
||
|
DataPool::OpenFiles::get(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles::get()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
if (!global_ptr)
|
||
|
global_ptr=new OpenFiles();
|
||
|
return global_ptr;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::OpenFiles::prune(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles::prune(void): "<<files_list.size()<< "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
while(files_list.size()>MAX_OPEN_FILES)
|
||
|
{
|
||
|
// Too many open files (streams). Get rid of the oldest one.
|
||
|
unsigned long oldest_time=GOS::ticks();
|
||
|
GPosition oldest_pos=files_list;
|
||
|
for(GPosition pos=files_list;pos;++pos)
|
||
|
{
|
||
|
if (files_list[pos]->open_time<oldest_time)
|
||
|
{
|
||
|
oldest_time=files_list[pos]->open_time;
|
||
|
oldest_pos=pos;
|
||
|
}
|
||
|
}
|
||
|
files_list[oldest_pos]->clear_stream();
|
||
|
files_list.del(oldest_pos);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// GP<ByteStream> & stream,
|
||
|
// GCriticalSection ** stream_lock)
|
||
|
GP<DataPool::OpenFiles_File>
|
||
|
DataPool::OpenFiles::request_stream(const GURL &url, GP<DataPool> pool)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles::request_stream(): url='" << url << "'\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
GP<DataPool::OpenFiles_File> file;
|
||
|
|
||
|
// Check: maybe the stream has already been open by request of
|
||
|
// another DataPool
|
||
|
GCriticalSectionLock lock(&files_lock);
|
||
|
for(GPosition pos=files_list;pos;++pos)
|
||
|
{
|
||
|
if (files_list[pos]->url==url)
|
||
|
{
|
||
|
DEBUG_MSG("found existing stream\n");
|
||
|
file=files_list[pos];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// No? Open the stream, but check, that there are not
|
||
|
// too many streams open
|
||
|
if (!file)
|
||
|
{
|
||
|
file=new DataPool::OpenFiles_File(url, pool);
|
||
|
files_list.append(file);
|
||
|
prune();
|
||
|
}
|
||
|
|
||
|
file->add_pool(pool);
|
||
|
return file;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::OpenFiles::stream_released(GP<ByteStream> &stream, GP<DataPool> pool)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles::stream_release: stream="
|
||
|
<< (void *)stream << " pool=" << (void *)pool << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&files_lock);
|
||
|
for(GPosition pos=files_list;pos;)
|
||
|
{
|
||
|
GPosition dpos = pos;
|
||
|
++pos;
|
||
|
GP<DataPool::OpenFiles_File> f=files_list[dpos];
|
||
|
if ((ByteStream *)(f->stream) == (ByteStream *)stream)
|
||
|
if (f->del_pool(pool)==0)
|
||
|
files_list.del(dpos);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// This isn't really an accurate url. The files are not really
|
||
|
// closed. Instead they are dereferenced from the data pool. If
|
||
|
// a there is another reference to the respective bytestream, it
|
||
|
// will remain open until dereferenced.
|
||
|
void
|
||
|
DataPool::OpenFiles::close_all(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::OpenFiles::close_all\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&files_lock);
|
||
|
files_list.empty();
|
||
|
}
|
||
|
|
||
|
//****************************************************************************
|
||
|
//******************************** FCPools ***********************************
|
||
|
//****************************************************************************
|
||
|
|
||
|
/** This class is used to maintain a list of DataPools connected to a file.
|
||
|
It's important to have this list if we want to do something with this file
|
||
|
like to modify it or just erase. Since any modifications of the file
|
||
|
will break DataPools directly connected to it, it would be nice to have
|
||
|
a mechanism for signaling all the related DataPools to read data into
|
||
|
memory. This is precisely the purpose of this class. */
|
||
|
class FCPools
|
||
|
{
|
||
|
private:
|
||
|
GMap<GURL, GPList<DataPool> > map; // GMap<GUTF8String, GPList<DataPool>> in fact
|
||
|
GCriticalSection map_lock;
|
||
|
|
||
|
static FCPools * global_ptr;
|
||
|
public:
|
||
|
static FCPools * get(void);
|
||
|
// Adds the <furl, pool> pair into the list
|
||
|
void add_pool(const GURL &furl, GP<DataPool> pool);
|
||
|
// Removes the <furl, pool> pair from the list
|
||
|
void del_pool(const GURL &furl, GP<DataPool> pool);
|
||
|
// Looks for the list of DataPools connected to 'furl' and makes
|
||
|
// each of them load the contents of the file into memory
|
||
|
void load_file(const GURL &url);
|
||
|
// Retrieve a local URL, if available.
|
||
|
GP<DataPool> get_pool(const GURL &url, int start, int length);
|
||
|
void clean(void);
|
||
|
};
|
||
|
|
||
|
void
|
||
|
FCPools::clean(void)
|
||
|
{
|
||
|
GCriticalSectionLock lock(&map_lock);
|
||
|
static int count=0;
|
||
|
if(! count++)
|
||
|
{
|
||
|
bool restart = true;
|
||
|
while (restart)
|
||
|
{
|
||
|
restart = false;
|
||
|
for (GPosition posmap = map; posmap; ++posmap)
|
||
|
{
|
||
|
GPList<DataPool> *lst;
|
||
|
lst = & map[posmap];
|
||
|
if (lst->isempty())
|
||
|
{
|
||
|
map.del(posmap);
|
||
|
restart = true;
|
||
|
break;
|
||
|
}
|
||
|
for (GPosition poslst = *lst; poslst; ++poslst)
|
||
|
if ((*lst)[poslst]->get_count() < 2)
|
||
|
{
|
||
|
lst->del(poslst);
|
||
|
restart = true;
|
||
|
break;
|
||
|
}
|
||
|
if (restart)
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
--count;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
FCPools::add_pool(const GURL &url, GP<DataPool> pool)
|
||
|
{
|
||
|
DEBUG_MSG("FCPools::add_pool: url='" << url << "' pool=" << (void *)pool << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&map_lock);
|
||
|
|
||
|
if (url.is_local_file_url())
|
||
|
{
|
||
|
GPList<DataPool> list;
|
||
|
GPosition pos(map.contains(url));
|
||
|
if (! pos)
|
||
|
{
|
||
|
map[url]=list;
|
||
|
pos=map.contains(url);
|
||
|
}
|
||
|
GPList<DataPool> &plist=map[pos];
|
||
|
if (!plist.contains(pool))
|
||
|
plist.append(pool);
|
||
|
}
|
||
|
clean();
|
||
|
}
|
||
|
|
||
|
GP<DataPool>
|
||
|
FCPools::get_pool(const GURL &url, int start, int length)
|
||
|
{
|
||
|
DEBUG_MSG("FCPools::get_pool: url='" << url << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GP<DataPool> retval;
|
||
|
if (url.is_local_file_url())
|
||
|
{
|
||
|
GCriticalSectionLock lock(&map_lock);
|
||
|
GPosition pos(map.contains(url));
|
||
|
if (pos)
|
||
|
{
|
||
|
GPList<DataPool> &plist=map[pos];
|
||
|
for(pos=plist;pos;++pos)
|
||
|
{
|
||
|
DataPool &pool=*plist[pos];
|
||
|
if(start == pool.start && (length < 0 || (length == pool.length)))
|
||
|
{
|
||
|
retval=plist[pos];
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
clean();
|
||
|
}
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
FCPools::del_pool(const GURL &url, GP<DataPool> pool)
|
||
|
{
|
||
|
DEBUG_MSG("FCPools::del_pool: url='" << url << "' pool=" << (void *)pool << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&map_lock);
|
||
|
|
||
|
clean();
|
||
|
if (url.is_local_file_url())
|
||
|
{
|
||
|
GPosition pos;
|
||
|
if (map.contains(url, pos))
|
||
|
{
|
||
|
GPList<DataPool> &list=map[pos];
|
||
|
GPosition list_pos;
|
||
|
while(list.search(pool, list_pos))
|
||
|
list.del(list_pos);
|
||
|
if (list.isempty())
|
||
|
{
|
||
|
map.del(pos);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
FCPools::load_file(const GURL &url)
|
||
|
{
|
||
|
DEBUG_MSG("FCPools::load_file: url='" << url << "'\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lock(&map_lock);
|
||
|
|
||
|
clean();
|
||
|
if (url.is_local_file_url())
|
||
|
{
|
||
|
GPosition pos;
|
||
|
if (map.contains(url, pos))
|
||
|
{
|
||
|
// We make here a copy of the list because DataPool::load_file()
|
||
|
// will call FCPools::del_pool(), which will modify the list
|
||
|
GPList<DataPool> list=map[pos];
|
||
|
for(GPosition list_pos=list;list_pos;++list_pos)
|
||
|
list[list_pos]->load_file();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
FCPools * FCPools::global_ptr;
|
||
|
|
||
|
inline FCPools *
|
||
|
FCPools::get(void)
|
||
|
{
|
||
|
if (!global_ptr)
|
||
|
global_ptr=new FCPools();
|
||
|
return global_ptr;
|
||
|
}
|
||
|
|
||
|
//****************************************************************************
|
||
|
//****************************** BlockList ***********************************
|
||
|
//****************************************************************************
|
||
|
|
||
|
// Since data can be added to the DataPool at any offset now, there may
|
||
|
// be white spots, which contain illegal data. This class is to contain
|
||
|
// the list of valid and invalid regions.
|
||
|
// The class is basically a list of integers. Abs(integer)=size of the
|
||
|
// block. If the integer is positive, data for the block is known.
|
||
|
// Otherwise it's unkown.
|
||
|
|
||
|
class DataPool::BlockList
|
||
|
{
|
||
|
// See comments in .cpp file.
|
||
|
private:
|
||
|
GCriticalSection lock;
|
||
|
GList<int> list;
|
||
|
public:
|
||
|
BlockList() {};
|
||
|
void clear(void);
|
||
|
void add_range(int start, int length);
|
||
|
int get_bytes(int start, int length) const;
|
||
|
int get_range(int start, int length) const;
|
||
|
friend class DataPool;
|
||
|
};
|
||
|
|
||
|
void
|
||
|
DataPool::BlockList::clear(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::BlockList::clear()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
GCriticalSectionLock lk(&lock);
|
||
|
list.empty();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::BlockList::add_range(int start, int length)
|
||
|
// Adds range of known data.
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::BlockList::add_range: start=" << start << " length=" << length << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
if (start<0)
|
||
|
G_THROW( ERR_MSG("DataPool.neg_start") );
|
||
|
if (length<=0)
|
||
|
G_THROW( ERR_MSG("DataPool.bad_length") );
|
||
|
if (length>0)
|
||
|
{
|
||
|
GCriticalSectionLock lk(&lock);
|
||
|
|
||
|
// Look thru existing zones, change their sign and split if
|
||
|
// necessary.
|
||
|
GPosition pos=list;
|
||
|
int block_start=0, block_end=0;
|
||
|
while(pos && block_start<start+length)
|
||
|
{
|
||
|
int size=list[pos];
|
||
|
block_end=block_start+abs(size);
|
||
|
if (size<0)
|
||
|
if (block_start<start)
|
||
|
{
|
||
|
if (block_end>start && block_end<=start+length)
|
||
|
{
|
||
|
list[pos]=-(start-block_start);
|
||
|
list.insert_after(pos, block_end-start);
|
||
|
++pos;
|
||
|
block_start=start;
|
||
|
} else if (block_end>start+length)
|
||
|
{
|
||
|
list[pos]=-(start-block_start);
|
||
|
list.insert_after(pos, length);
|
||
|
++pos;
|
||
|
list.insert_after(pos, -(block_end-(start+length)));
|
||
|
++pos;
|
||
|
block_start=start+length;
|
||
|
}
|
||
|
} else if (block_start>=start && block_start<start+length)
|
||
|
{
|
||
|
if (block_end<=start+length) list[pos]=abs(size);
|
||
|
else
|
||
|
{
|
||
|
list[pos]=start+length-block_start;
|
||
|
list.insert_after(pos, -(block_end-(start+length)));
|
||
|
++pos;
|
||
|
block_start=start+length;
|
||
|
}
|
||
|
}
|
||
|
block_start=block_end;
|
||
|
++pos;
|
||
|
}
|
||
|
if (block_end<start)
|
||
|
{
|
||
|
list.append(-(start-block_end));
|
||
|
list.append(length);
|
||
|
} else if (block_end<start+length) list.append(start+length-block_end);
|
||
|
|
||
|
// Now merge adjacent areas with the same sign
|
||
|
pos=list;
|
||
|
while(pos)
|
||
|
{
|
||
|
GPosition pos1=pos; ++pos1;
|
||
|
while(pos1)
|
||
|
{
|
||
|
if (list[pos]<0 && list[pos1]>0 ||
|
||
|
list[pos]>0 && list[pos1]<0)
|
||
|
break;
|
||
|
list[pos]+=list[pos1];
|
||
|
GPosition this_pos=pos1;
|
||
|
++pos1;
|
||
|
list.del(this_pos);
|
||
|
}
|
||
|
pos=pos1;
|
||
|
}
|
||
|
} // if (length>0)
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::BlockList::get_bytes(int start, int length) const
|
||
|
// Returns the number of bytes of data available in the range
|
||
|
// [start, start+length[. There may be holes between data chunks
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::BlockList::get_bytes: start=" << start << " length=" << length << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (length<0)
|
||
|
G_THROW( ERR_MSG("DataPool.bad_length") );
|
||
|
|
||
|
GCriticalSectionLock lk((GCriticalSection *) &lock);
|
||
|
int bytes=0;
|
||
|
int block_start=0, block_end=0;
|
||
|
for(GPosition pos=list;pos && block_start<start+length;++pos)
|
||
|
{
|
||
|
int size=list[pos];
|
||
|
block_end=block_start+abs(size);
|
||
|
if (size>0)
|
||
|
if (block_start<start)
|
||
|
{
|
||
|
if (block_end>=start && block_end<start+length)
|
||
|
bytes+=block_end-start;
|
||
|
else if (block_end>=start+length)
|
||
|
bytes+=length;
|
||
|
} else
|
||
|
{
|
||
|
if (block_end<=start+length)
|
||
|
bytes+=block_end-block_start;
|
||
|
else bytes+=start+length-block_start;
|
||
|
}
|
||
|
block_start=block_end;
|
||
|
}
|
||
|
return bytes;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::BlockList::get_range(int start, int length) const
|
||
|
// Finds a range covering offset=start and returns the length
|
||
|
// of intersection of this range with [start, start+length[
|
||
|
// 0 is returned if nothing can be found
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::BlockList::get_range: start=" << start << " length=" << length << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
if (start<0)
|
||
|
G_THROW( ERR_MSG("DataPool.neg_start") );
|
||
|
if (length<=0)
|
||
|
G_THROW( ERR_MSG("DataPool.bad_length") );
|
||
|
|
||
|
GCriticalSectionLock lk((GCriticalSection *) &lock);
|
||
|
int block_start=0, block_end=0;
|
||
|
for(GPosition pos=list;pos && block_start<start+length;++pos)
|
||
|
{
|
||
|
int size=list[pos];
|
||
|
block_end=block_start+abs(size);
|
||
|
if (block_start<=start && block_end>start)
|
||
|
if (size<0) return -1;
|
||
|
else
|
||
|
if (block_end>start+length) return length;
|
||
|
else return block_end-start;
|
||
|
block_start=block_end;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
//****************************************************************************
|
||
|
//******************************* DataPool ***********************************
|
||
|
//****************************************************************************
|
||
|
|
||
|
class DataPool::Reader : public GPEnabled
|
||
|
{
|
||
|
public:
|
||
|
GEvent event;
|
||
|
bool reenter_flag;
|
||
|
int offset;
|
||
|
int size;
|
||
|
Reader() : reenter_flag(false), offset(0), size(-1){};
|
||
|
Reader(int offset_in, int size_in=-1) :
|
||
|
reenter_flag(false), offset(offset_in), size(size_in) {};
|
||
|
virtual ~Reader() {};
|
||
|
};
|
||
|
|
||
|
class DataPool::Trigger : public GPEnabled
|
||
|
{
|
||
|
public:
|
||
|
GSafeFlags disabled;
|
||
|
int start, length;
|
||
|
// void (* callback)(GP<GPEnabled> &);
|
||
|
void (* callback)(void *);
|
||
|
// GP<GPEnabled> cl_data;
|
||
|
void *cl_data;
|
||
|
|
||
|
Trigger() : start(0), length(-1), callback(0), cl_data(0) {};
|
||
|
Trigger(int xstart, int xlength,
|
||
|
// void (* xcallback)(GP<GPEnabled> &), GP<GPEnabled> xcl_data) :
|
||
|
void (* xcallback)(void *), void *xcl_data) :
|
||
|
start(xstart), length(xlength), callback(xcallback), cl_data(xcl_data) {};
|
||
|
virtual ~Trigger() {};
|
||
|
};
|
||
|
|
||
|
class DataPool::Counter
|
||
|
{
|
||
|
private:
|
||
|
int counter;
|
||
|
GCriticalSection lock;
|
||
|
public:
|
||
|
Counter() : counter(0) {};
|
||
|
operator int(void) const;
|
||
|
void inc(void);
|
||
|
void dec(void);
|
||
|
};
|
||
|
|
||
|
#define DATAPOOL_INIT eof_flag(false),stop_flag(false), \
|
||
|
stop_blocked_flag(false), \
|
||
|
add_at(0),start(0),length(-1)
|
||
|
|
||
|
void
|
||
|
DataPool::init(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::init(): Initializing\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
start=0; length=-1; add_at=0;
|
||
|
eof_flag=false;
|
||
|
stop_flag=false;
|
||
|
stop_blocked_flag=false;
|
||
|
|
||
|
active_readers=new Counter;
|
||
|
block_list=0;
|
||
|
G_TRY
|
||
|
{
|
||
|
block_list=new BlockList;
|
||
|
data=ByteStream::create();
|
||
|
}
|
||
|
G_CATCH_ALL
|
||
|
{
|
||
|
delete block_list;
|
||
|
block_list=0;
|
||
|
delete active_readers;
|
||
|
active_readers=0;
|
||
|
G_RETHROW;
|
||
|
}
|
||
|
G_ENDCATCH;
|
||
|
}
|
||
|
|
||
|
DataPool::DataPool(void) : DATAPOOL_INIT {}
|
||
|
|
||
|
GP<DataPool>
|
||
|
DataPool::create(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::DataPool()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
DataPool *pool=new DataPool();
|
||
|
|
||
|
GP<DataPool> retval=pool;
|
||
|
pool->init();
|
||
|
|
||
|
// If we maintain the data ourselves, we want to interpret its
|
||
|
// IFF structure to predict its length
|
||
|
pool->add_trigger(0, 32, static_trigger_cb, pool);
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
GP<DataPool>
|
||
|
DataPool::create(const GP<ByteStream> &gstr)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::create: str="<<(ByteStream *)gstr<<"\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
DataPool *pool=new DataPool();
|
||
|
GP<DataPool> retval=pool;
|
||
|
pool->init();
|
||
|
|
||
|
// It's nice to have IFF data analyzed in this case too.
|
||
|
pool->add_trigger(0, 32, static_trigger_cb, pool);
|
||
|
|
||
|
pool->data=gstr->duplicate();
|
||
|
pool->added_data(0,pool->data->size());
|
||
|
// char buffer[1024];
|
||
|
// int length;
|
||
|
// while((length=str.read(buffer, 1024)))
|
||
|
// pool->add_data(buffer, length);
|
||
|
pool->set_eof();
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
GP<DataPool>
|
||
|
DataPool::create(const GP<DataPool> & pool, int start, int length)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::DataPool: pool=" << (void *)((DataPool *)pool) << " start=" << start << " length= " << length << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
DataPool *xpool=new DataPool();
|
||
|
GP<DataPool> retval=xpool;
|
||
|
xpool->init();
|
||
|
xpool->connect(pool, start, length);
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
GP<DataPool>
|
||
|
DataPool::create(const GURL &furl, int start, int length)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::DataPool: furl='" << furl << "' start=" << start << " length= " << length << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
GP<DataPool> retval=FCPools::get()->get_pool(furl,start,length);
|
||
|
if(! retval)
|
||
|
{
|
||
|
DataPool *pool=new DataPool();
|
||
|
retval=pool;
|
||
|
pool->init();
|
||
|
pool->connect(furl, start, length);
|
||
|
}
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::clear_stream(const bool release)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::clear_stream()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
if(fstream)
|
||
|
{
|
||
|
GCriticalSectionLock lock1(&class_stream_lock);
|
||
|
GP<OpenFiles_File> f=fstream;
|
||
|
if(f)
|
||
|
{
|
||
|
GCriticalSectionLock lock2(&(f->stream_lock));
|
||
|
fstream=0;
|
||
|
if(release)
|
||
|
OpenFiles::get()->stream_released(f->stream, this);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DataPool::~DataPool(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::~DataPool()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
clear_stream(true);
|
||
|
if (furl.is_local_file_url())
|
||
|
{
|
||
|
FCPools::get()->del_pool(furl, this);
|
||
|
}
|
||
|
|
||
|
{
|
||
|
// Wait until the static_trigger_cb() exits
|
||
|
GCriticalSectionLock lock(&trigger_lock);
|
||
|
if (pool)
|
||
|
pool->del_trigger(static_trigger_cb, this);
|
||
|
del_trigger(static_trigger_cb, this);
|
||
|
}
|
||
|
|
||
|
if (pool)
|
||
|
{
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Trigger> trigger=triggers_list[pos];
|
||
|
pool->del_trigger(trigger->callback, trigger->cl_data);
|
||
|
}
|
||
|
}
|
||
|
delete block_list;
|
||
|
delete active_readers;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::connect(const GP<DataPool> & pool_in, int start_in, int length_in)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::connect(): connecting to another DataPool\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (pool) G_THROW( ERR_MSG("DataPool.connected1") );
|
||
|
if (furl.is_local_file_url()) G_THROW( ERR_MSG("DataPool.connected2") );
|
||
|
if (start_in<0) G_THROW( ERR_MSG("DataPool.neg_start") );
|
||
|
|
||
|
pool=pool_in;
|
||
|
start=start_in;
|
||
|
length=length_in;
|
||
|
|
||
|
// The following will work for length<0 too
|
||
|
if (pool->has_data(start, length))
|
||
|
eof_flag=true;
|
||
|
else
|
||
|
pool->add_trigger(start, length, static_trigger_cb, this);
|
||
|
|
||
|
data=0;
|
||
|
|
||
|
wake_up_all_readers();
|
||
|
|
||
|
// Pass registered trigger callbacks to the DataPool
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Trigger> t=triggers_list[pos];
|
||
|
int tlength=t->length;
|
||
|
if (tlength<0 && length>0)
|
||
|
tlength=length-t->start;
|
||
|
pool->add_trigger(start+t->start, tlength, t->callback, t->cl_data);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::connect(const GURL &furl_in, int start_in, int length_in)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::connect(): connecting to a file\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (pool)
|
||
|
G_THROW( ERR_MSG("DataPool.connected1") );
|
||
|
if (furl.is_local_file_url())
|
||
|
G_THROW( ERR_MSG("DataPool.connected2") );
|
||
|
if (start_in<0)
|
||
|
G_THROW( ERR_MSG("DataPool.neg_start") );
|
||
|
|
||
|
|
||
|
if (furl_in.name() == "-")
|
||
|
{
|
||
|
DEBUG_MSG("This is stdin => just read the data...\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
char buffer[1024];
|
||
|
int length;
|
||
|
GP<ByteStream> gstr=ByteStream::create(furl_in, "rb");
|
||
|
ByteStream &str=*gstr;
|
||
|
while((length=str.read(buffer, 1024)))
|
||
|
add_data(buffer, length);
|
||
|
set_eof();
|
||
|
} else if(furl_in.is_local_file_url())
|
||
|
{
|
||
|
// Open the stream (just in this function) too see if
|
||
|
// the file is accessible. In future we will be using 'OpenFiles'
|
||
|
// to request and release streams
|
||
|
GP<ByteStream> str=ByteStream::create(furl_in,"rb");
|
||
|
str->seek(0, SEEK_END);
|
||
|
int file_size=str->tell();
|
||
|
|
||
|
furl=furl_in;
|
||
|
start=start_in;
|
||
|
length=length_in;
|
||
|
if (start>=file_size)
|
||
|
length=0;
|
||
|
else if (length<0 || start+length>=file_size)
|
||
|
length=file_size-start;
|
||
|
|
||
|
eof_flag=true;
|
||
|
|
||
|
if(str->is_static())
|
||
|
{
|
||
|
data=str;
|
||
|
added_data(0,length);
|
||
|
}else
|
||
|
{
|
||
|
data=0;
|
||
|
}
|
||
|
|
||
|
FCPools::get()->add_pool(furl, this);
|
||
|
|
||
|
wake_up_all_readers();
|
||
|
|
||
|
// Call every trigger callback
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Trigger> t=triggers_list[pos];
|
||
|
call_callback(t->callback, t->cl_data);
|
||
|
}
|
||
|
triggers_list.empty();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::get_length(void) const
|
||
|
{
|
||
|
// Not connected and length has been guessed
|
||
|
// Or connected to a file
|
||
|
// Or connected to a pool, but length was preset
|
||
|
int retval=(-1);
|
||
|
if (length>=0)
|
||
|
{
|
||
|
retval=length;
|
||
|
}else if (pool)
|
||
|
{
|
||
|
int plength=pool->get_length();
|
||
|
if (plength>=0)
|
||
|
retval=plength-start;
|
||
|
}
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::get_size(int dstart, int dlength) const
|
||
|
{
|
||
|
if (dlength<0 && length>0)
|
||
|
{
|
||
|
dlength=length-dstart;
|
||
|
if (dlength<0) return 0;
|
||
|
}
|
||
|
|
||
|
if (pool) return pool->get_size(start+dstart, dlength);
|
||
|
else if (furl.is_local_file_url())
|
||
|
{
|
||
|
if (start+dstart+dlength>length) return length-(start+dstart);
|
||
|
else return dlength;
|
||
|
} else
|
||
|
{
|
||
|
if (dlength<0)
|
||
|
{
|
||
|
GCriticalSectionLock lock((GCriticalSection *) &data_lock);
|
||
|
dlength=data->size()-dstart;
|
||
|
}
|
||
|
return (dlength<0)?0:(block_list->get_bytes(dstart, dlength));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::add_data(const void * buffer, int size)
|
||
|
// This function adds data sequentially at 'add_at' position
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::add_data(): adding " << size << " bytes of data...\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
add_data(buffer, add_at, size);
|
||
|
add_at+=size;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::add_data(const void * buffer, int offset, int size)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::add_data(): adding " << size << " bytes at pos=" <<
|
||
|
offset << "...\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (furl.is_local_file_url() || pool)
|
||
|
G_THROW( ERR_MSG("DataPool.add_data") );
|
||
|
|
||
|
// Add data to the data storage
|
||
|
{
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
if (offset>data->size())
|
||
|
{
|
||
|
char ch=0;
|
||
|
data->seek(0, SEEK_END);
|
||
|
for(int i=data->size();i<offset;i++)
|
||
|
data->write(&ch, 1);
|
||
|
} else
|
||
|
{
|
||
|
data->seek(offset, SEEK_SET);
|
||
|
data->writall(buffer, size);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
added_data(offset, size);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::added_data(const int offset, const int size)
|
||
|
{
|
||
|
// Modify map of blocks
|
||
|
block_list->add_range(offset, size);
|
||
|
|
||
|
// Wake up all threads, which may be waiting for this data
|
||
|
{
|
||
|
GCriticalSectionLock lock(&readers_lock);
|
||
|
for(GPosition pos=readers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Reader> reader=readers_list[pos];
|
||
|
if (block_list->get_bytes(reader->offset, 1))
|
||
|
{
|
||
|
DEBUG_MSG("waking up reader: offset=" << reader->offset <<
|
||
|
", size=" << reader->size << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
reader->event.set();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// And call triggers
|
||
|
check_triggers();
|
||
|
|
||
|
// Do not undo the following two lines. The reason why we need them
|
||
|
// here is the connected DataPools, which use 'length' (more exactly
|
||
|
// has_data()) to see if they have all data required. So, right after
|
||
|
// all data has been added to the master DataPool, but before EOF
|
||
|
// is set, the master and slave DataPools disagree regarding if
|
||
|
// all data is there or not. These two lines solve the problem
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
if (length>=0 && data->size()>=length)
|
||
|
set_eof();
|
||
|
}
|
||
|
|
||
|
bool
|
||
|
DataPool::has_data(int dstart, int dlength)
|
||
|
{
|
||
|
if (dlength<0 && length>0)
|
||
|
dlength=length-dstart;
|
||
|
return (pool?(pool->has_data(start+dstart, dlength))
|
||
|
:((furl.is_local_file_url())?(start+dstart+dlength<=length)
|
||
|
:((dlength<0)?is_eof()
|
||
|
:(block_list->get_bytes(dstart, dlength)==dlength))));
|
||
|
}
|
||
|
|
||
|
int
|
||
|
DataPool::get_data(void * buffer, int offset, int sz)
|
||
|
{
|
||
|
return get_data(buffer, offset, sz, 0);
|
||
|
}
|
||
|
|
||
|
class DataPool::Incrementor
|
||
|
{
|
||
|
private:
|
||
|
Counter & counter;
|
||
|
public:
|
||
|
Incrementor(Counter & xcounter) : counter(xcounter) {counter.inc();}
|
||
|
~Incrementor() {counter.dec();}
|
||
|
};
|
||
|
|
||
|
int
|
||
|
DataPool::get_data(void * buffer, int offset, int sz, int level)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::get_data()\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
Incrementor inc(*active_readers);
|
||
|
|
||
|
if (stop_flag)
|
||
|
G_THROW( DataPool::Stop );
|
||
|
if (stop_blocked_flag && !is_eof() &&
|
||
|
!has_data(offset, sz))
|
||
|
G_THROW( DataPool::Stop );
|
||
|
|
||
|
if (sz < 0)
|
||
|
G_THROW( ERR_MSG("DataPool.bad_size") );
|
||
|
|
||
|
if (! sz)
|
||
|
return 0;
|
||
|
|
||
|
if (pool)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::get_data(): from pool\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
int retval=0;
|
||
|
if (length>0 && offset+sz>length)
|
||
|
sz=length-offset;
|
||
|
if (sz<0)
|
||
|
sz=0;
|
||
|
for(;;)
|
||
|
{
|
||
|
// Ask the underlying (master) DataPool for data. Note, that
|
||
|
// master DataPool may throw the "DATA_POOL_REENTER" exception
|
||
|
// demanding all readers to restart. This happens when
|
||
|
// a DataPool in the chain of DataPools stops. All readers
|
||
|
// should return to the most upper level and then reenter the
|
||
|
// DataPools hierarchy. Some of them will be stopped by
|
||
|
// DataPool::Stop exception.
|
||
|
G_TRY
|
||
|
{
|
||
|
if(stop_flag||stop_blocked_flag&&!is_eof()&&!has_data(offset, sz))
|
||
|
G_THROW( DataPool::Stop );
|
||
|
retval=pool->get_data(buffer, start+offset, sz, level+1);
|
||
|
}
|
||
|
G_CATCH(exc)
|
||
|
{
|
||
|
pool->clear_stream(true);
|
||
|
if ((exc.get_cause() != GUTF8String( ERR_MSG("DataPool.reenter") ) ) || level)
|
||
|
G_RETHROW;
|
||
|
} G_ENDCATCH;
|
||
|
pool->clear_stream(true);
|
||
|
return retval;
|
||
|
}
|
||
|
}
|
||
|
else if(data && data->is_static() && eof_flag)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::get_data(): static\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
// We're not connected to anybody => handle the data
|
||
|
int size=block_list->get_range(offset, sz);
|
||
|
if (size>0)
|
||
|
{
|
||
|
// Hooray! Some data is there
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
data->seek(offset, SEEK_SET);
|
||
|
return data->readall(buffer, size);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
else if (furl.is_local_file_url())
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::get_data(): from file\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
if (length>0 && offset+sz>length)
|
||
|
sz=length-offset;
|
||
|
if (sz<0)
|
||
|
sz=0;
|
||
|
|
||
|
GP<OpenFiles_File> f=fstream;
|
||
|
if (!f)
|
||
|
{
|
||
|
GCriticalSectionLock lock(&class_stream_lock);
|
||
|
f=fstream;
|
||
|
if(!f)
|
||
|
{
|
||
|
fstream=f=OpenFiles::get()->request_stream(furl, this);
|
||
|
}
|
||
|
}
|
||
|
GCriticalSectionLock lock2(&(f->stream_lock));
|
||
|
f->stream->seek(start+offset, SEEK_SET);
|
||
|
return f->stream->readall(buffer, sz);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::get_data(): direct\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
// We're not connected to anybody => handle the data
|
||
|
int size=block_list->get_range(offset, sz);
|
||
|
if (size>0)
|
||
|
{
|
||
|
// Hooray! Some data is there
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
data->seek(offset, SEEK_SET);
|
||
|
return data->readall(buffer, size);
|
||
|
}
|
||
|
|
||
|
// No data available.
|
||
|
|
||
|
// If there is no data and nothing else is expected, we can do
|
||
|
// two things: throw ByteStream::EndOfFile exception or return ZERO bytes.
|
||
|
// The exception is for the cases when the data flow has been
|
||
|
// terminated in the middle. ZERO bytes is for regular read() beyond
|
||
|
// the boundaries of legal data. The problem is to distinguish
|
||
|
// these two cases. We do it here with the help of analysis of the
|
||
|
// IFF structure of the data (which sets the 'length' variable).
|
||
|
// If we attempt to read beyond the [0, length[, ZERO bytes will be
|
||
|
// returned. Otherwise an ByteStream::EndOfFile exception will be thrown.
|
||
|
if (eof_flag)
|
||
|
{
|
||
|
if (length>0 && offset<length)
|
||
|
{
|
||
|
G_THROW( ByteStream::EndOfFile );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return 0;
|
||
|
}
|
||
|
}
|
||
|
// Some data is still expected => add this reader to the
|
||
|
// list of readers and call virtual wait_for_data()
|
||
|
DEBUG_MSG("DataPool::get_data(): There is no data in the pool.\n");
|
||
|
DEBUG_MSG("offset=" << offset << ", size=" << sz <<
|
||
|
", data_size=" << data->size() << "\n");
|
||
|
GP<Reader> reader=new Reader(offset, sz);
|
||
|
G_TRY
|
||
|
{
|
||
|
{
|
||
|
GCriticalSectionLock slock(&readers_lock);
|
||
|
readers_list.append(reader);
|
||
|
}
|
||
|
wait_for_data(reader);
|
||
|
}
|
||
|
G_CATCH_ALL
|
||
|
{
|
||
|
{
|
||
|
GCriticalSectionLock slock(&readers_lock);
|
||
|
GPosition pos;
|
||
|
if (readers_list.search(reader, pos)) readers_list.del(pos);
|
||
|
}
|
||
|
G_RETHROW;
|
||
|
}
|
||
|
G_ENDCATCH;
|
||
|
|
||
|
{
|
||
|
GCriticalSectionLock slock(&readers_lock);
|
||
|
GPosition pos;
|
||
|
if (readers_list.search(reader, pos)) readers_list.del(pos);
|
||
|
}
|
||
|
|
||
|
// This call to get_data() should return immediately as there MUST
|
||
|
// be data in the buffer after wait_for_data(reader) returns
|
||
|
// or eof_flag should be TRUE
|
||
|
return get_data(buffer, reader->offset, reader->size, level);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::wait_for_data(const GP<Reader> & reader)
|
||
|
// This function may NOT return until there is some data for the
|
||
|
// given reader in the internal buffer
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::wait_for_data(): waiting for data at offset=" << reader->offset <<
|
||
|
", length=" << reader->size << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
#if THREADMODEL==NOTHREADS
|
||
|
G_THROW( ERR_MSG("DataPool.no_threadless") );
|
||
|
#else
|
||
|
for(;;)
|
||
|
{
|
||
|
if (stop_flag)
|
||
|
G_THROW( DataPool::Stop );
|
||
|
if (reader->reenter_flag)
|
||
|
G_THROW( ERR_MSG("DataPool.reenter") );
|
||
|
if (eof_flag || block_list->get_bytes(reader->offset, 1))
|
||
|
return;
|
||
|
if (pool || furl.is_local_file_url())
|
||
|
return;
|
||
|
|
||
|
if (stop_blocked_flag)
|
||
|
G_THROW( DataPool::Stop );
|
||
|
|
||
|
DEBUG_MSG("calling event.wait()...\n");
|
||
|
reader->event.wait();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
DEBUG_MSG("Got some data to read\n");
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::wake_up_all_readers(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::wake_up_all_readers(): waking up all readers\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
GCriticalSectionLock lock(&readers_lock);
|
||
|
for(GPosition pos=readers_list;pos;++pos)
|
||
|
readers_list[pos]->event.set();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::set_eof(void)
|
||
|
// Has no effect on connected DataPools
|
||
|
{
|
||
|
if (!furl.is_local_file_url() && !pool)
|
||
|
{
|
||
|
eof_flag=true;
|
||
|
|
||
|
// Can we set the length now?
|
||
|
if (length<0)
|
||
|
{
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
length=data->size();
|
||
|
}
|
||
|
|
||
|
// Wake up all readers to let them rescan the flags
|
||
|
wake_up_all_readers();
|
||
|
|
||
|
// Activate all trigger callbacks with negative threshold
|
||
|
check_triggers();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::stop(bool only_blocked)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::stop(): Stopping this and dependent DataPools, only_blocked="
|
||
|
<< only_blocked << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (only_blocked) stop_blocked_flag=true;
|
||
|
else stop_flag=true;
|
||
|
|
||
|
|
||
|
wake_up_all_readers();
|
||
|
|
||
|
// Now let all readers, which already go thru to the master DataPool,
|
||
|
// come back and reenter. While reentering some of them will go
|
||
|
// thru this DataPool again and will be stopped (DataPool::Stop exception)
|
||
|
// Others (which entered the master DataPool thru other slave DataPools)
|
||
|
// will simply continue waiting for their data.
|
||
|
if (pool)
|
||
|
{
|
||
|
// This loop is necessary because there may be another thread, which
|
||
|
// is going down thru the DataPool chain and did not reach the
|
||
|
// lowest "master" DataPool yet. Since it didn't reach it yet,
|
||
|
// the "pool->restart_readers()" will not restart it. So we're going
|
||
|
// to continue issuing this command until we get rid of all
|
||
|
// "active_readers"
|
||
|
while(*active_readers)
|
||
|
{
|
||
|
#if (THREADMODEL==COTHREADS) || (THREADMODEL==MACTHREADS)
|
||
|
GThread::yield();
|
||
|
#endif
|
||
|
pool->restart_readers();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::restart_readers(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::restart_readers(): telling all readers to reenter\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
GCriticalSectionLock slock(&readers_lock);
|
||
|
for(GPosition pos=readers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Reader> reader=readers_list[pos];
|
||
|
reader->reenter_flag=true;
|
||
|
reader->event.set();
|
||
|
}
|
||
|
|
||
|
if (pool)
|
||
|
pool->restart_readers();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::load_file(void)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::load_file() called\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (pool)
|
||
|
{
|
||
|
DEBUG_MSG("passing the request down.\n");
|
||
|
pool->load_file();
|
||
|
} else if (furl.is_local_file_url())
|
||
|
{
|
||
|
DEBUG_MSG("loading the data from \""<<(const char *)furl<<"\".\n");
|
||
|
|
||
|
GCriticalSectionLock lock1(&class_stream_lock);
|
||
|
GP<OpenFiles_File> f=fstream;
|
||
|
if (!f)
|
||
|
{
|
||
|
fstream=f=OpenFiles::get()->request_stream(furl, this);
|
||
|
}
|
||
|
{ // Scope to de-allocate lock2 before stream gets released
|
||
|
GCriticalSectionLock lock2(&(f->stream_lock));
|
||
|
|
||
|
data=ByteStream::create();
|
||
|
block_list->clear();
|
||
|
FCPools::get()->del_pool(furl, this);
|
||
|
furl=GURL();
|
||
|
|
||
|
const GP<ByteStream> gbs=f->stream;
|
||
|
gbs->seek(0, SEEK_SET);
|
||
|
data=gbs->duplicate();
|
||
|
added_data(0,data->size());
|
||
|
set_eof();
|
||
|
// char buffer[1024];
|
||
|
// int length;
|
||
|
// while((length=f->stream->read(buffer, 1024)))
|
||
|
// add_data(buffer, length);
|
||
|
// No need to set EOF. It should already be set.
|
||
|
OpenFiles::get()->stream_released(f->stream, this);
|
||
|
}
|
||
|
fstream=0;
|
||
|
} else { DEBUG_MSG("Not connected\n"); }
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::load_file(const GURL &url )
|
||
|
{
|
||
|
FCPools::get()->load_file(url);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::check_triggers(void)
|
||
|
// This function is for not connected DataPools only
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::check_triggers(): calling activated trigger callbacks.\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (!pool && !furl.is_local_file_url())
|
||
|
while(true)
|
||
|
{
|
||
|
GP<Trigger> trigger;
|
||
|
|
||
|
// First find a candidate (trigger, which needs to be called)
|
||
|
// Don't remove it from the list yet. del_trigger() should
|
||
|
// be able to find it if necessary and disable.
|
||
|
{
|
||
|
GCriticalSectionLock list_lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;++pos)
|
||
|
{
|
||
|
GP<Trigger> t=triggers_list[pos];
|
||
|
if (is_eof() || t->length>=0 &&
|
||
|
block_list->get_bytes(t->start, t->length)==t->length)
|
||
|
{
|
||
|
trigger=t;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (trigger)
|
||
|
{
|
||
|
// Now check that the trigger is not disabled
|
||
|
// and lock the trigger->disabled lock for the duration
|
||
|
// of the trigger. This will block the del_trigger() and
|
||
|
// will postpone client's destruction (usually following
|
||
|
// the call to del_trigger())
|
||
|
{
|
||
|
GMonitorLock lock(&trigger->disabled);
|
||
|
if (!trigger->disabled)
|
||
|
call_callback(trigger->callback, trigger->cl_data);
|
||
|
}
|
||
|
|
||
|
// Finally - remove the trigger from the list.
|
||
|
GCriticalSectionLock list_lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;++pos)
|
||
|
if (triggers_list[pos]==trigger)
|
||
|
{
|
||
|
triggers_list.del(pos);
|
||
|
break;
|
||
|
}
|
||
|
} else break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
// DataPool::add_trigger(int thresh, void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data)
|
||
|
DataPool::add_trigger(int thresh, void (* callback)(void *), void * cl_data)
|
||
|
{
|
||
|
if (thresh>=0)
|
||
|
add_trigger(0, thresh+1, callback, cl_data);
|
||
|
else
|
||
|
add_trigger(0, -1, callback, cl_data);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::add_trigger(int tstart, int tlength,
|
||
|
// void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data)
|
||
|
void (* callback)(void *), void * cl_data)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::add_trigger(): start=" << tstart <<
|
||
|
", length=" << tlength << ", func=" << (void *) callback << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (callback)
|
||
|
{
|
||
|
if (is_eof())
|
||
|
{
|
||
|
call_callback(callback, cl_data);
|
||
|
}else
|
||
|
{
|
||
|
if (pool)
|
||
|
{
|
||
|
// We're connected to a DataPool
|
||
|
// Just pass the triggers down remembering it in the list
|
||
|
if (tlength<0 && length>0) tlength=length-tstart;
|
||
|
GP<Trigger> trigger=new Trigger(tstart, tlength, callback, cl_data);
|
||
|
pool->add_trigger(start+tstart, tlength, callback, cl_data);
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
triggers_list.append(trigger);
|
||
|
} else if (!furl.is_local_file_url())
|
||
|
{
|
||
|
// We're not connected to anything and maintain our own data
|
||
|
if (tlength>=0 && block_list->get_bytes(tstart, tlength)==tlength)
|
||
|
call_callback(callback, cl_data);
|
||
|
else
|
||
|
{
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
triggers_list.append(new Trigger(tstart, tlength, callback, cl_data));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
// DataPool::del_trigger(void (* callback)(GP<GPEnabled> &), GP<GPEnabled> cl_data)
|
||
|
DataPool::del_trigger(void (* callback)(void *), void * cl_data)
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::del_trigger(): func=" << (void *) callback << "\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
for(;;)
|
||
|
{
|
||
|
GP<Trigger> trigger;
|
||
|
{
|
||
|
GCriticalSectionLock lock(&triggers_lock);
|
||
|
for(GPosition pos=triggers_list;pos;)
|
||
|
{
|
||
|
GP<Trigger> t=triggers_list[pos];
|
||
|
if (t->callback==callback && t->cl_data==cl_data)
|
||
|
{
|
||
|
trigger=t;
|
||
|
GPosition this_pos=pos;
|
||
|
++pos;
|
||
|
triggers_list.del(this_pos);
|
||
|
break;
|
||
|
} else
|
||
|
++pos;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Above we removed the trigger from the list and unlocked the list
|
||
|
// Now we will disable it and will wait if necessary (if the
|
||
|
// trigger is currently being processed by check_triggers())
|
||
|
// check_triggers() locks the trigger for the duration of the
|
||
|
// trigger callback. Thus we will wait for the trigger callback
|
||
|
// to finish and avoid client's destruction.
|
||
|
if (trigger)
|
||
|
trigger->disabled=1;
|
||
|
else
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (pool)
|
||
|
pool->del_trigger(callback, cl_data);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
// DataPool::static_trigger_cb(GP<GPEnabled> &cl_data)
|
||
|
DataPool::static_trigger_cb(void *cl_data)
|
||
|
{
|
||
|
// GP<DataPool> d=(DataPool *)(GPEnabled *)cl_data;
|
||
|
GP<DataPool> d=(DataPool *)cl_data;
|
||
|
d->trigger_cb();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::trigger_cb(void)
|
||
|
// This function may be triggered by the DataPool, which we're
|
||
|
// connected to, or by ourselves, if we're connected to nothing
|
||
|
{
|
||
|
// Don't want to be destroyed while I'm here. Can't use GP<> life saver
|
||
|
// because it may be called from the constructor
|
||
|
GCriticalSectionLock lock(&trigger_lock);
|
||
|
|
||
|
DEBUG_MSG("DataPool::trigger_cb() called\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
if (pool)
|
||
|
{
|
||
|
// Connected to a pool
|
||
|
// We may be here when either EOF is set on the master DataPool
|
||
|
// Or when it may have learnt its length (from IFF or whatever)
|
||
|
if (pool->is_eof() || pool->has_data(start, length)) eof_flag=true;
|
||
|
} else if (!furl.is_local_file_url())
|
||
|
{
|
||
|
// Not connected to anything => Try to guess the length
|
||
|
if (length<0) analyze_iff();
|
||
|
|
||
|
// Failed to analyze? Check, maybe it's EOF already
|
||
|
if (length<0 && is_eof())
|
||
|
{
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
length=data->size();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::analyze_iff(void)
|
||
|
// In order to display decode progress properly, we need to know
|
||
|
// the size of the data. It's trivial to figure it out if is_eof()
|
||
|
// is true. Otherwise we need to make a prediction. Luckily all
|
||
|
// DjVuFiles have IFF structure, which makes it possible to do it.
|
||
|
// If due to some reason we fail, the length will remain -1.
|
||
|
{
|
||
|
DEBUG_MSG("DataPool::analyze_iff(): Trying to decode IFF structure of " << furl << ".\n");
|
||
|
DEBUG_MSG("in order to predict the DataPool's size\n");
|
||
|
DEBUG_MAKE_INDENT(3);
|
||
|
|
||
|
GP<ByteStream> str=get_stream();
|
||
|
|
||
|
GP<IFFByteStream> giff=IFFByteStream::create(str);
|
||
|
IFFByteStream &iff=*giff;
|
||
|
GUTF8String chkid;
|
||
|
int size;
|
||
|
if ((size=iff.get_chunk(chkid)) && size>=0)
|
||
|
{
|
||
|
length=size+iff.tell()-4;
|
||
|
DEBUG_MSG("Got size=" << size << ", length=" << length << "\n");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//****************************************************************************
|
||
|
//****************************** PoolByteStream ******************************
|
||
|
//****************************************************************************
|
||
|
|
||
|
// This is an internal ByteStream receiving data from the associated DataPool.
|
||
|
// It's just a sequential interface, nothing more. All the job for data
|
||
|
// retrieval, waiting and thread synchronization is done by DataPool
|
||
|
|
||
|
class PoolByteStream : public ByteStream
|
||
|
{
|
||
|
public:
|
||
|
PoolByteStream(GP<DataPool> data_pool);
|
||
|
virtual ~PoolByteStream() {};
|
||
|
|
||
|
virtual size_t read(void *buffer, size_t size);
|
||
|
virtual size_t write(const void *buffer, size_t size);
|
||
|
virtual long tell(void) const ;
|
||
|
virtual int seek(long offset, int whence = SEEK_SET, bool nothrow=false);
|
||
|
private:
|
||
|
// Don't make data_pool GP<>. The problem is that DataPool creates
|
||
|
// and soon destroys this ByteStream from the constructor. Since
|
||
|
// there are no other pointers to the DataPool created yet, it becomes
|
||
|
// destroyed immediately :(
|
||
|
DataPool * data_pool;
|
||
|
GP<DataPool> data_pool_lock;
|
||
|
long position;
|
||
|
|
||
|
char buffer[512];
|
||
|
size_t buffer_size;
|
||
|
size_t buffer_pos;
|
||
|
|
||
|
// Cancel C++ default stuff
|
||
|
PoolByteStream & operator=(const PoolByteStream &);
|
||
|
};
|
||
|
|
||
|
inline
|
||
|
PoolByteStream::PoolByteStream(GP<DataPool> xdata_pool) :
|
||
|
data_pool(xdata_pool), position(0), buffer_size(0), buffer_pos(0)
|
||
|
{
|
||
|
if (!data_pool)
|
||
|
G_THROW( ERR_MSG("DataPool.zero_DataPool") );
|
||
|
|
||
|
// Secure the DataPool if possible. If we're called from DataPool
|
||
|
// constructor (get_count()==0) there is no need to secure at all.
|
||
|
if (data_pool->get_count()) data_pool_lock=data_pool;
|
||
|
}
|
||
|
|
||
|
size_t
|
||
|
PoolByteStream::read(void *data, size_t size)
|
||
|
{
|
||
|
if (buffer_pos >= buffer_size) {
|
||
|
if (size >= sizeof(buffer)) {
|
||
|
// Direct read
|
||
|
size = data_pool->get_data(data, position, size);
|
||
|
position += size;
|
||
|
return size;
|
||
|
} else {
|
||
|
// Refill buffer
|
||
|
buffer_size = data_pool->get_data(buffer, position, sizeof(buffer));
|
||
|
buffer_pos=0;
|
||
|
}
|
||
|
}
|
||
|
if (buffer_pos + size >= buffer_size)
|
||
|
size = buffer_size - buffer_pos;
|
||
|
memcpy(data, buffer+buffer_pos, size);
|
||
|
buffer_pos += size;
|
||
|
position += size;
|
||
|
return size;
|
||
|
}
|
||
|
|
||
|
size_t
|
||
|
PoolByteStream::write(const void *buffer, size_t size)
|
||
|
{
|
||
|
G_THROW( ERR_MSG("not_implemented_n") "\tPoolByteStream::write()"); // PoolByteStream::write() is not implemented.
|
||
|
return 0; // For compiler not to bark
|
||
|
}
|
||
|
|
||
|
long
|
||
|
PoolByteStream::tell(void) const
|
||
|
{
|
||
|
return position;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
PoolByteStream::seek(long offset, int whence, bool nothrow)
|
||
|
{
|
||
|
int retval=(-1);
|
||
|
switch(whence)
|
||
|
{
|
||
|
case SEEK_CUR:
|
||
|
offset+=position;
|
||
|
// fallthrough;
|
||
|
case SEEK_SET:
|
||
|
if(offset<position)
|
||
|
{
|
||
|
if((int)(offset+buffer_pos)>=(int)position)
|
||
|
{
|
||
|
buffer_pos-=position-offset;
|
||
|
}else
|
||
|
{
|
||
|
buffer_size=0;
|
||
|
}
|
||
|
position=offset;
|
||
|
}else if(offset>position)
|
||
|
{
|
||
|
buffer_pos+=(offset-position)-1;
|
||
|
position=offset-1;
|
||
|
unsigned char c;
|
||
|
if(read(&c,1)<1)
|
||
|
{
|
||
|
G_THROW( ByteStream::EndOfFile );
|
||
|
}
|
||
|
}
|
||
|
retval=0;
|
||
|
break;
|
||
|
case SEEK_END:
|
||
|
if(! nothrow)
|
||
|
G_THROW( ERR_MSG("DataPool.seek_backward") );
|
||
|
break;
|
||
|
}
|
||
|
return retval;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
DataPool::close_all(void)
|
||
|
{
|
||
|
OpenFiles::get()->close_all();
|
||
|
}
|
||
|
|
||
|
|
||
|
GP<ByteStream>
|
||
|
DataPool::get_stream(void)
|
||
|
{
|
||
|
if(data && data->is_static())
|
||
|
{
|
||
|
GCriticalSectionLock lock(&data_lock);
|
||
|
data->seek(0, SEEK_SET);
|
||
|
return data->duplicate(length);
|
||
|
}else
|
||
|
{
|
||
|
return new PoolByteStream(this);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
inline
|
||
|
DataPool::Counter::operator int(void) const
|
||
|
{
|
||
|
GCriticalSectionLock lk((GCriticalSection *) &lock);
|
||
|
int cnt=counter;
|
||
|
return cnt;
|
||
|
}
|
||
|
|
||
|
inline void
|
||
|
DataPool::Counter::inc(void)
|
||
|
{
|
||
|
GCriticalSectionLock lk(&lock);
|
||
|
counter++;
|
||
|
}
|
||
|
|
||
|
inline void
|
||
|
DataPool::Counter::dec(void)
|
||
|
{
|
||
|
GCriticalSectionLock lk(&lock);
|
||
|
counter--;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef HAVE_NAMESPACES
|
||
|
}
|
||
|
# ifndef NOT_USING_DJVU_NAMESPACE
|
||
|
using namespace DJVU;
|
||
|
# endif
|
||
|
#endif
|