Ignore:
Timestamp:
Jan 3, 2010, 7:13:32 PM (11 years ago)
Author:
rbri
Message:

DJVU plugin: djvulibre updated to version 3.5.22

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libdjvu/DjVuFile.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuFile.cpp,v 1.15 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuFile.cpp,v 1.17 2009/05/06 12:57:49 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    498498      GP<DjVuFile> & f=inc_files_list[pos];
    499499      if (f->is_decode_failed())
    500         G_THROW( ERR_MSG("DjVuFile.decode_fail") );
     500        G_THROW( ERR_MSG("DjVuFile.decode_fail") );
    501501      if (f->is_decode_stopped())
    502         G_THROW( DataPool::Stop );
     502        G_THROW( DataPool::Stop );
    503503      if (!f->is_decode_ok())
    504       {
    505         DEBUG_MSG("this_url='" << url << "'\n");
    506         DEBUG_MSG("incl_url='" << f->get_url() << "'\n");
    507         DEBUG_MSG("decoding=" << f->is_decoding() << "\n");
    508         DEBUG_MSG("status='" << f->get_flags() << "\n");
    509         G_THROW( ERR_MSG("DjVuFile.not_finished") );
    510       }
     504        {
     505          DEBUG_MSG("this_url='" << url << "'\n");
     506          DEBUG_MSG("incl_url='" << f->get_url() << "'\n");
     507          DEBUG_MSG("decoding=" << f->is_decoding() << "\n");
     508          DEBUG_MSG("status='" << f->get_flags() << "\n");
     509          G_THROW( ERR_MSG("DjVuFile.not_finished") );
     510        }
    511511    }
    512512  } G_CATCH(exc) {
    513513    G_TRY {
    514514      if (!exc.cmp_cause(DataPool::Stop))
    515       {
    516         flags.enter();
    517         flags=flags & ~DECODING | DECODE_STOPPED;
    518         flags.leave();
    519         pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.stopped"))
    520                               + GUTF8String("\t") + GUTF8String(url));
    521         pcaster->notify_file_flags_changed(this, DECODE_STOPPED, DECODING);
    522       } else
    523       {
    524         flags.enter();
    525         flags=flags & ~DECODING | DECODE_FAILED;
    526         flags.leave();
    527         pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.failed"))
    528                               + GUTF8String("\t") + GUTF8String(url));
    529         pcaster->notify_error(this, exc.get_cause());
    530         pcaster->notify_file_flags_changed(this, DECODE_FAILED, DECODING);
    531       }
     515        {
     516          flags.enter();
     517          flags = (flags & ~DECODING) | DECODE_STOPPED;
     518          flags.leave();
     519          pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.stopped"))
     520                                + GUTF8String("\t") + GUTF8String(url));
     521          pcaster->notify_file_flags_changed(this, DECODE_STOPPED, DECODING);
     522        } else
     523        {
     524          flags.enter();
     525          flags = (flags & ~DECODING) | DECODE_FAILED;
     526          flags.leave();
     527          pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.failed"))
     528                                + GUTF8String("\t") + GUTF8String(url));
     529          pcaster->notify_error(this, exc.get_cause());
     530          pcaster->notify_file_flags_changed(this, DECODE_FAILED, DECODING);
     531        }
    532532    } G_CATCH_ALL
    533     {
    534       DEBUG_MSG("******* Oops. Almost missed an exception\n");
    535     } G_ENDCATCH;
     533        {
     534          DEBUG_MSG("******* Oops. Almost missed an exception\n");
     535        } G_ENDCATCH;
    536536  } G_ENDCATCH;
    537  
     537
    538538  decode_data_pool->clear_stream();
    539539  G_TRY {
     
    609609      // decoder to resolve all chunk dependencies, and
    610610      // abort decoding if necessary.
    611      
    612       // G_EXTHROW(ex); /* commented out */
    613611     
    614612      get_portcaster()->notify_error(this,ex.get_cause());
     
    667665    if(throw_errors)
    668666    {
    669       G_EXTHROW(ex);
     667      G_EMTHROW(ex);
    670668    }else
    671669    {
     
    682680    if(throw_errors)
    683681    {
    684       G_EXTHROW(ex, msg);
     682      G_EMTHROW(GException(msg, ex.get_file(), ex.get_line(),
     683                           ex.get_function() ));
    685684    }else
    686685    {
     
    15881587    ByteStream &str_out=*gstr_out;
    15891588    map[url]=0;
    1590    
     1589
    15911590    // Do the included files first (To make sure that they have
    15921591    // less precedence)
     
    15971596    for(GPosition pos=list;pos;++pos)
    15981597      get_merged_anno(list[pos], gstr_out, ignore_list, level+1, max_level, map);
    1599    
     1598
    16001599    // Now process the DjVuFile's own annotations
    16011600    if (!ignore_list.contains(file->get_url()))
    1602     {
    1603       if (!file->is_data_present() ||
    1604         file->is_modified() && file->anno)
    1605       {
    1606                // Process the decoded (?) anno
    1607         GCriticalSectionLock lock(&file->anno_lock);
    1608         if (file->anno && file->anno->size())
    1609         {
    1610           if (str_out.tell())
    1611           {
    1612             str_out.write((void *) "", 1);
    1613           }
    1614           file->anno->seek(0);
    1615           str_out.copy(*file->anno);
    1616         }
    1617       } else if (file->is_data_present())
    1618       {
    1619                // Copy all annotations chunks, but do NOT modify
    1620                // this->anno (to avoid correlation with DjVuFile::decode())
    1621         const GP<ByteStream> str(file->data_pool->get_stream());
    1622         const GP<IFFByteStream> giff(IFFByteStream::create(str));
    1623         IFFByteStream &iff=*giff;
    1624         GUTF8String chkid;
    1625         if (iff.get_chunk(chkid))
    1626           while(iff.get_chunk(chkid))
    1627           {
    1628             if (chkid=="FORM:ANNO")
    1629             {
    1630               if (max_level<level)
    1631                 max_level=level;
    1632               if (str_out.tell())
    1633               {
    1634                 str_out.write((void *) "", 1);
    1635               }
    1636               str_out.copy(*iff.get_bytestream());
    1637             }
    1638             else if (is_annotation(chkid)) // but not FORM:ANNO
    1639             {
    1640               if (max_level<level)
    1641                 max_level=level;
    1642               if (str_out.tell()&&chkid != "ANTz")
    1643               {
    1644                 str_out.write((void *) "", 1);
    1645               }
    1646               const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1647               IFFByteStream &iff_out=*giff_out;
    1648               iff_out.put_chunk(chkid);
    1649               iff_out.copy(*iff.get_bytestream());
    1650               iff_out.close_chunk();
    1651             }
    1652             iff.close_chunk();
    1653           }
    1654         file->data_pool->clear_stream();
    1655       }
    1656     }
     1601      {
     1602        if (!file->is_data_present() ||
     1603            (file->is_modified() && file->anno))
     1604          {
     1605            // Process the decoded (?) anno
     1606            GCriticalSectionLock lock(&file->anno_lock);
     1607            if (file->anno && file->anno->size())
     1608              {
     1609                if (str_out.tell())
     1610                  {
     1611                    str_out.write((void *) "", 1);
     1612                  }
     1613                file->anno->seek(0);
     1614                str_out.copy(*file->anno);
     1615              }
     1616          } else if (file->is_data_present())
     1617          {
     1618            // Copy all annotations chunks, but do NOT modify
     1619            // this->anno (to avoid correlation with DjVuFile::decode())
     1620            const GP<ByteStream> str(file->data_pool->get_stream());
     1621            const GP<IFFByteStream> giff(IFFByteStream::create(str));
     1622            IFFByteStream &iff=*giff;
     1623            GUTF8String chkid;
     1624            if (iff.get_chunk(chkid))
     1625              while(iff.get_chunk(chkid))
     1626                {
     1627                  if (chkid=="FORM:ANNO")
     1628                    {
     1629                      if (max_level<level)
     1630                        max_level=level;
     1631                      if (str_out.tell())
     1632                        {
     1633                          str_out.write((void *) "", 1);
     1634                        }
     1635                      str_out.copy(*iff.get_bytestream());
     1636                    }
     1637                  else if (is_annotation(chkid)) // but not FORM:ANNO
     1638                    {
     1639                      if (max_level<level)
     1640                        max_level=level;
     1641                      if (str_out.tell()&&chkid != "ANTz")
     1642                        {
     1643                          str_out.write((void *) "", 1);
     1644                        }
     1645                      const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1646                      IFFByteStream &iff_out=*giff_out;
     1647                      iff_out.put_chunk(chkid);
     1648                      iff_out.copy(*iff.get_bytestream());
     1649                      iff_out.close_chunk();
     1650                    }
     1651                  iff.close_chunk();
     1652                }
     1653            file->data_pool->clear_stream();
     1654          }
     1655      }
    16571656  }
    16581657}
     
    17111710  ByteStream &str_out=*gstr_out;
    17121711  if (!file->is_data_present() ||
    1713     file->is_modified() && file->anno)
    1714   {
    1715     // Process the decoded (?) anno
    1716     GCriticalSectionLock lock(&file->anno_lock);
    1717     if (file->anno && file->anno->size())
    1718     {
    1719       if (str_out.tell())
    1720       {
    1721         str_out.write((void *) "", 1);
    1722       }
    1723       file->anno->seek(0);
    1724       str_out.copy(*file->anno);
    1725     }
    1726   } else if (file->is_data_present())
    1727   {
    1728                // Copy all anno chunks, but do NOT modify
    1729                // DjVuFile::anno (to avoid correlation with DjVuFile::decode())
    1730     const GP<ByteStream> str=file->data_pool->get_stream();
    1731     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1732     IFFByteStream &iff=*giff;
    1733     GUTF8String chkid;
    1734     if (iff.get_chunk(chkid))
    1735     {
    1736       while(iff.get_chunk(chkid))
    1737       {
    1738         if (is_annotation(chkid))
    1739         {
    1740           if (str_out.tell())
    1741           {
    1742             str_out.write((void *) "", 1);
    1743           }
    1744           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1745           IFFByteStream &iff_out=*giff_out;
    1746           iff_out.put_chunk(chkid);
    1747           iff_out.copy(*iff.get_bytestream());
    1748           iff_out.close_chunk();
    1749         }
    1750         iff.close_chunk();
    1751       }
    1752     }
    1753     file->data_pool->clear_stream();
    1754   }
     1712      (file->is_modified() && file->anno))
     1713    {
     1714      // Process the decoded (?) anno
     1715      GCriticalSectionLock lock(&file->anno_lock);
     1716      if (file->anno && file->anno->size())
     1717        {
     1718          if (str_out.tell())
     1719            {
     1720              str_out.write((void *) "", 1);
     1721            }
     1722          file->anno->seek(0);
     1723          str_out.copy(*file->anno);
     1724        }
     1725    } else if (file->is_data_present())
     1726    {
     1727      // Copy all anno chunks, but do NOT modify
     1728      // DjVuFile::anno (to avoid correlation with DjVuFile::decode())
     1729      const GP<ByteStream> str=file->data_pool->get_stream();
     1730      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1731      IFFByteStream &iff=*giff;
     1732      GUTF8String chkid;
     1733      if (iff.get_chunk(chkid))
     1734        {
     1735          while(iff.get_chunk(chkid))
     1736            {
     1737              if (is_annotation(chkid))
     1738                {
     1739                  if (str_out.tell())
     1740                    {
     1741                      str_out.write((void *) "", 1);
     1742                    }
     1743                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1744                  IFFByteStream &iff_out=*giff_out;
     1745                  iff_out.put_chunk(chkid);
     1746                  iff_out.copy(*iff.get_bytestream());
     1747                  iff_out.close_chunk();
     1748                }
     1749              iff.close_chunk();
     1750            }
     1751        }
     1752      file->data_pool->clear_stream();
     1753    }
    17551754}
    17561755
     
    17621761  ByteStream &str_out=*gstr_out;
    17631762  if (!file->is_data_present() ||
    1764     file->is_modified() && file->text)
    1765   {
    1766     // Process the decoded (?) text
    1767     GCriticalSectionLock lock(&file->text_lock);
    1768     if (file->text && file->text->size())
    1769     {
    1770       if (str_out.tell())
    1771       {
    1772         str_out.write((void *) "", 1);
    1773       }
    1774       file->text->seek(0);
    1775       str_out.copy(*file->text);
    1776     }
    1777   } else if (file->is_data_present())
    1778   {
    1779                // Copy all text chunks, but do NOT modify
    1780                // DjVuFile::text (to avoid correlation with DjVuFile::decode())
    1781     const GP<ByteStream> str=file->data_pool->get_stream();
    1782     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1783     IFFByteStream &iff=*giff;
    1784     GUTF8String chkid;
    1785     if (iff.get_chunk(chkid))
    1786     {
    1787       while(iff.get_chunk(chkid))
    1788       {
    1789         if (is_text(chkid))
    1790         {
    1791           if (str_out.tell())
    1792           {
    1793             str_out.write((void *) "", 1);
    1794           }
    1795           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1796           IFFByteStream &iff_out=*giff_out;
    1797           iff_out.put_chunk(chkid);
    1798           iff_out.copy(*iff.get_bytestream());
    1799           iff_out.close_chunk();
    1800         }
    1801         iff.close_chunk();
    1802       }
    1803     }
    1804     file->data_pool->clear_stream();
    1805   }
     1763      (file->is_modified() && file->text))
     1764    {
     1765      // Process the decoded (?) text
     1766      GCriticalSectionLock lock(&file->text_lock);
     1767      if (file->text && file->text->size())
     1768        {
     1769          if (str_out.tell())
     1770            {
     1771              str_out.write((void *) "", 1);
     1772            }
     1773          file->text->seek(0);
     1774          str_out.copy(*file->text);
     1775        }
     1776    } else if (file->is_data_present())
     1777    {
     1778      // Copy all text chunks, but do NOT modify
     1779      // DjVuFile::text (to avoid correlation with DjVuFile::decode())
     1780      const GP<ByteStream> str=file->data_pool->get_stream();
     1781      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1782      IFFByteStream &iff=*giff;
     1783      GUTF8String chkid;
     1784      if (iff.get_chunk(chkid))
     1785        {
     1786          while(iff.get_chunk(chkid))
     1787            {
     1788              if (is_text(chkid))
     1789                {
     1790                  if (str_out.tell())
     1791                    {
     1792                      str_out.write((void *) "", 1);
     1793                    }
     1794                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1795                  IFFByteStream &iff_out=*giff_out;
     1796                  iff_out.put_chunk(chkid);
     1797                  iff_out.copy(*iff.get_bytestream());
     1798                  iff_out.close_chunk();
     1799                }
     1800              iff.close_chunk();
     1801            }
     1802        }
     1803      file->data_pool->clear_stream();
     1804    }
    18061805}
    18071806
     
    18131812  ByteStream &str_out=*gstr_out;
    18141813  if (!file->is_data_present() ||
    1815     file->is_modified() && file->meta)
    1816   {
    1817     // Process the decoded (?) meta
    1818     GCriticalSectionLock lock(&file->meta_lock);
    1819     if (file->meta && file->meta->size())
    1820     {
    1821       if (str_out.tell())
    1822       {
    1823         str_out.write((void *) "", 1);
    1824       }
    1825       file->meta->seek(0);
    1826       str_out.copy(*file->meta);
    1827     }
    1828   } else if (file->is_data_present())
    1829   {
    1830                // Copy all meta chunks, but do NOT modify
    1831                // DjVuFile::meta (to avoid correlation with DjVuFile::decode())
    1832     const GP<ByteStream> str=file->data_pool->get_stream();
    1833     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1834     IFFByteStream &iff=*giff;
    1835     GUTF8String chkid;
    1836     if (iff.get_chunk(chkid))
    1837     {
    1838       while(iff.get_chunk(chkid))
    1839       {
    1840         if (is_meta(chkid))
    1841         {
    1842           if (str_out.tell())
    1843           {
    1844             str_out.write((void *) "", 1);
    1845           }
    1846           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1847           IFFByteStream &iff_out=*giff_out;
    1848           iff_out.put_chunk(chkid);
    1849           iff_out.copy(*iff.get_bytestream());
    1850           iff_out.close_chunk();
    1851         }
    1852         iff.close_chunk();
    1853       }
    1854     }
    1855     file->data_pool->clear_stream();
    1856   }
     1814      (file->is_modified() && file->meta))
     1815    {
     1816      // Process the decoded (?) meta
     1817      GCriticalSectionLock lock(&file->meta_lock);
     1818      if (file->meta && file->meta->size())
     1819        {
     1820          if (str_out.tell())
     1821            {
     1822              str_out.write((void *) "", 1);
     1823            }
     1824          file->meta->seek(0);
     1825          str_out.copy(*file->meta);
     1826        }
     1827    } else if (file->is_data_present())
     1828    {
     1829      // Copy all meta chunks, but do NOT modify
     1830      // DjVuFile::meta (to avoid correlation with DjVuFile::decode())
     1831      const GP<ByteStream> str=file->data_pool->get_stream();
     1832      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1833      IFFByteStream &iff=*giff;
     1834      GUTF8String chkid;
     1835      if (iff.get_chunk(chkid))
     1836        {
     1837          while(iff.get_chunk(chkid))
     1838            {
     1839              if (is_meta(chkid))
     1840                {
     1841                  if (str_out.tell())
     1842                    {
     1843                      str_out.write((void *) "", 1);
     1844                    }
     1845                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1846                  IFFByteStream &iff_out=*giff_out;
     1847                  iff_out.put_chunk(chkid);
     1848                  iff_out.copy(*iff.get_bytestream());
     1849                  iff_out.close_chunk();
     1850                }
     1851              iff.close_chunk();
     1852            }
     1853        }
     1854      file->data_pool->clear_stream();
     1855    }
    18571856}
    18581857
Note: See TracChangeset for help on using the changeset viewer.