Esempio n. 1
0
 public static String decompress(byte[] data) {
   int length = ByteBuffer.wrap(Arrays.copyOfRange(data, 0, 4)).getInt();
   if (length > 100000) {
     // This is a sanity check. More than 100kb of password settings make no sense.
     System.out.println("Decompression error: The trasferred length is too big.");
     return "";
   }
   Inflater inflater = new Inflater();
   inflater.setInput(data, 4, data.length - 4);
   byte[] decompressedBytes = new byte[length];
   try {
     if (inflater.inflate(decompressedBytes) != length) {
       throw new AssertionError();
     }
   } catch (DataFormatException e) {
     e.printStackTrace();
   }
   inflater.end();
   try {
     return new String(decompressedBytes, "UTF-8");
   } catch (UnsupportedEncodingException e) {
     System.out.println(
         "Decompression error: UTF-8 is not supported. " + "Using default encoding.");
     return new String(decompressedBytes);
   }
 }
  /* (non-Javadoc)
   * @see org.eclipse.jetty.websocket.AbstractExtension#onFrame(byte, byte, org.eclipse.jetty.io.Buffer)
   */
  @Override
  public void onFrame(byte flags, byte opcode, Buffer buffer) {
    if (getConnection().isControl(opcode) || !isFlag(flags, 1)) {
      super.onFrame(flags, opcode, buffer);
      return;
    }

    if (buffer.array() == null) buffer = buffer.asMutableBuffer();

    int length = 0xff & buffer.get();
    if (length >= 0x7e) {
      int b = (length == 0x7f) ? 8 : 2;
      length = 0;
      while (b-- > 0) length = 0x100 * length + (0xff & buffer.get());
    }

    // TODO check a max framesize

    _inflater.setInput(buffer.array(), buffer.getIndex(), buffer.length());
    ByteArrayBuffer buf = new ByteArrayBuffer(length);
    try {
      while (_inflater.getRemaining() > 0) {
        int inflated = _inflater.inflate(buf.array(), buf.putIndex(), buf.space());
        if (inflated == 0) throw new DataFormatException("insufficient data");
        buf.setPutIndex(buf.putIndex() + inflated);
      }

      super.onFrame(clearFlag(flags, 1), opcode, buf);
    } catch (DataFormatException e) {
      LOG.warn(e);
      getConnection().close(WebSocketConnectionRFC6455.CLOSE_BAD_PAYLOAD, e.toString());
    }
  }
 /** Start the thread. Exits when the client has been completely handled. */
 @Override
 public void run() {
   try {
     GELFClientHandlerIF client = null;
     if (GELF.isChunkedMessage(this.receivedGelfSentence)) {
       LOG.info("Received message is chunked. Handling now.");
       client = new ChunkedGELFClientHandler(this.receivedGelfSentence);
     } else {
       LOG.info("Received message is not chunked. Handling now.");
       client = new SimpleGELFClientHandler(this.receivedGelfSentence);
     }
     client.handle();
   } catch (InvalidGELFTypeException e) {
     LOG.error("Invalid GELF type in message: " + e.getMessage(), e);
   } catch (InvalidGELFHeaderException e) {
     LOG.error("Invalid GELF header in message: " + e.getMessage(), e);
   } catch (InvalidGELFCompressionMethodException e) {
     LOG.error("Invalid compression method of GELF message: " + e.getMessage(), e);
   } catch (java.util.zip.DataFormatException e) {
     LOG.error("Invalid compression data format in GELF message: " + e.getMessage(), e);
   } catch (java.io.UnsupportedEncodingException e) {
     LOG.error("Invalid enconding of GELF message: " + e.getMessage(), e);
   } catch (java.io.EOFException e) {
     LOG.error("EOF Exception while handling GELF message: " + e.getMessage(), e);
   } catch (java.net.SocketException e) {
     LOG.error("SocketException while handling GELF message: " + e.getMessage(), e);
   } catch (java.io.IOException e) {
     LOG.error("IO Error while handling GELF message: " + e.getMessage(), e);
   } catch (Exception e) {
     LOG.error("Exception caught while handling GELF message: " + e.getMessage(), e);
   }
 }
 /**
  * Reads uncompressed data into an array of bytes. If <code>len</code> is not zero, the method
  * will block until some input can be decompressed; otherwise, no bytes are read and <code>0
  * </code> is returned.
  *
  * @param b the buffer into which the data is read
  * @param off the start offset in the destination array <code>b</code>
  * @param len the maximum number of bytes read
  * @return the actual number of bytes read, or -1 if the end of the compressed input is reached or
  *     a preset dictionary is needed
  * @exception NullPointerException If <code>b</code> is <code>null</code>.
  * @exception IndexOutOfBoundsException If <code>off</code> is negative, <code>len</code> is
  *     negative, or <code>len</code> is greater than <code>b.length - off</code>
  * @exception ZipException if a ZIP format error has occurred
  * @exception IOException if an I/O error has occurred
  */
 public int read(byte[] b, int off, int len) throws IOException {
   ensureOpen();
   if (b == null) {
     throw new NullPointerException();
   } else if (off < 0 || len < 0 || len > b.length - off) {
     throw new IndexOutOfBoundsException();
   } else if (len == 0) {
     return 0;
   }
   try {
     int n;
     while ((n = inf.inflate(b, off, len)) == 0) {
       if (inf.finished() || inf.needsDictionary()) {
         reachEOF = true;
         return -1;
       }
       if (inf.needsInput()) {
         fill();
       }
     }
     return n;
   } catch (DataFormatException e) {
     String s = e.getMessage();
     throw new ZipException(s != null ? s : "Invalid ZLIB data format");
   }
 }
 public synchronized int decompress(byte[] b, int off, int len) throws IOException {
   try {
     return super.inflate(b, off, len);
   } catch (DataFormatException dfe) {
     throw new IOException(dfe.getMessage());
   }
 }
 private int inflate(byte[] bytes) throws ZipException {
   try {
     return inflater.inflate(bytes);
   } catch (DataFormatException x) {
     throw new ZipException(x.getMessage());
   }
 }
Esempio n. 7
0
  private final byte[] uncompress(final byte[] input) throws IOException {

    Inflater decompressor = new Inflater();
    decompressor.setInput(input);

    // Create an expandable byte array to hold the decompressed data
    ByteArrayOutputStream bos = new ByteArrayOutputStream(input.length);

    // Decompress the data
    byte[] buf = new byte[1024];
    while (!decompressor.finished()) {
      try {
        int count = decompressor.inflate(buf);
        bos.write(buf, 0, count);
      } catch (DataFormatException e) {
        // this will happen if the field is not compressed
        IOException newException =
            new IOException("field data are in wrong format: " + e.toString());
        newException.initCause(e);
        throw newException;
      }
    }

    decompressor.end();

    // Get the decompressed data
    return bos.toByteArray();
  }
Esempio n. 8
0
 /** TIFF Adobe ZIP support contributed by Jason Newton. */
 public byte[] zipUncompress(byte[] input) {
   ByteArrayOutputStream imageBuffer = new ByteArrayOutputStream();
   byte[] buffer = new byte[1024];
   Inflater decompressor = new Inflater();
   decompressor.setInput(input);
   try {
     while (!decompressor.finished()) {
       int rlen = decompressor.inflate(buffer);
       imageBuffer.write(buffer, 0, rlen);
     }
   } catch (DataFormatException e) {
     IJ.log(e.toString());
   }
   decompressor.end();
   return imageBuffer.toByteArray();
 }
Esempio n. 9
0
  /**
   * Reads from the compressed stream and stores the resulting uncompressed data into the byte
   * array.
   *
   * @return number of bytes read, or -1 upon EOF
   */
  public int read(byte[] b, int off, int len) throws IOException {
    if (len <= 0 || off < 0 || off + len > b.length) return 0;

    if (_eof) return -1;

    // Read from uncompressed stream
    if (!_isGzip) return _in.read(b, off, len);

    try {
      int sublen;
      int length = 0;
      while (length < len) {
        if (_inflater.needsInput()) {
          _readBufferSize = _in.read(_readBuffer, 0, _readBuffer.length);
          if (_readBufferSize < 0) break;

          _inflater.setInput(_readBuffer, 0, _readBufferSize);
        }

        sublen = _inflater.inflate(b, off + length, len - length);

        _crc.update(b, off + length, sublen);
        _inputSize += sublen;
        _totalInputSize += sublen;

        length += sublen;

        // Unread gzip trailer and possibly beginning of appended gzip data.
        if (_inflater.finished()) {
          int remaining = _inflater.getRemaining();
          _in.unread(_readBuffer, _readBufferSize - remaining, remaining);

          readTrailer();

          int secondPart = read(b, off + length, len - length);

          return secondPart > 0 ? length + secondPart : length;
        }
      }

      return length;
    } catch (DataFormatException e) {
      throw new IOException(e.getMessage());
    }
  }
 /** Parse out and decompress the data part of a fileblock helper function. */
 FileBlock parseData(byte buf[]) throws InvalidProtocolBufferException {
   FileBlock out = FileBlock.newInstance(type, indexdata);
   Fileformat.Blob blob = Fileformat.Blob.parseFrom(buf);
   if (blob.hasRaw()) {
     out.data = blob.getRaw();
   } else if (blob.hasZlibData()) {
     byte buf2[] = new byte[blob.getRawSize()];
     Inflater decompresser = new Inflater();
     decompresser.setInput(blob.getZlibData().toByteArray());
     // decompresser.getRemaining();
     try {
       decompresser.inflate(buf2);
     } catch (DataFormatException e) {
       e.printStackTrace();
       throw new Error(e);
     }
     assert (decompresser.finished());
     decompresser.end();
     out.data = ByteString.copyFrom(buf2);
   }
   return out;
 }
Esempio n. 11
0
  public int read() throws IOException {
    if (pointer == -1) {
      try {
        length = doRead(readBuffer, 0, readBuffer.length);
        if (length == 0) {
          return -1;
        }
        pointer = 0;
      } catch (DataFormatException e) {
        IOException e2 = new IOException(e.getMessage());
        e2.initCause(e);
        throw e2;
      }
    }

    int value = readBuffer[pointer] & 0xFF;
    pointer++;
    if (pointer == length) {
      pointer = -1;
    }

    return value;
  }
Esempio n. 12
0
  public String processCreate() {

    try {
      if (!this.checkAccess()) {
        throw new PermissionException(
            SessionManager.getCurrentSessionUserId(), "syllabus_access_athz", "");
      }

    } catch (PermissionException e) {
      // logger.info(this + ".getEntries() in PostemTool " + e);
      FacesContext.getCurrentInstance()
          .addMessage(
              null,
              MessageUtils.getMessage(
                  FacesMessage.SEVERITY_ERROR,
                  "error_permission",
                  (new Object[] {e.toString()}),
                  FacesContext.getCurrentInstance()));
      this.currentGradebook = null;
      this.csv = null;
      this.newTemplate = null;
      // this.release = null;
      return "permission_error";
    }
    if (currentGradebook.getId() == null) {
      ArrayList gb = getGradebooks();
      Iterator gi = gb.iterator();
      while (gi.hasNext()) {
        if (((Gradebook) gi.next()).getTitle().equals(currentGradebook.getTitle())) {
          // To stay consistent, remove current messages when adding a new message
          // so as to only display one error message before returning
          PostemTool.clearMessages();
          PostemTool.populateMessage(
              FacesMessage.SEVERITY_ERROR, "duplicate_title", new Object[] {});
          return "create_gradebook";
        }
      }
    }
    if (currentGradebook.getTitle() == null || currentGradebook.getTitle().equals("")) {
      // To stay consistent, remove current messages when adding a new message
      // so as to only display one error message before returning
      PostemTool.clearMessages();
      PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, "missing_title", new Object[] {});
      return "create_gradebook";
    } else if (currentGradebook.getTitle().trim().length() > TITLE_MAX_LENGTH) {
      PostemTool.clearMessages();
      PostemTool.populateMessage(
          FacesMessage.SEVERITY_ERROR,
          "title_too_long",
          new Object[] {
            new Integer(currentGradebook.getTitle().trim().length()), new Integer(TITLE_MAX_LENGTH)
          });
      return "create_gradebook";
    }

    Reference attachment = getAttachmentReference();
    if (attachment == null) {
      return "create_gradebook";
    }

    if (!this.delimiter.equals(COMMA_DELIM_STR) && !this.delimiter.equals(TAB_DELIM_STR)) {
      PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, "invalid_delim", new Object[] {});
      return "create_gradebook";
    }

    if (attachment != null) {
      // logger.info("*** Non-Empty CSV!");
      try {

        char csv_delim = CSV.COMMA_DELIM;
        if (this.delimiter.equals(TAB_DELIM_STR)) {
          csv_delim = CSV.TAB_DELIM;
        }

        // Read the data

        ContentResource cr = contentHostingService.getResource(attachment.getId());
        // Check the type
        if (ResourceProperties.TYPE_URL.equalsIgnoreCase(cr.getContentType())) {
          // Going to need to read from a stream
          String csvURL = new String(cr.getContent());
          // Load the URL
          csv = URLConnectionReader.getText(csvURL);
          if (LOG.isDebugEnabled()) {
            LOG.debug(csv);
          }
        } else {
          csv = new String(cr.getContent());
          if (LOG.isDebugEnabled()) {
            LOG.debug(csv);
          }
        }
        CSV grades = new CSV(csv, withHeader, csv_delim);

        if (withHeader == true) {
          if (grades.getHeaders() != null) {

            List headingList = grades.getHeaders();
            for (int col = 0; col < headingList.size(); col++) {
              String heading = (String) headingList.get(col).toString().trim();
              // Make sure there are no blank headings
              if (heading == null || heading.equals("")) {
                PostemTool.populateMessage(
                    FacesMessage.SEVERITY_ERROR, "blank_headings", new Object[] {});
                return "create_gradebook";
              }
              // Make sure the headings don't exceed max limit
              if (heading.length() > HEADING_MAX_LENGTH) {
                PostemTool.populateMessage(
                    FacesMessage.SEVERITY_ERROR,
                    "heading_too_long",
                    new Object[] {new Integer(HEADING_MAX_LENGTH)});
                return "create_gradebook";
              }
            }
          }
        }

        if (grades.getStudents() != null) {
          if (!usernamesValid(grades)) {
            return "create_gradebook";
          }

          if (hasADuplicateUsername(grades)) {
            return "create_gradebook";
          }
        }

        if (this.newTemplate != null && this.newTemplate.trim().length() > 0) {
          if (this.newTemplate.trim().length() > TEMPLATE_MAX_LENGTH) {
            PostemTool.populateMessage(
                FacesMessage.SEVERITY_ERROR,
                "template_too_long",
                new Object[] {
                  new Integer(this.newTemplate.trim().length()), new Integer(TEMPLATE_MAX_LENGTH)
                });
            return "create_gradebook";
          }
        }

        if (withHeader == true) {
          if (grades.getHeaders() != null) {
            PostemTool.populateMessage(FacesMessage.SEVERITY_INFO, "has_headers", new Object[] {});
          }
        }
        if (grades.getStudents() != null) {
          PostemTool.populateMessage(
              FacesMessage.SEVERITY_INFO,
              "has_students",
              new Object[] {new Integer(grades.getStudents().size())});
        }
        if (withHeader == true) {
          currentGradebook.setHeadings(grades.getHeaders());
        }
        List slist = grades.getStudents();

        if (oldGradebook.getId() != null && !this.userPressedBack) {
          Set oldStudents = currentGradebook.getStudents();
          oldGradebook.setStudents(oldStudents);
        }

        currentGradebook.setStudents(new TreeSet());
        // gradebookManager.saveGradebook(currentGradebook);
        Iterator si = slist.iterator();
        while (si.hasNext()) {
          List ss = (List) si.next();
          String uname = ((String) ss.remove(0)).trim();
          // logger.info("[POSTEM] processCreate -- adding student " +
          // uname);
          gradebookManager.createStudentGradesInGradebook(uname, ss, currentGradebook);
          if (currentGradebook.getStudents().size() == 1) {
            currentGradebook.setFirstUploadedUsername(
                uname); // otherwise, the verify screen shows first in ABC order
          }
        }
      } catch (DataFormatException exception) {
        /*
         * TODO: properly subclass exception in order to allow for localized
         * messages (add getRowNumber/setRowNumber). Set exception message to be
         * key in .properties file
         */
        PostemTool.populateMessage(
            FacesMessage.SEVERITY_ERROR, exception.getMessage(), new Object[] {});
        return "create_gradebook";
      } catch (IdUnusedException e) {
        PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), new Object[] {});
        return "create_gradebook";
      } catch (TypeException e) {
        PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), new Object[] {});
        return "create_gradebook";
      } catch (PermissionException e) {
        PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), new Object[] {});
        return "create_gradebook";
      } catch (ServerOverloadException e) {
        PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), new Object[] {});
        return "create_gradebook";
      } catch (IOException e) {
        PostemTool.populateMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), new Object[] {});
        return "create_gradebook";
      }
    } else if (this.csv != null) {
      // logger.info("**** Non Null Empty CSV!");
      PostemTool.populateMessage(
          FacesMessage.SEVERITY_ERROR, "has_students", new Object[] {new Integer(0)});
      currentGradebook.setHeadings(new ArrayList());
      if (oldGradebook.getId() != null) {
        Set oldStudents = currentGradebook.getStudents();
        oldGradebook.setStudents(oldStudents);
      }

      currentGradebook.setStudents(new TreeSet());
    }

    if (this.newTemplate != null && this.newTemplate.trim().length() > 0) {
      currentGradebook.setTemplate(gradebookManager.createTemplate(newTemplate.trim()));
    } else if (this.newTemplate != null) {
      // logger.info("*** Non Null Empty Template!");
      currentGradebook.setTemplate(null);
    }

    /*
     * if("No".equals(this.release)) { currentGradebook.setReleased(new
     * Boolean(false)); //logger.info("Set to No, " +
     * currentGradebook.getReleased()); } else {
     * currentGradebook.setReleased(new Boolean(true)); //logger.info("Set to
     * Yes, " + currentGradebook.getReleased()); }
     */

    // gradebookManager.saveGradebook(currentGradebook);
    // logger.info(currentGradebook.getId());
    // currentGradebook = null;
    if ((this.csv != null && this.csv.trim().length() > 0)
        || (this.newTemplate != null && this.newTemplate.trim().length() > 0)) {
      this.csv = null;
      this.newTemplate = null;
      return "verify";
    }

    Iterator oi = oldGradebook.getStudents().iterator();
    while (oi.hasNext()) {
      gradebookManager.deleteStudentGrades((StudentGrades) oi.next());
    }
    this.userId = SessionManager.getCurrentSessionUserId();
    currentGradebook.setLastUpdated(new Timestamp(new Date().getTime()));
    currentGradebook.setLastUpdater(this.userId);
    gradebookManager.saveGradebook(currentGradebook);

    this.currentGradebook = null;
    this.oldGradebook = null;
    this.withHeader = true;
    // this.gradebooks = null;
    return "main";
  }
Esempio n. 13
0
  @Override
  public CompressedChunkMessage decode(ChannelBuffer buffer) throws IOException {
    int x = buffer.readInt();
    int z = buffer.readInt();
    boolean contiguous = buffer.readByte() == 1;

    short primaryBitMap = buffer.readShort();
    short addBitMap = buffer.readShort();
    int compressedSize = buffer.readInt();
    int unused = buffer.readInt();
    byte[] compressedData = new byte[compressedSize];
    buffer.readBytes(compressedData);

    boolean[] hasAdditionalData = new boolean[MAX_SECTIONS];
    byte[][] data = new byte[MAX_SECTIONS][];

    int size = 0;
    for (int i = 0; i < MAX_SECTIONS; ++i) {
      if ((primaryBitMap & 1 << i) != 0) { // This chunk exists! Let's initialize the data for it.
        int sectionSize = SIXTEEN_CUBED * 5 / 2;
        if ((addBitMap & 1 << i) != 0) {
          hasAdditionalData[i] = true;
          sectionSize += SIXTEEN_CUBED / 2;
        }

        data[i] = new byte[sectionSize];
        size += sectionSize;
      }
    }

    if (contiguous) {
      size += Chunk.CHUNK_SIZE * Chunk.CHUNK_SIZE;
    }

    byte[] uncompressedData = new byte[size];

    Inflater inflater = new Inflater();
    inflater.setInput(compressedData);
    inflater.getRemaining();
    try {
      int uncompressed = inflater.inflate(uncompressedData);
      if (uncompressed == 0) {
        throw new IOException("Not all bytes uncompressed.");
      }
    } catch (DataFormatException e) {
      e.printStackTrace();
      throw new IOException("Bad compressed data.");
    } finally {
      inflater.end();
    }

    size = 0;
    for (byte[] sectionData : data) {
      if (sectionData != null && sectionData.length + size < uncompressedData.length) {
        System.arraycopy(uncompressedData, size, sectionData, 0, sectionData.length);
        size += sectionData.length;
      }
    }
    byte[] biomeData = new byte[Chunk.CHUNK_SIZE * Chunk.CHUNK_SIZE];

    if (contiguous) {
      System.arraycopy(uncompressedData, size, biomeData, 0, biomeData.length);
      size += biomeData.length;
    }

    return new CompressedChunkMessage(x, z, contiguous, hasAdditionalData, unused, data, biomeData);
  }
Esempio n. 14
0
  private void readRecord(int recordSize) throws IOException {
    int uid = PdbUtil.readShort(myStream);
    if (uid == 1) {
      myCompressionVersion = (short) PdbUtil.readShort(myStream);
    } else {
      int paragraphs = PdbUtil.readShort(myStream);

      int size = PdbUtil.readShort(myStream);
      // TODO ??????
      int type = myStream.read();

      int flags = myStream.read();

      switch (type) {
        case 0: // text (TODO: found sample file and test this code)
        case 1: // compressed text
          {
            ArrayList /*<Integer>*/ pars = new ArrayList();
            for (int i = 0; i < paragraphs; ++i) {
              int pSize = PdbUtil.readShort(myStream);
              pars.add(pSize);
              myStream.skip(2);
            }

            boolean doProcess = false;
            if (type == 0) { // ?
              byte[] buf = new byte[size];
              doProcess = myStream.read(buf, 0, (int) size) == size;
              if (doProcess) {
                // TODO: use encoding!!!!
                // TODO: don't create any new objects!!!!
                myCharBuffer = new String(buf).toCharArray();
              }
            } else if (myCompressionVersion == 1) {
              byte[] buf = new byte[size];
              doProcess =
                  DocDecompressor.decompress(myStream, buf, recordSize - 8 - 4 * paragraphs)
                      == size;
              if (doProcess) {
                myCharBuffer = new String(buf).toCharArray();
              }
            } else if (myCompressionVersion == 2) {
              byte input[] = new byte[(int) (recordSize - 10 - 4 * paragraphs)];
              final int inputSize = myStream.read(input);
              Inflater decompressor = new Inflater();
              decompressor.setInput(input, 0, inputSize);
              byte output[] = new byte[size];
              try {
                doProcess = decompressor.inflate(output) == size;
                decompressor.end();
                myCharBuffer = new String(output, 0, size).toCharArray();
              } catch (DataFormatException e) {
                // TODO Auto-generated catch block
                //	e.printStackTrace();
                System.out.println(e.getMessage());
              }
              // doProcess =
              // ZLZDecompressor(recordSize - 10 - 4 * paragraphs).
              // decompress(myStream, myCharBuffer, size) == size;
            }
            if (doProcess) {
              addHyperlinkLabel(fromNumber(uid));
              myParagraphMap.put(uid, new ArrayList());
              myParagraphVector = (ArrayList) myParagraphMap.get(uid);
              processTextRecord(size, pars);
              if ((flags & 0x1) == 0) {
                //							insertEndOfTextParagraph();
                // setNewTextModel();
              }
            }
            break;
          }
        case 2: // image
        case 3: // compressed image
          {
            final String mime = "image/palm";
            ZLImage image = null;
            if (type == 2) {
              System.out.println("non-compressed image");
              image = new PluckerFileImage(mime, myFile, myStream.offset(), recordSize - 8);
            } else if (myCompressionVersion == 1) {
              System.out.println("DocCompressedImage");
              image = new DocCompressedFileImage(mime, myFile, myStream.offset(), recordSize - 8);
            } else if (myCompressionVersion == 2) {
              System.out.println("ZCompressedImage");
              image =
                  new ZCompressedFileImage(mime, myFile, myStream.offset() + 2, recordSize - 10);
            }
            if (image != null) {
              addImage(fromNumber(uid), image);
            }
            break;
          }
        case 9: // category record is ignored
          break;
        case 10:
          short typeCode = (short) PdbUtil.readShort(myStream);
          break;
        case 11: // style sheet record is ignored
          break;
        case 12: // font page record is ignored
          break;
        case 13: // TODO: process tables
        case 14: // TODO: process tables
          break;
        case 15: // multiimage
          {
            short columns = (short) PdbUtil.readShort(myStream);
            short rows = (short) PdbUtil.readShort(myStream);
            System.out.println("multiimage");
            /*PluckerMultiImage image = new PluckerMultiImage(rows, columns, Model.getImageMap());
            for (int i = 0; i < size / 2 - 2; ++i) {
            	short us = (short)myStream.read();
            	PdbUtil.readShort(myStream, us);
            	image.addId(fromNumber(us));
            }
            addImage(fromNumber(uid), image);
            */ break;
          }
        default:
          // std::cerr << "type = " << (int)type << "\n";
          break;
      }
    }
  }