Package com.sun.image.codec.jpeg

Examples of com.sun.image.codec.jpeg.JPEGEncodeParam


      while(iterImgs.hasNext()){
        message += "<IMAGE page=\""+count+"\">";
        BufferedImage image = (BufferedImage)iterImgs.next();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(baos);
        JPEGEncodeParam encodeParam = encoder.getDefaultJPEGEncodeParam(image);
        encodeParam.setQuality(1.0f, true);
        encoder.setJPEGEncodeParam(encodeParam);
        encoder.encode(image);
        byte[] byteImg = baos.toByteArray();
        baos.close();
        BASE64Encoder encoder64 = new BASE64Encoder();
View Full Code Here


        y += hei;
      }
      // gets byte of the jpeg image
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(baos);
      JPEGEncodeParam encodeParam = encoder.getDefaultJPEGEncodeParam(finalImage);
      encodeParam.setQuality(1.0f, true);
      encoder.setJPEGEncodeParam(encodeParam);
      encoder.encode(finalImage);
      bytes = baos.toByteArray();
      baos.close();
View Full Code Here

        pngParam.setPhysicalDimension(dpi * 3937, dpi * 3937, 100);
        PNGImageEncoder pngEncoder = new PNGImageEncoder(outputStream,
            pngParam);
        pngEncoder.encode(image);
      } else if ("jpg".equals(lowFormat) || "jpeg".equals(lowFormat)) {
        JPEGEncodeParam jpgParam = JPEGCodec
            .getDefaultJPEGEncodeParam(image);
        jpgParam.setXDensity(dpi);
        jpgParam.setYDensity(dpi);
        jpgParam.setDensityUnit(JPEGDecodeParam.DENSITY_UNIT_DOTS_INCH);
        JPEGImageEncoder jpgEncoder = JPEGCodec.createJPEGEncoder(
            outputStream, jpgParam);
        jpgEncoder.encode(image);
      } else {
        ImageIO.write(image, format, outputStream);
View Full Code Here

  private void drawAWTImage(byte[] aImgSource, OutputStream outStr, int iThumbWidth, int iThumbHeight, float fQuality) throws IOException, InstantiationException, InterruptedException {

    Frame awtFrame;
    JPEGImageEncoder encoder;
    JPEGEncodeParam param;
    BufferedImage thumbImage;
    Graphics2D graphics2D;

    oImg = Toolkit.getDefaultToolkit().createImage(aImgSource);

    int iImageWidth = oImg.getWidth(null);
    int iImageHeight = oImg.getHeight(null);

    double thumbRatio = ((double) iThumbWidth) / ((double) iThumbHeight);
    double imageRatio = ((double) iImageWidth) / ((double) iImageHeight);

    if (thumbRatio < imageRatio)
      iImageHeight = (int)(iThumbWidth / imageRatio);
    else
      iThumbWidth = (int)(iThumbHeight * imageRatio);

    if (null==mediaTracker) {

      try {
        awtFrame = new Frame();
      } catch (Exception e) { throw new InstantiationException("Cannot instantiate java.awt.Frame " + (e.getMessage()!=null ? e.getMessage() : "")); }

      mediaTracker = new MediaTracker(awtFrame);
    } // fi (mediaTracker)

    mediaTracker.addImage(oImg, 0);
    mediaTracker.waitForID(0);

    // draw original image to thumbnail image object and
    // scale it to the new size on-the-fly
    thumbImage = new BufferedImage(iThumbWidth, iThumbHeight, BufferedImage.TYPE_INT_RGB);

    graphics2D = thumbImage.createGraphics();
    graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    graphics2D.drawImage(oImg, 0, 0, iThumbWidth, iThumbHeight, null);
    graphics2D.dispose();

    encoder = JPEGCodec.createJPEGEncoder(outStr);
    param = encoder.getDefaultJPEGEncodeParam(thumbImage);

  // javax.imageio.plugins.jpeg.JPEGHuffmanTable t;
  // javax.imageio.plugins.jpeg.JPEGQTable q;
 
    fQuality = Math.max(0, Math.min(fQuality, 100));
    if (fQuality>1)
      param.setQuality(fQuality / 100.0f, false);
    else
      param.setQuality(fQuality, false);

    encoder.setJPEGEncodeParam(param);

    encoder.encode(thumbImage);

View Full Code Here

        pngParam.setPhysicalDimension(dpi * 3937, dpi * 3937, 100);
        PNGImageEncoder pngEncoder = new PNGImageEncoder(outputStream,
            pngParam);
        pngEncoder.encode(image);
      } else if ("jpg".equals(lowFormat) || "jpeg".equals(lowFormat)) {
        JPEGEncodeParam jpgParam = JPEGCodec
            .getDefaultJPEGEncodeParam(image);
        jpgParam.setXDensity(dpi);
        jpgParam.setYDensity(dpi);
        jpgParam.setDensityUnit(JPEGDecodeParam.DENSITY_UNIT_DOTS_INCH);
        JPEGImageEncoder jpgEncoder = JPEGCodec.createJPEGEncoder(
            outputStream, jpgParam);
        jpgEncoder.encode(image);
      } else {
        ImageIO.write(image, format, outputStream);
View Full Code Here

       
        chart.paintComponent( g );

        // Encode the BufferedImage as a JPEG image and write it to the output stream.
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder( os );
        JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam( bi );
        param.setQuality( 0.90f, true );
        encoder.encode( bi, param );
    }
View Full Code Here

            tileHeight = encodeParam.getTileHeight() > 0 ?
                encodeParam.getTileHeight() : DEFAULT_ROWS_PER_STRIP;
        }

        // Re-tile for JPEG conformance if needed.
        JPEGEncodeParam jep = null;
        if(compression == COMP_JPEG_TTN2) {
            // Get JPEGEncodeParam from encodeParam.
            jep = encodeParam.getJPEGEncodeParam();

            // Determine maximum subsampling.
            int maxSubH = jep.getHorizontalSubsampling(0);
            int maxSubV = jep.getVerticalSubsampling(0);
            for(int i = 1; i < numBands; i++) {
                int subH = jep.getHorizontalSubsampling(i);
                if(subH > maxSubH) {
                    maxSubH = subH;
                }
                int subV = jep.getVerticalSubsampling(i);
                if(subV > maxSubV) {
                    maxSubV = subV;
                }
            }

            int factorV = 8*maxSubV;
            tileHeight =
                (int)((float)tileHeight/(float)factorV + 0.5F)*factorV;
            if(tileHeight < factorV) {
                tileHeight = factorV;
            }

            if(isTiled) {
                int factorH = 8*maxSubH;
                tileWidth =
                    (int)((float)tileWidth/(float)factorH + 0.5F)*factorH;
                if(tileWidth < factorH) {
                    tileWidth = factorH;
                }
            }
        }

        int numTiles;
        if(isTiled) {
            // NB: Parentheses are used in this statement for correct rounding.
            numTiles =
                ((width + tileWidth - 1)/tileWidth) *
                ((height + tileHeight - 1)/tileHeight);
        } else {
            numTiles = (int)Math.ceil((double)height/(double)tileHeight);
        }

        long[] tileByteCounts = new long[numTiles];

        long bytesPerRow =
            (long)Math.ceil((sampleSize[0] / 8.0) * tileWidth * numBands);

        long bytesPerTile = bytesPerRow * tileHeight;

        for (int i=0; i<numTiles; i++) {
            tileByteCounts[i] = bytesPerTile;
        }

        if(!isTiled) {
            // Last strip may have lesser rows
            long lastStripRows = height - (tileHeight * (numTiles-1));
            tileByteCounts[numTiles-1] = lastStripRows * bytesPerRow;
        }

        long totalBytesOfData = bytesPerTile * (numTiles - 1) +
            tileByteCounts[numTiles-1];

        // The data will be written after the IFD: create the array here
        // but fill it in later.
        long[] tileOffsets = new long[numTiles];

        // Basic fields - have to be in increasing numerical order.
        // ImageWidth                     256
        // ImageLength                    257
        // BitsPerSample                  258
        // Compression                    259
        // PhotoMetricInterpretation      262
        // StripOffsets                   273
        // RowsPerStrip                   278
        // StripByteCounts                279
        // XResolution                    282
        // YResolution                    283
        // ResolutionUnit                 296

        // Create Directory
        SortedSet fields = new TreeSet();

        // Image Width
        fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_WIDTH,
                                 TIFFField.TIFF_LONG, 1,
                                 new long[] {width}));

        // Image Length
        fields.add(new TIFFField(TIFFImageDecoder.TIFF_IMAGE_LENGTH,
                                 TIFFField.TIFF_LONG, 1,
                                 new long[] {height}));

        char [] shortSampleSize = new char[numBands];
        for (int i=0; i<numBands; i++)
            shortSampleSize[i] = (char)sampleSize[i];
        fields.add(new TIFFField(TIFFImageDecoder.TIFF_BITS_PER_SAMPLE,
                                 TIFFField.TIFF_SHORT, numBands,
                                 shortSampleSize));

        fields.add(new TIFFField(TIFFImageDecoder.TIFF_COMPRESSION,
                                 TIFFField.TIFF_SHORT, 1,
                                 new char[] {(char)compression}));

        fields.add(
            new TIFFField(TIFFImageDecoder.TIFF_PHOTOMETRIC_INTERPRETATION,
                          TIFFField.TIFF_SHORT, 1,
                                 new char[] {(char)photometricInterpretation}));

        if(!isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_OFFSETS,
                                     TIFFField.TIFF_LONG, numTiles,
                                     tileOffsets));
        }

        fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLES_PER_PIXEL,
                                 TIFFField.TIFF_SHORT, 1,
                                 new char[] {(char)numBands}));

        if(!isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_ROWS_PER_STRIP,
                                     TIFFField.TIFF_LONG, 1,
                                     new long[] {tileHeight}));

            fields.add(new TIFFField(TIFFImageDecoder.TIFF_STRIP_BYTE_COUNTS,
                                     TIFFField.TIFF_LONG, numTiles,
                                     tileByteCounts));
        }

        if (colormap != null) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_COLORMAP,
                                     TIFFField.TIFF_SHORT, sizeOfColormap,
                                     colormap));
        }

        if(isTiled) {
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_WIDTH,
                                     TIFFField.TIFF_LONG, 1,
                                     new long[] {tileWidth}));

            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_LENGTH,
                                     TIFFField.TIFF_LONG, 1,
                                     new long[] {tileHeight}));

            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_OFFSETS,
                                     TIFFField.TIFF_LONG, numTiles,
                                     tileOffsets));

            fields.add(new TIFFField(TIFFImageDecoder.TIFF_TILE_BYTE_COUNTS,
                                     TIFFField.TIFF_LONG, numTiles,
                                     tileByteCounts));
        }

        if(numExtraSamples > 0) {
            char[] extraSamples = new char[numExtraSamples];
            for(int i = 0; i < numExtraSamples; i++) {
                extraSamples[i] = (char)extraSampleType;
            }
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_EXTRA_SAMPLES,
                                     TIFFField.TIFF_SHORT, numExtraSamples,
                                     extraSamples));
        }

        // Data Sample Format Extension fields.
        if(dataType != DataBuffer.TYPE_BYTE) {
            // SampleFormat
            char[] sampleFormat = new char[numBands];
            if(dataType == DataBuffer.TYPE_FLOAT) {
                sampleFormat[0] = 3;
            } else if(dataType == DataBuffer.TYPE_USHORT) {
                sampleFormat[0] = 1;
            } else {
                sampleFormat[0] = 2;
            }
            for(int b = 1; b < numBands; b++) {
                sampleFormat[b] = sampleFormat[0];
            }
            fields.add(new TIFFField(TIFFImageDecoder.TIFF_SAMPLE_FORMAT,
                                     TIFFField.TIFF_SHORT, numBands,
                                     sampleFormat));

            // NOTE: We don't bother setting the SMinSampleValue and
            // SMaxSampleValue fields as these both default to the
            // extrema of the respective data types.  Probably we should
            // check for the presence of the "extrema" property and
            // use it if available.
        }

        // Initialize some JPEG variables.
        com.sun.image.codec.jpeg.JPEGEncodeParam jpegEncodeParam = null;
        com.sun.image.codec.jpeg.JPEGImageEncoder jpegEncoder = null;
        int jpegColorID = 0;

        if(compression == COMP_JPEG_TTN2) {

            // Initialize JPEG color ID.
            jpegColorID =
                com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_UNKNOWN;
            switch(imageType) {
            case TIFF_GRAY:
            case TIFF_PALETTE:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_GRAY;
                break;
            case TIFF_RGB:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_RGB;
                break;
            case TIFF_YCBCR:
                jpegColorID =
                    com.sun.image.codec.jpeg.JPEGDecodeParam.COLOR_ID_YCbCr;
                break;
            }

            // Get the JDK encoding parameters.
            Raster tile00 = im.getTile(0, 0);
            jpegEncodeParam =
                com.sun.image.codec.jpeg.JPEGCodec.getDefaultJPEGEncodeParam(
                    tile00, jpegColorID);

            modifyEncodeParam(jep, jpegEncodeParam, numBands);

            // Write an abbreviated tables-only stream to JPEGTables field.
            jpegEncodeParam.setImageInfoValid(false);
            jpegEncodeParam.setTableInfoValid(true);
            ByteArrayOutputStream tableStream =
              new ByteArrayOutputStream();
            jpegEncoder =
              com.sun.image.codec.jpeg.JPEGCodec.createJPEGEncoder(
                tableStream,
                jpegEncodeParam);
            jpegEncoder.encode(tile00);
            byte[] tableData = tableStream.toByteArray();
            fields.add(new TIFFField(TIFF_JPEG_TABLES,
                                     TIFFField.TIFF_UNDEFINED,
                                     tableData.length,
                                     tableData));

            // Reset encoder so it's recreated below.
            jpegEncoder = null;
        }

        if(imageType == TIFF_YCBCR) {
            // YCbCrSubSampling: 2 is the default so we must write 1 as
            // we do not (yet) do any subsampling.
            char subsampleH = 1;
            char subsampleV = 1;

            // If JPEG, update values.
            if(compression == COMP_JPEG_TTN2) {
                // Determine maximum subsampling.
                subsampleH = (char)jep.getHorizontalSubsampling(0);
                subsampleV = (char)jep.getVerticalSubsampling(0);
                for(int i = 1; i < numBands; i++) {
                    char subH = (char)jep.getHorizontalSubsampling(i);
                    if(subH > subsampleH) {
                        subsampleH = subH;
                    }
                    char subV = (char)jep.getVerticalSubsampling(i);
                    if(subV > subsampleV) {
                        subsampleV = subV;
                    }
                }
            }
View Full Code Here

        if (channels == 4 && img.getColorModel().getColorSpace().getType() != ColorSpace.TYPE_CMYK) {
            img = ImageColorConvertHelper.convertRGBA2RGB(PlanarImage.wrapRenderedImage(img)).getAsBufferedImage();
            channels = img.getColorModel().getNumComponents();
        }

        JPEGEncodeParam encodeParam = JPEGCodec.getDefaultJPEGEncodeParam(img);
        if (inParam.isSamplingSet()) {
            encodeParam.setHorizontalSubsampling(0, inParam.getHorizontalSubsampling(0));
            encodeParam.setVerticalSubsampling(0, inParam.getVerticalSubsampling(0));

            if (channels >= 3) {
                encodeParam.setHorizontalSubsampling(1, inParam.getHorizontalSubsampling(1));
                encodeParam.setVerticalSubsampling(1, inParam.getVerticalSubsampling(1));

                encodeParam.setHorizontalSubsampling(2, inParam.getHorizontalSubsampling(2));
                encodeParam.setVerticalSubsampling(2, inParam.getVerticalSubsampling(2));
            }

            if (channels >= 4) {
                encodeParam.setHorizontalSubsampling(3, inParam.getHorizontalSubsampling(3));
                encodeParam.setVerticalSubsampling(3, inParam.getVerticalSubsampling(3));
            }
        } else {
            encodeParam.setHorizontalSubsampling(0, imgWrapper.getHorizontalSubsampling(0));
            encodeParam.setVerticalSubsampling(0, imgWrapper.getVerticalSubsampling(0));

            if (channels >= 3) {
                encodeParam.setHorizontalSubsampling(1, imgWrapper.getHorizontalSubsampling(1));
                encodeParam.setVerticalSubsampling(1, imgWrapper.getVerticalSubsampling(1));

                encodeParam.setHorizontalSubsampling(2, imgWrapper.getHorizontalSubsampling(2));
                encodeParam.setVerticalSubsampling(2, imgWrapper.getVerticalSubsampling(2));
            }
            if (channels >= 4) {
                encodeParam.setHorizontalSubsampling(3, imgWrapper.getHorizontalSubsampling(3));
                encodeParam.setVerticalSubsampling(3, imgWrapper.getVerticalSubsampling(3));
            }
        }

        if (inParam.isQualitySet()) {
            encodeParam.setQuality(inParam.getDefaultQuality(), false);
        } else {
            int q = imgWrapper.getQuality();
            if (q < DEFAULT_MIN_QUALITY) {
                q = DEFAULT_MIN_QUALITY;
            }
            encodeParam.setQuality(q / 100.0f, false);
        }

        try {
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(os, encodeParam);
            encoder.encode(img);
View Full Code Here

  ByteArrayOutputStream baos = new ByteArrayOutputStream() ;

  SampleModel sm = ras.getSampleModel() ;

  JPEGEncodeParam j2dEP = convertToJ2DJPEGEncodeParam(paramList, sm) ;
        ((JPEGParam)j2dEP).setWidth(ras.getWidth()) ;
  ((JPEGParam)j2dEP).setHeight(ras.getHeight()) ;

  JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(baos, j2dEP) ;
  encoder.encode(ras) ;
View Full Code Here

}
private void sendScreen(SocketAddress address) {
  try {
   BufferedImage image=robot.createScreenCapture(new Rectangle(toolkit.getScreenSize()));
   ByteArrayOutputStream output=new ByteArrayOutputStream();
   JPEGEncodeParam param=JPEGCodec.getDefaultJPEGEncodeParam(image);
   param.setQuality(0.1f,true);
   JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(output,param);
   encoder.encode(image);
   encoder.getOutputStream().close();
   DatagramPacket packet=new DatagramPacket(output.toByteArray(),output.size
(),address);
View Full Code Here

TOP

Related Classes of com.sun.image.codec.jpeg.JPEGEncodeParam

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.