void
JB2Dict::JB2Codec::Decode::code(const GP<JB2Dict> &gjim)
{
if(!gjim)
{
G_THROW( ERR_MSG("JB2Image.bad_number") );
}
JB2Dict &jim=*gjim;
// -------------------------
// THIS IS THE DECODING PART
// -------------------------
int rectype;
JB2Shape tmpshape;
do {
code_record(rectype, gjim, &tmpshape);
} while(rectype != END_OF_DATA);
if (!gotstartrecordp)
G_THROW( ERR_MSG("JB2Image.no_start") );
// cache bounding boxes
int nshapes = jim.get_shape_count();
int ishapes = jim.get_inherited_shape_count();
jim.boxes.resize(0, nshapes-ishapes-1);
for (int i = ishapes; i < nshapes; i++)
jim.boxes[i-ishapes] = libinfo[i];
// compress
jim.compress();
}
void
GIFFChunk::set_name(GUTF8String name)
{
DEBUG_MSG("GIFFChunk::set_name(): name='" << name << "'\n");
DEBUG_MAKE_INDENT(3);
const int colon=name.search(':');
if(colon>=0)
{
type=name.substr(0,colon);
name=name.substr(colon+1,(unsigned int)-1);
if(name.search(':')>=0)
G_THROW( ERR_MSG("GIFFManager.one_colon") );
}
DEBUG_MSG("auto-setting type to '" << type << "'\n");
if (name.contains(".[]")>=0)
G_THROW( ERR_MSG("GIFFManager.bad_char") );
strncpy(GIFFChunk::name, (const char *)name, 4);
GIFFChunk::name[4]=0;
for(int i=strlen(GIFFChunk::name);i<4;i++)
GIFFChunk::name[i]=' ';
}
void
DjVuText::decode(const GP<ByteStream> &gbs)
{
GUTF8String chkid;
GP<IFFByteStream> giff=IFFByteStream::create(gbs);
IFFByteStream &iff=*giff;
while( iff.get_chunk(chkid) )
{
if (chkid == "TXTa")
{
if (txt)
G_THROW( ERR_MSG("DjVuText.dupl_text") );
txt = DjVuTXT::create();
txt->decode(iff.get_bytestream());
}
else if (chkid == "TXTz")
{
if (txt)
G_THROW( ERR_MSG("DjVuText.dupl_text") );
txt = DjVuTXT::create();
const GP<ByteStream> gbsiff=BSByteStream::create(iff.get_bytestream());
txt->decode(gbsiff);
}
// Add decoding of other chunks here
iff.close_chunk();
}
}
// ticks() --
// -- returns the number of milliseconds elapsed since
// a system dependent date.
unsigned long
GOS::ticks()
{
#if defined(UNIX)
struct timeval tv;
if (gettimeofday(&tv, NULL) < 0)
G_THROW(errmsg());
return (unsigned long)( ((tv.tv_sec & 0xfffff)*1000)
+ (tv.tv_usec/1000) );
#elif defined(WIN32)
DWORD clk = GetTickCount();
return (unsigned long)clk;
#elif defined(OS2)
ULONG clk = 0;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, (PVOID)&clk, sizeof(ULONG));
return clk;
#elif defined(macintosh)
return (unsigned long)((double)TickCount()*16.66);
#else
struct timeval tv;
if (gettimeofday(&tv, NULL) < 0)
G_THROW(errmsg());
return (unsigned long)( ((tv.tv_sec & 0xfffff)*1000)
+ (tv.tv_usec/1000) );
#endif
}
// cwd([dirname])
// -- changes directory to dirname (when specified).
// returns the full path name of the current directory.
GUTF8String
GOS::cwd(const GUTF8String &dirname)
{
#if defined(UNIX) || defined(macintosh) || defined(OS2)
if (dirname.length() && chdir(dirname.getUTF82Native())==-1)//MBCS cvt
G_THROW(errmsg());
char *string_buffer;
GPBuffer<char> gstring_buffer(string_buffer,MAXPATHLEN+1);
char *result = getcwd(string_buffer,MAXPATHLEN);
if (!result)
G_THROW(errmsg());
return GNativeString(result).getNative2UTF8();//MBCS cvt
#elif defined (WIN32)
char drv[2];
if (dirname.length() && _chdir(dirname.getUTF82Native())==-1)//MBCS cvt
G_THROW(errmsg());
drv[0]= dot ; drv[1]=0;
char *string_buffer;
GPBuffer<char> gstring_buffer(string_buffer,MAXPATHLEN+1);
char *result = getcwd(string_buffer,MAXPATHLEN);
GetFullPathName(drv, MAXPATHLEN, string_buffer, &result);
return GNativeString(string_buffer).getNative2UTF8();//MBCS cvt
#else
#error "Define something here for your operating system"
#endif
}
void
MMRDecoder::VLTable::init(const int nbits)
{
// count entries
int ncodes = 0;
while (code[ncodes].codelen)
ncodes++;
// check arguments
if (nbits<=1 || nbits>16)
G_THROW(invalid_mmr_data);
if (ncodes>=256)
G_THROW(invalid_mmr_data);
codewordshift = 32 - nbits;
// allocate table
int size = (1<<nbits);
gindex.resize(size);
gindex.set(ncodes);
// process codes
for (int i=0; i<ncodes; i++) {
const int c = code[i].code;
const int b = code[i].codelen;
if(b<=0 || b>nbits)
{
G_THROW(invalid_mmr_data);
}
// fill table entries whose index high bits are code.
int n = c + (1<<(nbits-b));
while ( --n >= c ) {
if(index[n] != ncodes)
G_THROW( ERR_MSG("MMRDecoder.bad_codebook") );
index[n] = i;
}
}
}
SDL_Surface *load_image( std::string filename )
{
SDL_Surface* loadedImage = NULL;
//The optimized surface that will be used
SDL_Surface* optimizedImage = NULL;
//Load the image
loadedImage = IMG_Load( filename.c_str() );
if(loadedImage == NULL)
G_THROW(filename + " couldn't be loaded");
//If the image loaded
if( loadedImage != NULL )
{
//Create an optimized surface
optimizedImage = SDL_DisplayFormatAlpha( loadedImage );
//assert(optimizedImage);
if(optimizedImage == NULL)
G_THROW("ImageFile " + filename + " couldn't be converted");
//Free the old surface
SDL_FreeSurface( loadedImage );
}
//Return the optimized surface
return optimizedImage;
}
void
DjVuTXT::Zone::decode(const GP<ByteStream> &gbs, int maxtext,
const Zone * parent, const Zone * prev)
{
ByteStream &bs=*gbs;
// Decode type
ztype = (ZoneType) bs.read8();
if ( ztype<PAGE || ztype>CHARACTER )
G_THROW( ERR_MSG("DjVuText.corrupt_text") );
// Decode coordinates
int x=(int) bs.read16()-0x8000;
int y=(int) bs.read16()-0x8000;
int width=(int) bs.read16()-0x8000;
int height=(int) bs.read16()-0x8000;
// Decode text info
text_start = (int) bs.read16()-0x8000;
// int start=text_start;
text_length = bs.read24();
if (prev)
{
if (ztype==PAGE || ztype==PARAGRAPH || ztype==LINE)
{
x=x+prev->rect.xmin;
y=prev->rect.ymin-(y+height);
} else // Either COLUMN or WORD or CHARACTER
{
x=x+prev->rect.xmax;
y=y+prev->rect.ymin;
}
text_start+=prev->text_start+prev->text_length;
} else if (parent)
{
x=x+parent->rect.xmin;
y=parent->rect.ymax-(y+height);
text_start+=parent->text_start;
}
rect=GRect(x, y, width, height);
// Get children size
int size = bs.read24();
// Checks
if (rect.isempty() || text_start<0 || text_start+text_length>maxtext )
G_THROW( ERR_MSG("DjVuText.corrupt_text") );
// Process children
const Zone * prev_child=0;
children.empty();
while (size-- > 0)
{
Zone *z = append_child();
z->decode(gbs, maxtext, this, prev_child);
prev_child=z;
}
}
GUTF8String
DjVuNavDir::page_to_name(int page) const
{
GCriticalSectionLock lk((GCriticalSection *)&lock);
if (page<0)
G_THROW( ERR_MSG("DjVuNavDir.neg_page") );
if (page>=page2name.size())
G_THROW( ERR_MSG("DjVuNavDir.large_page") );
return page2name[page];
}
void
create_masksub_chunks(IFFByteStream &iff, const GURL &url)
{
// Check and load pixmap file
if (!g().stencil)
G_THROW("The use of a raw ppm image requires a stencil");
GP<ByteStream> gibs=ByteStream::create(url, "rb");
ByteStream &ibs=*gibs;
GP<GPixmap> graw_pm=GPixmap::create(ibs);
GPixmap &raw_pm=*graw_pm;
if ((int) g().stencil->get_width() != (int) raw_pm.columns())
G_THROW("Stencil and raw image have different widths!");
if ((int) g().stencil->get_height() != (int) raw_pm.rows())
G_THROW("Stencil and raw image have different heights!");
// Encode foreground
{
GP<GPixmap> gfg_img=GPixmap::create();
GPixmap &fg_img=*gfg_img;
GP<GBitmap> fg_mask=GBitmap::create();
processForeground(&raw_pm, g().stencil, fg_img, *fg_mask);
GP<IW44Image> fg_pm = IW44Image::create_encode(fg_img, fg_mask, IW44Image::CRCBfull);
IWEncoderParms parms[8];
iff.put_chunk("FG44");
parms[0].slices = 100;
fg_pm->encode_chunk(iff.get_bytestream(), parms[0]);
iff.close_chunk();
}
// Encode backgound
{
GP<GPixmap> gbg_img=GPixmap::create();
GPixmap &bg_img=*gbg_img;
GP<GBitmap> bg_mask=GBitmap::create();
processBackground(&raw_pm, g().stencil, bg_img, *bg_mask);
GP<IW44Image> bg_pm = IW44Image::create_encode(bg_img, bg_mask, IW44Image::CRCBnormal);
IWEncoderParms parms[4];
parms[0].bytes = 10000;
parms[0].slices = 74;
iff.put_chunk("BG44");
bg_pm->encode_chunk(iff.get_bytestream(), parms[0]);
iff.close_chunk();
parms[1].slices = 84;
iff.put_chunk("BG44");
bg_pm->encode_chunk(iff.get_bytestream(), parms[1]);
iff.close_chunk();
parms[2].slices = 90;
iff.put_chunk("BG44");
bg_pm->encode_chunk(iff.get_bytestream(), parms[2]);
iff.close_chunk();
parms[3].slices = 97;
iff.put_chunk("BG44");
bg_pm->encode_chunk(iff.get_bytestream(), parms[3]);
iff.close_chunk();
}
}
void
GBitmap::init(ByteStream &ref, int aborder)
{
GMonitorLock lock(monitor());
// Get magic number
char magic[2];
magic[0] = magic[1] = 0;
ref.readall((void*)magic, sizeof(magic));
char lookahead = '\n';
int acolumns = read_integer(lookahead, ref);
int arows = read_integer(lookahead, ref);
init(arows, acolumns, aborder);
// go reading file
if (magic[0]=='P')
{
switch(magic[1])
{
case '1':
grays = 2;
read_pbm_text(ref);
return;
case '2':
grays = 1 + read_integer(lookahead, ref);
if (grays > 256)
G_THROW("Cannot read PGM with depth greater than 8 bits.");
read_pgm_text(ref);
return;
case '4':
grays = 2;
read_pbm_raw(ref);
return;
case '5':
grays = 1 + read_integer(lookahead, ref);
if (grays > 256)
grays = 256;
read_pgm_raw(ref);
return;
}
}
else if (magic[0]=='R')
{
switch(magic[1])
{
case '4':
grays = 2;
read_rle_raw(ref);
return;
}
}
G_THROW( ERR_MSG("GBitmap.bad_format") );
}
void
analyze_jb2_chunk(const GURL &url)
{
if (!g().jb2stencil || !g().jb2stencil->size())
{
GP<ByteStream> gbs=ByteStream::create(url,"rb");
ByteStream &bs=*gbs;
g().jb2stencil = ByteStream::create();
// Check if file is an IFF file
char magic[4];
memset(magic,0,sizeof(magic));
bs.readall(magic,sizeof(magic));
if (!GStringRep::cmp(magic,"AT&T",4))
bs.readall(magic,sizeof(magic));
if (GStringRep::cmp(magic,"FORM",4))
{
// Must be a raw file
bs.seek(0);
g().jb2stencil->copy(bs);
}
else
{
// Search Sjbz chunk
bs.seek(0);
GUTF8String chkid;
GP<IFFByteStream> giff=IFFByteStream::create(gbs);
IFFByteStream &iff=*giff;
if (iff.get_chunk(chkid)==0 || chkid!="FORM:DJVU")
G_THROW("Expecting a DjVu file!");
for(; iff.get_chunk(chkid); iff.close_chunk())
if (chkid=="Sjbz") { g().jb2stencil->copy(bs); break; }
}
// Check result
g().jb2stencil->seek(0);
if (!g().jb2stencil->size())
G_THROW("Could not find JB2 data");
// Decode
g().stencil=JB2Image::create();
g().stencil->decode(g().jb2stencil,&provide_shared_dict,NULL);
int jw = g().stencil->get_width();
int jh = g().stencil->get_height();
if (w < 0)
w = jw;
if (h < 0)
h = jh;
if (blit_count < 0)
blit_count = g().stencil->get_blit_count();
if (jw!=w || jh!=h)
DjVuPrintErrorUTF8("djvumake: mask size (%s) does not match info size\n", (const char *)url);
}
}
GP<DjVuFile>
lt_XMLParser::Impl::get_file(const GURL &url,GUTF8String id)
{
GP<DjVuFile> dfile;
GP<DjVuDocument> doc;
GCriticalSectionLock lock(&xmlparser_lock);
{
GPosition pos=m_docs.contains(url.get_string());
if(pos)
{
doc=m_docs[pos];
}else
{
doc=DjVuDocument::create_wait(url);
if(! doc->wait_for_complete_init())
{
G_THROW(( ERR_MSG("XMLAnno.fail_init") "\t")+url.get_string() );
}
m_docs[url.get_string()]=doc;
}
if(id.is_int())
{
const int xpage=id.toInt(); //atoi((char const *)page);
if(xpage>0)
id=doc->page_to_id(xpage-1);
}else if(!id.length())
{
id=doc->page_to_id(0);
}
}
const GURL fileurl(doc->id_to_url(id));
GPosition dpos(m_files.contains(fileurl.get_string()));
if(!dpos)
{
if(!doc->get_id_list().contains(id))
{
G_THROW( ERR_MSG("XMLAnno.bad_page") );
}
dfile=doc->get_djvu_file(id,false);
if(!dfile)
{
G_THROW( ERR_MSG("XMLAnno.bad_page") );
}
m_files[fileurl.get_string()]=dfile;
}else
{
dfile=m_files[dpos];
}
return dfile;
}
void
DjVuPalette::decode(GP<ByteStream> gbs)
{
ByteStream &bs=*gbs;
// Make sure that everything is clear
delete hist;
delete pmap;
hist = 0;
pmap = 0;
mask = 0;
// Code version
int version = bs.read8();
if ( (version & 0x7f) != DJVUPALETTEVERSION)
G_THROW( ERR_MSG("DjVuPalette.bad_version") );
// Code palette
const int palettesize = bs.read16();
if (palettesize<0 || palettesize>MAXPALETTESIZE)
G_THROW( ERR_MSG("DjVuPalette.bad_palette") );
palette.resize(0,palettesize-1);
{ // extra nesting for windows
for (int c=0; c<palettesize; c++)
{
unsigned char p[3];
bs.readall((void*)p, 3);
palette[c].p[0] = p[0];
palette[c].p[1] = p[1];
palette[c].p[2] = p[2];
palette[c].p[3] = (p[0]*BMUL+p[1]*GMUL+p[2]*RMUL)/SMUL;
}
}
// Code data
if (version & 0x80)
{
int datasize = bs.read24();
if (datasize<0)
G_THROW( ERR_MSG("DjVuPalette.bad_palette") );
colordata.resize(0,datasize-1);
GP<ByteStream> gbsb=BSByteStream::create(gbs);
ByteStream &bsb=*gbsb;
{ // extra nesting for windows
for (int d=0; d<datasize; d++)
{
short s = bsb.read16();
if (s<0 || s>=palettesize)
G_THROW( ERR_MSG("DjVuPalette.bad_palette") );
colordata[d] = s;
}
}
}
}
void
GIFFManager::del_chunk(GUTF8String name)
// "name" should be fully qualified, that is contain dots.
// It may also end with [] to set the chunk order number
{
DEBUG_MSG("GIFFManager::del_chunk(): Deleting chunk '" << name << "'\n");
DEBUG_MAKE_INDENT(3);
if (!name.length())
G_THROW( ERR_MSG("GIFFManager.del_empty") );
if (name[0]=='.')
{
const int next_dot=name.search('.',1);
if (next_dot < 0)
{
if (top_level->check_name(name.substr(1,(unsigned int)-1)))
{
DEBUG_MSG("Removing top level chunk..\n");
top_level=GIFFChunk::create();
return;
}
G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+name.substr(1,(unsigned int)-1));
}
const GUTF8String top_name=name.substr(1,next_dot-1);
if (!top_level->check_name(top_name))
G_THROW( ERR_MSG("GIFFManager.wrong_name2") "\t"+top_name);
name=name.substr(next_dot+1,(unsigned int)-1);
}
GP<GIFFChunk> cur_sec=top_level;
const char * start, * end=(const char *)name-1;
do
{
for(start=++end;*end&&(*end!='.');end++)
EMPTY_LOOP;
if (end>start && *end=='.')
cur_sec=cur_sec->get_chunk(GUTF8String(start, end-start));
if (!cur_sec)
G_THROW( ERR_MSG("GIFFManager.cant_find") "\t"+GUTF8String(name));
} while(*end);
if (!start[0])
{
G_THROW(GUTF8String( ERR_MSG("GIFFManager.malformed") "\t")+name);
}
cur_sec->del_chunk(start);
}
bool
MMRDecoder::decode_header(
ByteStream &inp, int &width, int &height, int &invert)
{
unsigned long int magic = inp.read32();
if((magic&0xfffffffc) != 0x4d4d5200)
G_THROW( ERR_MSG("MMRDecoder.unrecog_header") );
invert = ((magic & 0x1) ? 1 : 0);
const bool strip = ((magic & 0x2) ? 1 : 0);
width = inp.read16();
height = inp.read16();
if (width<=0 || height<=0)
G_THROW( ERR_MSG("MMRDecoder.bad_header") );
return strip;
}
void
JB2Dict::set_inherited_dict(const GP<JB2Dict> &dict)
{
if (shapes.size() > 0)
G_THROW( ERR_MSG("JB2Image.cant_set") );
if (inherited_dict)
G_THROW( ERR_MSG("JB2Image.cant_change") );
inherited_dict = dict;
inherited_shapes = dict->get_shape_count();
// Make sure that inherited bitmaps are marked as shared
for (int i=0; i<inherited_shapes; i++)
{
JB2Shape &jshp = dict->get_shape(i);
if (jshp.bits) jshp.bits->share();
}
}
void
GBitmap::init(int arows, int acolumns, int aborder)
{
size_t np = arows * (acolumns + aborder) + aborder;
if (arows != (unsigned short) arows ||
acolumns != (unsigned short) acolumns ||
acolumns + aborder != (unsigned short)(acolumns + aborder) ||
(arows > 0 && (np-aborder)/(size_t)arows!=(size_t)(acolumns+aborder)) )
G_THROW("GBitmap: image size exceeds maximum (corrupted file?)");
GMonitorLock lock(monitor());
destroy();
grays = 2;
nrows = arows;
ncolumns = acolumns;
border = aborder;
bytes_per_row = ncolumns + border;
int npixels = nrows * bytes_per_row + border;
gzerobuffer=zeroes(bytes_per_row + border);
if (npixels > 0)
{
gbytes_data.resize(npixels);
gbytes_data.clear();
bytes = bytes_data;
}
}
void
GMonitor::wait(unsigned long timeout)
{
// Check
pthread_t self = pthread_self();
if (count>0 || !pthread_equal(locker, self))
G_THROW( ERR_MSG("GThreads.not_acq_wait") );
// Wait
if (ok)
{
// Release
int sav_count = count;
count = 1;
// Wait
struct timeval abstv;
struct timespec absts;
gettimeofday(&abstv, NULL); // grrr
absts.tv_sec = abstv.tv_sec + timeout/1000;
absts.tv_nsec = abstv.tv_usec*1000 + (timeout%1000)*1000000;
if (absts.tv_nsec > 1000000000) {
absts.tv_nsec -= 1000000000;
absts.tv_sec += 1;
}
pthread_cond_timedwait(&cond, &mutex, &absts);
// Re-acquire
count = sav_count;
locker = self;
}
}
void
GIFFChunk::del_chunk(const GUTF8String &name)
// The name may contain brackets to specify the chunk number
{
DEBUG_MSG("GIFFChunk::del_chunk(): Deleting chunk '" << name <<
"' from '" << get_name() << "'\n");
DEBUG_MAKE_INDENT(3);
int number;
const GUTF8String short_name=decode_name(name,number);
GPosition pos=chunks;
for(int num=0;pos;++pos)
{
if ((chunks[pos]->get_name()==short_name)&&(num++ == number))
{
chunks.del(pos);
break;
}
}
if(! pos)
{
G_THROW( ERR_MSG("GIFFManager.no_chunk") "\t"+short_name+"\t"+GUTF8String(number)+"\t"+get_name());
}
}
void
lt_XMLParser::Impl::parse_anno(
const int width,
const int height,
const lt_XMLTags &GObject,
GMap<GUTF8String,GP<lt_XMLTags> > &Maps,
DjVuFile &dfile )
{
GP<lt_XMLTags> map;
{
GPosition usemappos=GObject.get_args().contains("usemap");
if(usemappos)
{
const GUTF8String mapname(GObject.get_args()[usemappos]);
GPosition mappos=Maps.contains(mapname);
if(!mappos)
{
G_THROW((ERR_MSG("XMLAnno.map_find") "\t")+mapname );
}else
{
map=Maps[mappos];
}
}
}
if(map)
{
ChangeAnno(width,height,dfile,*map);
}
}
void
JB2Dict::JB2Codec::Encode::encode_libonly_shape(
const GP<JB2Image> &gjim, int shapeno )
{
if(!gjim)
{
G_THROW( ERR_MSG("JB2Image.bad_number") );
}
JB2Image &jim=*gjim;
// Recursively encode parent shape
JB2Shape &jshp = jim.get_shape(shapeno);
if (jshp.parent>=0 && shape2lib[jshp.parent]<0)
encode_libonly_shape(gjim, jshp.parent);
// Test that library shape must be encoded
if (shape2lib[shapeno] < 0)
{
// Code library entry
int rectype=(jshp.parent >= 0)
?NEW_MARK_LIBRARY_ONLY:MATCHED_REFINE_LIBRARY_ONLY;
code_record(rectype, gjim, &jshp, 0);
// Add shape to library
add_library(shapeno, jshp);
// Check numcoder status
if (cur_ncell > CELLCHUNK)
{
rectype = REQUIRED_DICT_OR_RESET;
code_record(rectype, 0, 0);
}
}
}
void
JB2Dict::JB2Codec::Encode::CodeNum(int num, int low, int high, NumContext &ctx)
{
if (num < low || num > high)
G_THROW( ERR_MSG("JB2Image.bad_number") );
JB2Codec::CodeNum(low,high,&ctx,num);
}
int
DjVuPalette::color_to_index_slow(const unsigned char *bgr)
{
PColor *pal = palette;
const int ncolors = palette.size();
if (! ncolors)
G_THROW( ERR_MSG("DjVuPalette.not_init") );
// Should be able to do better
int found = 0;
int founddist = 3*256*256;
{ // extra nesting for windows
for (int i=0; i<ncolors; i++)
{
int bd = bgr[0] - pal[i].p[0];
int gd = bgr[1] - pal[i].p[1];
int rd = bgr[2] - pal[i].p[2];
int dist = (bd*bd)+(gd*gd)+(rd*rd);
if (dist < founddist)
{
found = i;
founddist = dist;
}
}
}
// Store in pmap
if (pmap && pmap->size()<0x8000)
{
int key = (bgr[0]<<16)|(bgr[1]<<8)|(bgr[2]);
(*pmap)[key] = found;
}
// Return
return found;
}
// This function constructs message names for external lookup.
// The message names are constructed to avoid the problems of concatenating
// phrases (which does not translate well into other languages). The
// message names that can be generated are (listed here to appease the
// auditing program which reads comments):
// ERR_MSG("DjVuAnno.invalid2number"), ERR_MSG("DjVuAnno.string2number"),
// ERR_MSG("DjVuAnno.symbol2number"), ERR_MSG("DjVuAnno.list2number")
// ERR_MSG("DjVuAnno.invalid2string"), ERR_MSG("DjVuAnno.number2string"),
// ERR_MSG("DjVuAnno.symbol2string"), ERR_MSG("DjVuAnno.list2string")
// ERR_MSG("DjVuAnno.invalid2symbol"), ERR_MSG("DjVuAnno.number2symbol"),
// ERR_MSG("DjVuAnno.string2symbol"), ERR_MSG("DjVuAnno.list2symbol")
// ERR_MSG("DjVuAnno.invalid2list"), ERR_MSG("DjVuAnno.number2list"),
// ERR_MSG("DjVuAnno.string2list"), ERR_MSG("DjVuAnno.symbol2list")
void
GLObject::throw_can_not_convert_to(const GLObjectType to) const
{
static const GUTF8String two('2');
static const GUTF8String tab('\t');
GUTF8String mesg("DjVuAnno.");
switch(type)
{
case NUMBER:
mesg+=GLObjectString[NUMBER]+two+GLObjectString[to]+tab+GUTF8String(number);
break;
case STRING:
mesg+=GLObjectString[STRING]+two+GLObjectString[to]+tab+string;
break;
case SYMBOL:
mesg+=GLObjectString[SYMBOL]+two+GLObjectString[to]+tab+symbol;
break;
case LIST:
mesg+=GLObjectString[LIST]+two+GLObjectString[to]+tab+name;
break;
default:
mesg+=GLObjectString[INVALID]+two+GLObjectString[to];
break;
}
G_THROW(mesg);
}
void
GLParser::skip_white_space(const char * & start)
{
while(*start && isspace(*start)) start++;
if (!*start)
G_THROW( ByteStream::EndOfFile );
}
void
create_fgbz_chunk(IFFByteStream &iff)
{
int nzones = g().colorzones.size();
int npalette = g().colorpalette->size() / 3;
GP<DjVuPalette> pal = DjVuPalette::create();
g().colorpalette->seek(0);
pal->decode_rgb_entries(*g().colorpalette, npalette);
pal->colordata.resize(0,blit_count-1);
for (int d=0; d<blit_count; d++)
{
JB2Blit *blit = g().stencil->get_blit(d);
const JB2Shape &shape = g().stencil->get_shape(blit->shapeno);
GRect brect(blit->left, blit->bottom, shape.bits->columns(), shape.bits->rows());
int index = nzones;
for (int i=0; i<nzones; i++)
{
GRect zrect = g().colorzones[i];
if (zrect.isempty() || zrect.intersect(brect, zrect))
index = i;
}
if (index >= npalette)
G_THROW("create_fgbz_chunk: internal error");
pal->colordata[d] = index;
}
iff.put_chunk("FGbz");
pal->encode(iff.get_bytestream());
iff.close_chunk();
}
void
GMonitor::wait(unsigned long timeout)
{
// Check state
DWORD self = GetCurrentThreadId();
if (count>0 || self!=locker)
G_THROW( ERR_MSG("GThreads.not_acq_wait") );
// Wait
if (ok)
{
// Prepare wait record
struct thr_waiting waitrec;
waitrec.waiting = TRUE;
waitrec.gwait = CreateEvent(NULL,FALSE,FALSE,NULL);
waitrec.next = 0;
waitrec.prev = tail;
// Link wait record (protected by critical section)
*(waitrec.prev ? &waitrec.prev->next : &head) = &waitrec;
*(waitrec.next ? &waitrec.next->prev : &tail) = &waitrec;
// Start wait
int sav_count = count;
count = 1;
LeaveCriticalSection(&cs);
WaitForSingleObject(waitrec.gwait,timeout);
// Re-acquire
EnterCriticalSection(&cs);
count = sav_count;
locker = self;
// Unlink wait record
*(waitrec.next ? &waitrec.next->prev : &tail) = waitrec.prev;
*(waitrec.prev ? &waitrec.prev->next : &head) = waitrec.next;
CloseHandle(waitrec.gwait);
}
}
inline
GRectMapper::GRatio::GRatio(int p, int q)
: p(p), q(q)
{
if (q == 0)
G_THROW( ERR_MSG("GRect.div_zero") );
if (p == 0)
q = 1;
if (q < 0)
{
p = -p;
q = -q;
}
int gcd = 1;
int g1 = p;
int g2 = q;
if (g1 > g2)
{
gcd = g1;
g1 = g2;
g2 = gcd;
}
while (g1 > 0)
{
gcd = g1;
g1 = g2 % g1;
g2 = gcd;
}
p /= gcd;
q /= gcd;
}
void
GPEnabled::destroy()
{
if (count >= 0)
G_THROW( ERR_MSG("GSmartPointer.suspicious") );
delete this;
}
