JBIG2Segment.h

/*
 * Copyright © 2016 Stefan Kebekus <stefan.kebekus@math.uni-freiburg.de>
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef JBIG2SEGMENT
#define JBIG2SEGMENT 1
 
#include <QIODevice>
#include <QVector>
 
 
/* Reads and stores a JBIG2 segment, and interprets the segment header.
    
    This class can be used to read a JBIG2 segment.  It is used internally by
    the JBIG2Document class; users will hardly ever access this class directly.
    The class has minimal support for interpretation of the segment header, and
    for manipulating a few flags there.  In order to support JBIG2 with random
    access organisation, instances of this class are constructed in a three-step
    procedure.
 
    - First, an instance is constructed using the default JBIG2Segment().
    
    - Second, the segment header is read from a QIODevice (usually a QFile),
    using the method readHeader(). If an error occurs at this stage, the
    JBIG2Segment should not be used anymore.
    
    - Third, the segment data is read from a QIODevice, using the method
    readData(). Again, if an error occurs at this stage, the JBIG2Segment
    should not be used anymore.
    
    The instance can then be converted to a QByteArray which contains the full
    segment, or it can be manipulated first.
 
    The methods of this class are reentrant, but not thread-safe.
*/
 
class JBIG2Segment
{
 public:
  JBIG2Segment();
 
  void clear();
  
  QString readHeader(QIODevice *device);
 
  
  inline bool hasHeader() const
  {
    return !_header.isEmpty();
  };
 
  
  QByteArray header() const;
 
  
  QString readData(QIODevice *device);
 
  
  inline bool hasData() const
  {
    return !_data.isNull();
  };
 
  
  QByteArray data() const;
 
  
  inline operator QByteArray() const {return header()+data();};
 
  
  QString info() const;
 
  
  quint8 type() const;
 
  
  bool retainbitForThisSegment() const;
 
  
  void setRetainbitForThisSegment(bool bit=true);
  
  
  quint32 pageAssociation() const;
  
  
  void setPageAssociation();
 
  
  quint32 number() const;
 
  
  QVector<quint32> refersTo() const;
 
 private:
  // QByteArray containing the segment header
  QByteArray _header;
 
  // QByteArray containing the segment data
  QByteArray _data;
 
  // Once the header has been read successfully, this member contains the
  // position of the 'page association' field in the segment header data. This
  // information is used internally to modify the header data.
  qint64 pageAssociationPos{};
 
  // Once the header has been read successfully, this member contains the
  // position of the byte in the segment header data whose least significant bit
  // is the retain bit for this segment. This information is used internally to
  // modify the header data.
  qint64 retainbitForThisSegmentPos{};
 
  
  /* Warning!  The following members duplicate data that is also present in the
     member _header, which represents the segment header data. When modifying
     these members, the segment header data must be modified accordingly,
     otherwise data corruption will like follow.
   */
  
  // Length of segment data, as read from the header data
  quint32 _dataLength{};
 
  // Header flags,
  quint8 _headerFlags{};
 
  // Number of this segment
  quint32 _number{};
 
  // Page association
  quint32 _pageAssociation{};
 
  // Numbers of segments that this segment refers to, in order of appearance in
  // the segment header data.
  QVector<quint32> _referredToSegmentNumbers;
  
  // Convenience method, tells if the page association field in the header data
  // is one byte or four bytes long
  inline bool segmentPageAssociationIs8Bit() const
  {
    return ((_headerFlags & (1 << 6)) == 0);
  };
  
};
 
#endif