This commit is contained in:
WangQiang 2017-03-02 13:03:37 +08:00
parent 4a7f52d86c
commit d22bed4c29
24 changed files with 1586 additions and 10 deletions

44
.gitignore vendored
View File

@ -1,12 +1,36 @@
*.class # maven ignore
target/
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war *.war
*.ear *.zip
*.tar
*.tar.gz
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml # eclipse ignore
hs_err_pid* .settings/
.project
.classpath
.tern-project
# idea ignore
.idea/
*.ipr
*.iml
*.iws
# temp ignore
.svn/
generated/
.externalToolBuilders/
logs/
*.log
*.cache
*.diff
*.patch
*.tmp
*.java~
*.properties~
*.xml~
# system ignore
.DS_Store
Thumbs.db

View File

@ -1,2 +1,11 @@
# j-webp # j-webp
Java Image I/O reader and writer for the Google WebP image format. Java Image I/O reader and writer for the Google WebP image format.
基于[webp project of Luciad](https://bitbucket.org/luciad/webp-imageio) 0.4.2版本修改.
实际上只修改了`com.luciad.imageio.webp.WebP.loadNativeLibrary`这一个方法.
因为按他默认的加载方式, 需要把native的so/dll/dylib等文件放到OS对应的`java.library.path`对应的目录才能加载到, 这会给部署带来一些不便.
所以我们这里换成了[native-lib-loader](https://github.com/scijava/native-lib-loader)自动加载, 编译构建好的包里已经包含了各种OS上的native文件, 使用时会自动加载.
具体使用方法可参看`src/main/java/example`下的源码.

25
pom.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>net.wangq</groupId>
<artifactId>webp</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.scijava</groupId>
<artifactId>native-lib-loader</artifactId>
<version>2.1.3</version>
</dependency>
</dependencies>
</project>

View File

@ -0,0 +1,38 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
enum VP8StatusCode {
VP8_STATUS_OK,
VP8_STATUS_OUT_OF_MEMORY,
VP8_STATUS_INVALID_PARAM,
VP8_STATUS_BITSTREAM_ERROR,
VP8_STATUS_UNSUPPORTED_FEATURE,
VP8_STATUS_SUSPENDED,
VP8_STATUS_USER_ABORT,
VP8_STATUS_NOT_ENOUGH_DATA,;
private static VP8StatusCode[] VALUES = values();
public static VP8StatusCode getStatusCode( int aValue ) {
if ( aValue >= 0 && aValue < VALUES.length ) {
return VALUES[ aValue ];
}
else {
return null;
}
}
}

View File

@ -0,0 +1,428 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import org.scijava.nativelib.NativeLibraryUtil;
import java.awt.image.*;
import java.io.IOException;
import java.nio.ByteOrder;
import java.util.Hashtable;
final class WebP {
private static boolean NATIVE_LIBRARY_LOADED = false;
static synchronized void loadNativeLibrary() {
if ( !NATIVE_LIBRARY_LOADED ) {
NATIVE_LIBRARY_LOADED = true;
NativeLibraryUtil.loadNativeLibrary(WebP.class, "webp-imageio");
}
}
static {
loadNativeLibrary();
}
private WebP() {
}
public static BufferedImage decode( WebPReadParam aReadParam, byte[] aData, int aOffset, int aLength ) throws IOException {
if ( aReadParam == null ) {
throw new NullPointerException( "Decoder options may not be null" );
}
if ( aData == null ) {
throw new NullPointerException( "Input data may not be null" );
}
if ( aOffset + aLength > aData.length ) {
throw new IllegalArgumentException( "Offset/length exceeds array size" );
}
int[] out = new int[4];
int[] pixels = decode( aReadParam.fPointer, aData, aOffset, aLength, out, ByteOrder.nativeOrder().equals( ByteOrder.BIG_ENDIAN ) );
VP8StatusCode status = VP8StatusCode.getStatusCode( out[0] );
switch ( status ) {
case VP8_STATUS_OK:
break;
case VP8_STATUS_OUT_OF_MEMORY:
throw new OutOfMemoryError();
default:
throw new IOException( "Decode returned code " + status );
}
int width = out[1];
int height = out[2];
boolean alpha = out[3] != 0;
ColorModel colorModel;
if ( alpha ) {
colorModel = new DirectColorModel( 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 );
} else {
colorModel = new DirectColorModel( 24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000 );
}
SampleModel sampleModel = colorModel.createCompatibleSampleModel( width, height );
DataBufferInt db = new DataBufferInt( pixels, width * height );
WritableRaster raster = WritableRaster.createWritableRaster( sampleModel, db, null );
return new BufferedImage( colorModel, raster, false, new Hashtable<Object, Object>() );
}
private static native int[] decode( long aDecoderOptionsPointer, byte[] aData, int aOffset, int aLength, int[] aFlags, boolean aBigEndian );
public static int[] getInfo( byte[] aData, int aOffset, int aLength ) throws IOException {
int[] out = new int[2];
int result = getInfo( aData, aOffset, aLength, out );
if (result == 0) {
throw new IOException( "Invalid WebP data" );
}
return out;
}
private static native int getInfo( byte[] aData, int aOffset, int aLength, int[] aOut );
public static byte[] encode( WebPWriteParam aWriteParam, RenderedImage aImage ) throws IOException {
if ( aWriteParam == null ) {
throw new NullPointerException( "Encoder options may not be null" );
}
if ( aImage == null ) {
throw new NullPointerException( "Image may not be null" );
}
boolean encodeAlpha = hasTranslucency( aImage );
if ( encodeAlpha ) {
byte[] rgbaData = getRGBA( aImage );
return encodeRGBA( aWriteParam.getPointer(), rgbaData, aImage.getWidth(), aImage.getHeight(), aImage.getWidth() * 4 );
}
else {
byte[] rgbData = getRGB( aImage );
return encodeRGB( aWriteParam.getPointer(), rgbData, aImage.getWidth(), aImage.getHeight(), aImage.getWidth() * 3 );
}
}
private static native byte[] encodeRGBA( long aConfig, byte[] aRgbaData, int aWidth, int aHeight, int aStride );
private static native byte[] encodeRGB( long aConfig, byte[] aRgbaData, int aWidth, int aHeight, int aStride );
private static boolean hasTranslucency( RenderedImage aRi ) {
return aRi.getColorModel().hasAlpha();
}
private static int getShift( int aMask ) {
int shift = 0;
while ( ( ( aMask >> shift ) & 0x1 ) == 0 ) {
shift++;
}
return shift;
}
private static byte[] getRGB( RenderedImage aRi ) throws IOException {
int width = aRi.getWidth();
int height = aRi.getHeight();
ColorModel colorModel = aRi.getColorModel();
if ( colorModel instanceof ComponentColorModel ) {
ComponentSampleModel sampleModel = ( ComponentSampleModel ) aRi.getSampleModel();
int type = sampleModel.getTransferType();
if ( type == DataBuffer.TYPE_BYTE ) {
return extractComponentRGBByte( width, height, sampleModel, ( ( DataBufferByte ) aRi.getData().getDataBuffer() ) );
}
else if ( type == DataBuffer.TYPE_INT ) {
return extractComponentRGBInt( width, height, sampleModel, ( ( DataBufferInt ) aRi.getData().getDataBuffer() ) );
}
else {
throw new IOException( "Incompatible image: " + aRi );
}
}
else if ( colorModel instanceof DirectColorModel ) {
SinglePixelPackedSampleModel sampleModel = ( SinglePixelPackedSampleModel ) aRi.getSampleModel();
int type = sampleModel.getTransferType();
if ( type == DataBuffer.TYPE_INT ) {
return extractDirectRGBInt( width, height, ( DirectColorModel ) colorModel, sampleModel, ( ( DataBufferInt ) aRi.getData().getDataBuffer() ) );
}
else {
throw new IOException( "Incompatible image: " + aRi );
}
}
return extractGenericRGB( aRi, width, height, colorModel );
}
private static byte[] extractGenericRGB( RenderedImage aRi, int aWidth, int aHeight, ColorModel aColorModel ) {
Object dataElements = null;
byte[] rgbData = new byte[ aWidth * aHeight * 3 ];
for ( int b = 0, y = 0; y < aHeight; y++ ) {
for ( int x = 0; x < aWidth; x++, b += 3 ) {
dataElements = aRi.getData().getDataElements( x, y, dataElements );
rgbData[ b ] = ( byte ) aColorModel.getRed( dataElements );
rgbData[ b + 1 ] = ( byte ) aColorModel.getGreen( dataElements );
rgbData[ b + 2 ] = ( byte ) aColorModel.getBlue( dataElements );
}
}
return rgbData;
}
private static byte[] extractDirectRGBInt( int aWidth, int aHeight, DirectColorModel aColorModel, SinglePixelPackedSampleModel aSampleModel, DataBufferInt aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 3 ];
int rMask = aColorModel.getRedMask();
int gMask = aColorModel.getGreenMask();
int bMask = aColorModel.getBlueMask();
int rShift = getShift( rMask );
int gShift = getShift( gMask );
int bShift = getShift( bMask );
int[] bank = aDataBuffer.getBankData()[ 0 ];
int scanlineStride = aSampleModel.getScanlineStride();
int scanIx = 0;
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int pixIx = scanIx;
for ( int x = 0; x < aWidth; x++, b += 3 ) {
int pixel = bank[ pixIx++ ];
out[ b ] = ( byte ) ( ( pixel & rMask ) >>> rShift );
out[ b + 1 ] = ( byte ) ( ( pixel & gMask ) >>> gShift );
out[ b + 2 ] = ( byte ) ( ( pixel & bMask ) >>> bShift );
}
scanIx += scanlineStride;
}
return out;
}
private static byte[] extractComponentRGBInt( int aWidth, int aHeight, ComponentSampleModel aSampleModel, DataBufferInt aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 3 ];
int[] bankIndices = aSampleModel.getBankIndices();
int[] rBank = aDataBuffer.getBankData()[ bankIndices[ 0 ] ];
int[] gBank = aDataBuffer.getBankData()[ bankIndices[ 1 ] ];
int[] bBank = aDataBuffer.getBankData()[ bankIndices[ 2 ] ];
int[] bankOffsets = aSampleModel.getBandOffsets();
int rScanIx = bankOffsets[ 0 ];
int gScanIx = bankOffsets[ 1 ];
int bScanIx = bankOffsets[ 2 ];
int pixelStride = aSampleModel.getPixelStride();
int scanlineStride = aSampleModel.getScanlineStride();
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int rPixIx = rScanIx;
int gPixIx = gScanIx;
int bPixIx = bScanIx;
for ( int x = 0; x < aWidth; x++, b += 3 ) {
out[ b ] = ( byte ) rBank[ rPixIx ];
rPixIx += pixelStride;
out[ b + 1 ] = ( byte ) gBank[ gPixIx ];
gPixIx += pixelStride;
out[ b + 2 ] = ( byte ) bBank[ bPixIx ];
bPixIx += pixelStride;
}
rScanIx += scanlineStride;
gScanIx += scanlineStride;
bScanIx += scanlineStride;
}
return out;
}
private static byte[] extractComponentRGBByte( int aWidth, int aHeight, ComponentSampleModel aSampleModel, DataBufferByte aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 3 ];
int[] bankIndices = aSampleModel.getBankIndices();
byte[] rBank = aDataBuffer.getBankData()[ bankIndices[ 0 ] ];
byte[] gBank = aDataBuffer.getBankData()[ bankIndices[ 1 ] ];
byte[] bBank = aDataBuffer.getBankData()[ bankIndices[ 2 ] ];
int[] bankOffsets = aSampleModel.getBandOffsets();
int rScanIx = bankOffsets[ 0 ];
int gScanIx = bankOffsets[ 1 ];
int bScanIx = bankOffsets[ 2 ];
int pixelStride = aSampleModel.getPixelStride();
int scanlineStride = aSampleModel.getScanlineStride();
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int rPixIx = rScanIx;
int gPixIx = gScanIx;
int bPixIx = bScanIx;
for ( int x = 0; x < aWidth; x++, b += 3 ) {
out[ b ] = rBank[ rPixIx ];
rPixIx += pixelStride;
out[ b + 1 ] = gBank[ gPixIx ];
gPixIx += pixelStride;
out[ b + 2 ] = bBank[ bPixIx ];
bPixIx += pixelStride;
}
rScanIx += scanlineStride;
gScanIx += scanlineStride;
bScanIx += scanlineStride;
}
return out;
}
private static byte[] getRGBA( RenderedImage aRi ) throws IOException {
int width = aRi.getWidth();
int height = aRi.getHeight();
ColorModel colorModel = aRi.getColorModel();
if ( colorModel instanceof ComponentColorModel ) {
ComponentSampleModel sampleModel = ( ComponentSampleModel ) aRi.getSampleModel();
int type = sampleModel.getTransferType();
if ( type == DataBuffer.TYPE_BYTE ) {
return extractComponentRGBAByte( width, height, sampleModel, ( ( DataBufferByte ) aRi.getData().getDataBuffer() ) );
}
else if ( type == DataBuffer.TYPE_INT ) {
return extractComponentRGBAInt( width, height, sampleModel, ( ( DataBufferInt ) aRi.getData().getDataBuffer() ) );
}
else {
throw new IOException( "Incompatible image: " + aRi );
}
}
else if ( colorModel instanceof DirectColorModel ) {
SinglePixelPackedSampleModel sampleModel = ( SinglePixelPackedSampleModel ) aRi.getSampleModel();
int type = sampleModel.getTransferType();
if ( type == DataBuffer.TYPE_INT ) {
return extractDirectRGBAInt( width, height, ( DirectColorModel ) colorModel, sampleModel, ( ( DataBufferInt ) aRi.getData().getDataBuffer() ) );
}
else {
throw new IOException( "Incompatible image: " + aRi );
}
}
return extractGenericRGBA( aRi, width, height, colorModel );
}
private static byte[] extractGenericRGBA( RenderedImage aRi, int aWidth, int aHeight, ColorModel aColorModel ) {
Object dataElements = null;
byte[] rgbData = new byte[ aWidth * aHeight * 4 ];
for ( int b = 0, y = 0; y < aHeight; y++ ) {
for ( int x = 0; x < aWidth; x++, b += 4 ) {
dataElements = aRi.getData().getDataElements( x, y, dataElements );
rgbData[ b ] = ( byte ) aColorModel.getRed( dataElements );
rgbData[ b + 1 ] = ( byte ) aColorModel.getGreen( dataElements );
rgbData[ b + 2 ] = ( byte ) aColorModel.getBlue( dataElements );
rgbData[ b + 3 ] = ( byte ) aColorModel.getAlpha( dataElements );
}
}
return rgbData;
}
private static byte[] extractDirectRGBAInt( int aWidth, int aHeight, DirectColorModel aColorModel, SinglePixelPackedSampleModel aSampleModel, DataBufferInt aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 4 ];
int rMask = aColorModel.getRedMask();
int gMask = aColorModel.getGreenMask();
int bMask = aColorModel.getBlueMask();
int aMask = aColorModel.getAlphaMask();
int rShift = getShift( rMask );
int gShift = getShift( gMask );
int bShift = getShift( bMask );
int aShift = getShift( aMask );
int[] bank = aDataBuffer.getBankData()[ 0 ];
int scanlineStride = aSampleModel.getScanlineStride();
int scanIx = 0;
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int pixIx = scanIx;
for ( int x = 0; x < aWidth; x++, b += 4 ) {
int pixel = bank[ pixIx++ ];
out[ b ] = ( byte ) ( ( pixel & rMask ) >>> rShift );
out[ b + 1 ] = ( byte ) ( ( pixel & gMask ) >>> gShift );
out[ b + 2 ] = ( byte ) ( ( pixel & bMask ) >>> bShift );
out[ b + 3 ] = ( byte ) ( ( pixel & aMask ) >>> aShift );
}
scanIx += scanlineStride;
}
return out;
}
private static byte[] extractComponentRGBAInt( int aWidth, int aHeight, ComponentSampleModel aSampleModel, DataBufferInt aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 4 ];
int[] bankIndices = aSampleModel.getBankIndices();
int[] rBank = aDataBuffer.getBankData()[ bankIndices[ 0 ] ];
int[] gBank = aDataBuffer.getBankData()[ bankIndices[ 1 ] ];
int[] bBank = aDataBuffer.getBankData()[ bankIndices[ 2 ] ];
int[] aBank = aDataBuffer.getBankData()[ bankIndices[ 3 ] ];
int[] bankOffsets = aSampleModel.getBandOffsets();
int rScanIx = bankOffsets[ 0 ];
int gScanIx = bankOffsets[ 1 ];
int bScanIx = bankOffsets[ 2 ];
int aScanIx = bankOffsets[ 3 ];
int pixelStride = aSampleModel.getPixelStride();
int scanlineStride = aSampleModel.getScanlineStride();
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int rPixIx = rScanIx;
int gPixIx = gScanIx;
int bPixIx = bScanIx;
int aPixIx = aScanIx;
for ( int x = 0; x < aWidth; x++, b += 4 ) {
out[ b ] = ( byte ) rBank[ rPixIx ];
rPixIx += pixelStride;
out[ b + 1 ] = ( byte ) gBank[ gPixIx ];
gPixIx += pixelStride;
out[ b + 2 ] = ( byte ) bBank[ bPixIx ];
bPixIx += pixelStride;
out[ b + 3 ] = ( byte ) aBank[ aPixIx ];
aPixIx += pixelStride;
}
rScanIx += scanlineStride;
gScanIx += scanlineStride;
bScanIx += scanlineStride;
aScanIx += scanlineStride;
}
return out;
}
private static byte[] extractComponentRGBAByte( int aWidth, int aHeight, ComponentSampleModel aSampleModel, DataBufferByte aDataBuffer ) {
byte[] out = new byte[ aWidth * aHeight * 4 ];
int[] bankIndices = aSampleModel.getBankIndices();
byte[] rBank = aDataBuffer.getBankData()[ bankIndices[ 0 ] ];
byte[] gBank = aDataBuffer.getBankData()[ bankIndices[ 1 ] ];
byte[] bBank = aDataBuffer.getBankData()[ bankIndices[ 2 ] ];
byte[] aBank = aDataBuffer.getBankData()[ bankIndices[ 3 ] ];
int[] bankOffsets = aSampleModel.getBandOffsets();
int rScanIx = bankOffsets[ 0 ];
int gScanIx = bankOffsets[ 1 ];
int bScanIx = bankOffsets[ 2 ];
int aScanIx = bankOffsets[ 3 ];
int pixelStride = aSampleModel.getPixelStride();
int scanlineStride = aSampleModel.getScanlineStride();
for ( int b = 0, y = 0; y < aHeight; y++ ) {
int rPixIx = rScanIx;
int gPixIx = gScanIx;
int bPixIx = bScanIx;
int aPixIx = aScanIx;
for ( int x = 0; x < aWidth; x++, b += 4 ) {
out[ b ] = rBank[ rPixIx ];
rPixIx += pixelStride;
out[ b + 1 ] = gBank[ gPixIx ];
gPixIx += pixelStride;
out[ b + 2 ] = bBank[ bPixIx ];
bPixIx += pixelStride;
out[ b + 3 ] = aBank[ aPixIx ];
aPixIx += pixelStride;
}
rScanIx += scanlineStride;
gScanIx += scanlineStride;
bScanIx += scanlineStride;
aScanIx += scanlineStride;
}
return out;
}
}

View File

@ -0,0 +1,106 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.ImageReader;
import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Locale;
/**
*
*/
public class WebPImageReaderSpi extends ImageReaderSpi {
private static final byte[] RIFF = new byte[]{ 'R', 'I', 'F', 'F' };
private static final byte[] WEBP = new byte[]{ 'W', 'E', 'B', 'P' };
private static final byte[] VP8_ = new byte[]{ 'V', 'P', '8', ' ' };
private static final byte[] VP8X = new byte[]{ 'V', 'P', '8', 'X' };
public WebPImageReaderSpi() {
super(
"Luciad",
"1.0",
new String[]{ "WebP", "webp" },
new String[]{ "webp" },
new String[]{ "image/webp" },
WebPReader.class.getName(),
new Class[] { ImageInputStream.class },
new String[]{ WebPImageWriterSpi.class.getName() },
false,
null,
null,
null,
null,
false,
null,
null,
null,
null
);
}
@Override
public ImageReader createReaderInstance( Object extension ) throws IOException {
return new WebPReader( this );
}
@Override
public boolean canDecodeInput( Object source ) throws IOException {
if ( !( source instanceof ImageInputStream ) ) {
return false;
}
ImageInputStream stream = ( ImageInputStream ) source;
byte[] b = new byte[ 4 ];
ByteOrder oldByteOrder = stream.getByteOrder();
stream.mark();
stream.setByteOrder( ByteOrder.LITTLE_ENDIAN );
try {
stream.readFully( b );
if ( !Arrays.equals( b, RIFF ) ) {
return false;
}
long chunkLength = stream.readUnsignedInt();
long streamLength = stream.length();
if ( streamLength != -1 && streamLength != chunkLength + 8 ) {
return false;
}
stream.readFully( b );
if ( !Arrays.equals( b, WEBP ) ) {
return false;
}
stream.readFully( b );
if ( !Arrays.equals( b, VP8_ ) && !Arrays.equals( b, VP8X ) ) {
return false;
}
} finally {
stream.setByteOrder( oldByteOrder );
stream.reset();
}
return true;
}
@Override
public String getDescription( Locale locale ) {
return "WebP Reader";
}
}

View File

@ -0,0 +1,110 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriter;
import javax.imageio.spi.ImageWriterSpi;
import javax.imageio.stream.ImageOutputStream;
import java.awt.color.ColorSpace;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.ComponentSampleModel;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.SampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.io.IOException;
import java.util.Locale;
/**
*
*/
public class WebPImageWriterSpi extends ImageWriterSpi {
public WebPImageWriterSpi() {
super(
"Luciad",
"1.0",
new String[]{ "WebP", "webp" },
new String[]{ "webp" },
new String[]{ "image/webp" },
WebPReader.class.getName(),
new Class[]{ ImageOutputStream.class },
new String[]{ WebPImageReaderSpi.class.getName() },
false,
null,
null,
null,
null,
false,
null,
null,
null,
null
);
}
@Override
public boolean canEncodeImage( ImageTypeSpecifier type ) {
ColorModel colorModel = type.getColorModel();
SampleModel sampleModel = type.getSampleModel();
int transferType = sampleModel.getTransferType();
if ( colorModel instanceof ComponentColorModel ) {
if ( !( sampleModel instanceof ComponentSampleModel ) ) {
return false;
}
if ( transferType != DataBuffer.TYPE_BYTE && transferType != DataBuffer.TYPE_INT ) {
return false;
}
}
else if ( colorModel instanceof DirectColorModel ) {
if ( !( sampleModel instanceof SinglePixelPackedSampleModel ) ) {
return false;
}
if ( transferType != DataBuffer.TYPE_INT ) {
return false;
}
}
ColorSpace colorSpace = colorModel.getColorSpace();
if ( !( colorSpace.isCS_sRGB() ) ) {
return false;
}
int[] sampleSize = sampleModel.getSampleSize();
for ( int i = 0; i < sampleSize.length; i++ ) {
if ( sampleSize[ i ] > 8 ) {
return false;
}
}
return true;
}
@Override
public ImageWriter createWriterInstance( Object extension ) throws IOException {
return new WebPWriter( this );
}
@Override
public String getDescription( Locale locale ) {
return "WebP Writer";
}
}

View File

@ -0,0 +1,200 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.ImageReadParam;
public final class WebPReadParam extends ImageReadParam {
static {
WebP.loadNativeLibrary();
}
long fPointer;
public WebPReadParam() {
fPointer = createDecoderOptions();
if ( fPointer == 0 ) {
throw new OutOfMemoryError();
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
deleteDecoderOptions( fPointer );
fPointer = 0L;
}
public int getCropHeight() {
return getCropHeight( fPointer );
}
public void setCropHeight( int aCropHeight ) {
setCropHeight( fPointer, aCropHeight );
}
public int getCropLeft() {
return getCropLeft( fPointer );
}
public void setCropLeft( int aCropLeft ) {
setCropLeft( fPointer, aCropLeft );
}
public int getCropTop() {
return getCropTop( fPointer );
}
public void setCropTop( int aCropTop ) {
setCropTop( fPointer, aCropTop );
}
public int getCropWidth() {
return getCropWidth( fPointer );
}
public void setCropWidth( int aCropWidth ) {
setCropWidth( fPointer, aCropWidth );
}
public boolean isForceRotation() {
return isForceRotation( fPointer );
}
public void setForceRotation( boolean aForceRotation ) {
setForceRotation( fPointer, aForceRotation );
}
public boolean isEnhancement() {
return !isNoEnhancement( fPointer );
}
public void setEnhancement( boolean aEnhancement ) {
setNoEnhancement( fPointer, !aEnhancement );
}
public boolean isFancyUpsampling() {
return !isNoFancyUpsampling( fPointer );
}
public void setFancyUpsampling( boolean aFancyUpsampling ) {
setNoFancyUpsampling( fPointer, !aFancyUpsampling );
}
public int getScaledHeight() {
return getScaledHeight( fPointer );
}
public void setScaledHeight( int aScaledHeight ) {
setScaledHeight( fPointer, aScaledHeight );
}
public int getScaledWidth() {
return getScaledWidth( fPointer );
}
public void setScaledWidth( int aScaledWidth ) {
setScaledWidth( fPointer, aScaledWidth );
}
public boolean isUseCropping() {
return isUseCropping( fPointer );
}
public void setUseCropping( boolean aUseCropping ) {
setUseCropping( fPointer, aUseCropping );
}
public boolean isUseScaling() {
return isUseScaling( fPointer );
}
public void setUseScaling( boolean aUseScaling ) {
setUseScaling( fPointer, aUseScaling );
}
public boolean isUseThreads() {
return isUseThreads( fPointer );
}
public void setUseThreads( boolean aUseThreads ) {
setUseThreads( fPointer, aUseThreads );
}
public boolean isBypassFiltering() {
return isBypassFiltering( fPointer );
}
public void setBypassFiltering( boolean aBypassFiltering ) {
setBypassFiltering( fPointer, aBypassFiltering );
}
private static native long createDecoderOptions();
private static native void deleteDecoderOptions( long aPointer );
private static native int getCropHeight( long aPointer );
private static native void setCropHeight( long aPointer, int aCropHeight );
private static native int getCropLeft( long aPointer );
private static native void setCropLeft( long aPointer, int aCropLeft );
private static native int getCropTop( long aPointer );
private static native void setCropTop( long aPointer, int aCropTop );
private static native int getCropWidth( long aPointer );
private static native void setCropWidth( long aPointer, int aCropWidth );
private static native boolean isForceRotation( long aPointer );
private static native void setForceRotation( long aPointer, boolean aForceRotation );
private static native boolean isNoEnhancement( long aPointer );
private static native void setNoEnhancement( long aPointer, boolean aNoEnhancement );
private static native boolean isNoFancyUpsampling( long aPointer );
private static native void setNoFancyUpsampling( long aPointer, boolean aFancyUpsampling );
private static native int getScaledHeight( long aPointer );
private static native void setScaledHeight( long aPointer, int aScaledHeight );
private static native int getScaledWidth( long aPointer );
private static native void setScaledWidth( long aPointer, int aScaledWidth );
private static native boolean isUseCropping( long aPointer );
private static native void setUseCropping( long aPointer, boolean aUseCropping );
private static native boolean isUseScaling( long aPointer );
private static native void setUseScaling( long aPointer, boolean aUseScaling );
private static native boolean isUseThreads( long aPointer );
private static native void setUseThreads( long aPointer, boolean aUseThreads );
private static native boolean isBypassFiltering( long aPointer );
private static native void setBypassFiltering( long aPointer, boolean aBypassFiltering );
}

View File

@ -0,0 +1,151 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.stream.ImageInputStream;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
class WebPReader extends ImageReader {
private byte[] fData;
private int fWidth;
private int fHeight;
WebPReader( ImageReaderSpi originatingProvider ) {
super( originatingProvider );
}
@Override
public void setInput( Object input, boolean seekForwardOnly, boolean ignoreMetadata ) {
super.setInput( input, seekForwardOnly, ignoreMetadata );
fData = null;
fWidth = -1;
fHeight = -1;
}
@Override
public int getNumImages( boolean allowSearch ) throws IOException {
return 1;
}
private void readHeader() throws IOException {
if ( fWidth != -1 && fHeight != -1 ) {
return;
}
readData();
int[] info = WebP.getInfo( fData, 0, fData.length );
fWidth = info[ 0 ];
fHeight = info[ 1 ];
}
private void readData() throws IOException {
if ( fData != null ) {
return;
}
ImageInputStream input = ( ImageInputStream ) getInput();
long length = input.length();
if ( length > Integer.MAX_VALUE ) {
throw new IOException( "Cannot read image of size " + length );
}
if ( input.getStreamPosition() != 0L ) {
if ( isSeekForwardOnly() ) {
throw new IOException();
}
else {
input.seek( 0 );
}
}
byte[] data;
if ( length > 0 ) {
data = new byte[ ( int ) length ];
input.readFully( data );
}
else {
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[ 4096 ];
int bytesRead;
while ( ( bytesRead = input.read( buffer ) ) != -1 ) {
out.write( buffer, 0, bytesRead );
}
out.close();
data = out.toByteArray();
}
fData = data;
}
private void checkIndex( int imageIndex ) {
if ( imageIndex != 0 ) {
throw new IndexOutOfBoundsException( "Invalid image index: " + imageIndex );
}
}
@Override
public int getWidth( int imageIndex ) throws IOException {
checkIndex( imageIndex );
readHeader();
return fWidth;
}
@Override
public int getHeight( int imageIndex ) throws IOException {
checkIndex( imageIndex );
readHeader();
return fHeight;
}
@Override
public IIOMetadata getStreamMetadata() throws IOException {
return null;
}
@Override
public IIOMetadata getImageMetadata( int imageIndex ) throws IOException {
return null;
}
@Override
public Iterator<ImageTypeSpecifier> getImageTypes( int imageIndex ) throws IOException {
return Collections.singletonList(
ImageTypeSpecifier.createFromBufferedImageType( BufferedImage.TYPE_INT_ARGB )
).iterator();
}
@Override
public ImageReadParam getDefaultReadParam() {
return new WebPReadParam();
}
@Override
public BufferedImage read( int imageIndex, ImageReadParam param ) throws IOException {
checkIndex( imageIndex );
readData();
readHeader();
WebPReadParam options = param != null ? (WebPReadParam) param : new WebPReadParam();
return WebP.decode( options, fData, 0, fData.length );
}
}

View File

@ -0,0 +1,337 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.ImageWriteParam;
import java.util.Locale;
public class WebPWriteParam extends ImageWriteParam {
static {
WebP.loadNativeLibrary();
}
long fPointer;
private final int defaultLossless;
public WebPWriteParam( Locale aLocale ) {
super( aLocale );
fPointer = createConfig();
if ( fPointer == 0 ) {
throw new OutOfMemoryError();
}
defaultLossless = getLossless( fPointer );
canWriteCompressed = true;
compressionTypes = new String[]{
"Lossy",
"Lossless"
};
compressionType = compressionTypes[defaultLossless];
compressionQuality = getQuality( fPointer ) / 100f;
compressionMode = MODE_EXPLICIT;
}
@Override
protected void finalize() throws Throwable {
super.finalize();
deleteConfig( fPointer );
fPointer = 0L;
}
private static native long createConfig();
private static native void deleteConfig( long aPointer );
long getPointer() {
return fPointer;
}
@Override
public float getCompressionQuality() {
return super.getCompressionQuality();
}
@Override
public void setCompressionQuality( float quality ) {
super.setCompressionQuality( quality );
setQuality( fPointer, quality * 100f );
}
@Override
public void setCompressionType( String compressionType ) {
super.setCompressionType( compressionType );
for ( int i = 0; i < compressionTypes.length; i++ ) {
if ( compressionTypes[i].equals( compressionType ) ) {
setLossless( fPointer, i );
break;
}
}
}
@Override
public void unsetCompression() {
super.unsetCompression();
setLossless( fPointer, defaultLossless );
}
public int getTargetSize() {
return getTargetSize( fPointer );
}
public void setTargetSize( int aTargetSize ) {
setTargetSize( fPointer, aTargetSize );
}
public float getTargetPSNR() {
return getTargetPSNR( fPointer );
}
public void setTargetPSNR( float aTargetPSNR ) {
setTargetPSNR( fPointer, aTargetPSNR );
}
public int getMethod() {
return getMethod( fPointer );
}
public void setMethod( int aMethod ) {
setMethod( fPointer, aMethod );
}
public int getSegments() {
return getSegments( fPointer );
}
public void setSegments( int aSegments ) {
setSegments( fPointer, aSegments );
}
public int getSnsStrength() {
return getSnsStrength( fPointer );
}
public void setSnsStrength( int aSnsStrength ) {
setSnsStrength( fPointer, aSnsStrength );
}
public int getFilterStrength() {
return getFilterStrength( fPointer );
}
public void setFilterStrength( int aFilterStrength ) {
setFilterStrength( fPointer, aFilterStrength );
}
public int getFilterSharpness() {
return getFilterSharpness( fPointer );
}
public void setFilterSharpness( int aFilterSharpness ) {
setFilterSharpness( fPointer, aFilterSharpness );
}
public int getFilterType() {
return getFilterType( fPointer );
}
public void setFilterType( int aFilterType ) {
setFilterType( fPointer, aFilterType );
}
public boolean isAutoAdjustFilterStrength() {
return getAutofilter( fPointer ) != 0;
}
public void setAutoAdjustFilterStrength( boolean aAutofilter ) {
setAutofilter( fPointer, aAutofilter ? 1 : 0 );
}
public int getEntropyAnalysisPassCount() {
return getPass( fPointer );
}
public void setEntropyAnalysisPassCount( int aPass ) {
setPass( fPointer, aPass );
}
public boolean isShowCompressed() {
return getShowCompressed( fPointer ) != 0;
}
public void setShowCompressed( boolean aShowCompressed ) {
setShowCompressed( fPointer, aShowCompressed ? 1 : 0 );
}
public int getPreprocessing() {
return getPreprocessing( fPointer );
}
public void setPreprocessing( int aPreprocessing ) {
setPreprocessing( fPointer, aPreprocessing );
}
public int getPartitions() {
return getPartitions( fPointer );
}
public void setPartitions( int aPartitions ) {
setPartitions( fPointer, aPartitions );
}
public int getPartitionLimit() {
return getPartitionLimit( fPointer );
}
public void setPartitionLimit( int aPartitionLimit ) {
setPartitionLimit( fPointer, aPartitionLimit );
}
public int getAlphaCompression() {
return getAlphaCompression( fPointer );
}
public void setAlphaCompression( int aAlphaCompression ) {
setAlphaCompression( fPointer, aAlphaCompression );
}
public int getAlphaFiltering() {
return getAlphaFiltering( fPointer );
}
public void setAlphaFiltering( int aAlphaFiltering ) {
setAlphaFiltering( fPointer, aAlphaFiltering );
}
public int getAlphaQuality() {
return getAlphaQuality( fPointer );
}
public void setAlphaQuality( int aAlphaQuality ) {
setAlphaQuality( fPointer, aAlphaQuality );
}
public boolean isEmulateJpegSize() {
return getEmulateJpegSize( fPointer ) != 0;
}
public void setEmulateJpegSize( boolean aEmulateJpegSize ) {
setEmulateJpegSize( fPointer, aEmulateJpegSize ? 1 : 0 );
}
public int getThreadLevel() {
return getThreadLevel( fPointer );
}
public void setThreadLevel( int aThreadLevel ) {
setThreadLevel( fPointer, aThreadLevel );
}
public boolean isReduceMemoryUsage() {
return getLowMemory( fPointer ) != 0;
}
public void setReduceMemoryUsage( boolean aLowMemory ) {
setLowMemory( fPointer, aLowMemory ? 1 : 0 );
}
private static native float getQuality( long aPointer );
private static native void setQuality( long aPointer, float aQuality );
private static native int getTargetSize( long aPointer );
private static native void setTargetSize( long aPointer, int aTargetSize );
private static native float getTargetPSNR( long aPointer );
private static native void setTargetPSNR( long aPointer, float aTargetPSNR );
private static native int getMethod( long aPointer );
private static native void setMethod( long aPointer, int aMethod );
private static native int getSegments( long aPointer );
private static native void setSegments( long aPointer, int aSegments );
private static native int getSnsStrength( long aPointer );
private static native void setSnsStrength( long aPointer, int aSnsStrength );
private static native int getFilterStrength( long aPointer );
private static native void setFilterStrength( long aPointer, int aFilterStrength );
private static native int getFilterSharpness( long aPointer );
private static native void setFilterSharpness( long aPointer, int aFilterSharpness );
private static native int getFilterType( long aPointer );
private static native void setFilterType( long aPointer, int aFilterType );
private static native int getAutofilter( long aPointer );
private static native void setAutofilter( long aPointer, int aAutofilter );
private static native int getPass( long aPointer );
private static native void setPass( long aPointer, int aPass );
private static native int getShowCompressed( long aPointer );
private static native void setShowCompressed( long aPointer, int aShowCompressed );
private static native int getPreprocessing( long aPointer );
private static native void setPreprocessing( long aPointer, int aPreprocessing );
private static native int getPartitions( long aPointer );
private static native void setPartitions( long aPointer, int aPartitions );
private static native int getPartitionLimit( long aPointer );
private static native void setPartitionLimit( long aPointer, int aPartitionLimit );
private static native int getAlphaCompression( long aPointer );
private static native void setAlphaCompression( long aPointer, int aAlphaCompression );
private static native int getAlphaFiltering( long aPointer );
private static native void setAlphaFiltering( long aPointer, int aAlphaFiltering );
private static native int getAlphaQuality( long aPointer );
private static native void setAlphaQuality( long aPointer, int aAlphaQuality );
private static native int getLossless( long aPointer );
private static native void setLossless( long aPointer, int aLossless );
private static native int getEmulateJpegSize( long aPointer );
private static native void setEmulateJpegSize( long aPointer, int aEmulateJpegSize );
private static native int getThreadLevel( long aPointer );
private static native void setThreadLevel( long aPointer, int aThreadLevel );
private static native int getLowMemory( long aPointer );
private static native void setLowMemory( long aPointer, int aLowMemory );
}

View File

@ -0,0 +1,72 @@
/*
* Copyright 2013 Luciad (http://www.luciad.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.luciad.imageio.webp;
import javax.imageio.IIOImage;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.spi.ImageWriterSpi;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.RenderedImage;
import java.io.IOException;
class WebPWriter extends ImageWriter {
WebPWriter( ImageWriterSpi originatingProvider ) {
super( originatingProvider );
}
@Override
public ImageWriteParam getDefaultWriteParam() {
return new WebPWriteParam( getLocale() );
}
@Override
public IIOMetadata convertImageMetadata( IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param ) {
return null;
}
@Override
public IIOMetadata convertStreamMetadata( IIOMetadata inData, ImageWriteParam param ) {
return null;
}
@Override
public IIOMetadata getDefaultImageMetadata( ImageTypeSpecifier imageType, ImageWriteParam param ) {
return null;
}
@Override
public IIOMetadata getDefaultStreamMetadata( ImageWriteParam param ) {
return null;
}
@Override
public void write( IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param ) throws IOException {
if ( param == null ) {
param = getDefaultWriteParam();
}
WebPWriteParam writeParam = (WebPWriteParam) param;
ImageOutputStream output = ( ImageOutputStream ) getOutput();
RenderedImage ri = image.getRenderedImage();
byte[] encodedData = WebP.encode(writeParam, ri);
output.write( encodedData );
}
}

View File

@ -0,0 +1,38 @@
package example;
import com.luciad.imageio.webp.WebPReadParam;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class DecodingTest {
public static void main(String args[]) throws IOException {
String inputWebpPath = "test_pic/test.webp";
String outputJpgPath = "test_pic/test_.jpg";
String outputJpegPath = "test_pic/test_.jpeg";
String outputPngPath = "test_pic/test_.png";
// Obtain a WebP ImageReader instance
ImageReader reader = ImageIO.getImageReadersByMIMEType("image/webp").next();
// Configure decoding parameters
WebPReadParam readParam = new WebPReadParam();
readParam.setBypassFiltering(true);
// Configure the input on the ImageReader
reader.setInput(new FileImageInputStream(new File(inputWebpPath)));
// Decode the image
BufferedImage image = reader.read(0, readParam);
ImageIO.write(image, "png", new File(outputPngPath));
ImageIO.write(image, "jpg", new File(outputJpgPath));
ImageIO.write(image, "jpeg", new File(outputJpegPath));
}
}

View File

@ -0,0 +1,36 @@
package example;
import com.luciad.imageio.webp.WebPWriteParam;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.stream.FileImageOutputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class EncodingTest {
public static void main(String args[]) throws IOException {
String inputPngPath = "test_pic/test.png";
String inputJpgPath = "test_pic/test.jpg";
String outputWebpPath = "test_pic/test_.webp";
// Obtain an image to encode from somewhere
BufferedImage image = ImageIO.read(new File(inputJpgPath));
// Obtain a WebP ImageWriter instance
ImageWriter writer = ImageIO.getImageWritersByMIMEType("image/webp").next();
// Configure encoding parameters
WebPWriteParam writeParam = new WebPWriteParam(writer.getLocale());
writeParam.setCompressionMode(WebPWriteParam.MODE_DEFAULT);
// Configure the output on the ImageWriter
writer.setOutput(new FileImageOutputStream(new File(outputWebpPath)));
// Encode
writer.write(null, new IIOImage(image, null, null), writeParam);
}
}

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -0,0 +1 @@
com.luciad.imageio.webp.WebPImageReaderSpi

View File

@ -0,0 +1 @@
com.luciad.imageio.webp.WebPImageWriterSpi

BIN
test_pic/test.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 27 KiB

BIN
test_pic/test.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 29 KiB

BIN
test_pic/test.webp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 10 KiB