下面列出了javax.imageio.spi.ImageReaderSpi#createReaderInstance ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Retrieves a JPEG reader which supports native JPEG stream metadata.
*/
private static ImageReader getJPEGTablesReader() {
ImageReader jpegReader = null;
try {
IIORegistry registry = IIORegistry.getDefaultInstance();
Iterator<?> readerSPIs =
registry.getServiceProviders(ImageReaderSpi.class,
new JPEGSPIFilter(),
true);
if(readerSPIs.hasNext()) {
ImageReaderSpi jpegReaderSPI =
(ImageReaderSpi)readerSPIs.next();
jpegReader = jpegReaderSPI.createReaderInstance();
}
} catch(Exception e) {
// Ignore it ...
}
return jpegReader;
}
/**
* Retrieves a JPEG reader which supports native JPEG stream metadata.
*/
private static ImageReader getJPEGTablesReader() {
ImageReader jpegReader = null;
try {
IIORegistry registry = IIORegistry.getDefaultInstance();
Iterator<?> readerSPIs =
registry.getServiceProviders(ImageReaderSpi.class,
new JPEGSPIFilter(),
true);
if(readerSPIs.hasNext()) {
ImageReaderSpi jpegReaderSPI =
(ImageReaderSpi)readerSPIs.next();
jpegReader = jpegReaderSPI.createReaderInstance();
}
} catch(Exception e) {
// Ignore it ...
}
return jpegReader;
}
public ImageReader next() {
ImageReaderSpi spi = null;
try {
spi = iter.next();
return spi.createReaderInstance();
} catch (IOException e) {
// Deregister the spi in this case, but only as
// an ImageReaderSpi
theRegistry.deregisterServiceProvider(spi, ImageReaderSpi.class);
}
return null;
}
public ImageReader next() {
ImageReaderSpi spi = null;
try {
spi = iter.next();
return spi.createReaderInstance();
} catch (IOException e) {
// Deregister the spi in this case, but only as
// an ImageReaderSpi
theRegistry.deregisterServiceProvider(spi, ImageReaderSpi.class);
}
return null;
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}
Context(TestEnvironment env, Result result, int testType) {
super(env, result);
String content = (String)env.getModifier(contentList);
if (content == null) {
content = CONTENT_BLANK;
}
// REMIND: add option for non-opaque images
image = createBufferedImage(size, size, content, false);
result.setUnits(size*size);
result.setUnitName("pixel");
if (testType == TEST_IMAGEIO || testType == TEST_IMAGEREADER) {
ImageReaderSpi readerspi =
(ImageReaderSpi)env.getModifier(imageioReadFormatList);
format = readerspi.getFileSuffixes()[0].toLowerCase();
if (testType == TEST_IMAGEREADER) {
seekForwardOnly = env.isEnabled(seekForwardOnlyTog);
ignoreMetadata = env.isEnabled(ignoreMetadataTog);
try {
reader = readerspi.createReaderInstance();
} catch (IOException e) {
System.err.println("error creating reader");
e.printStackTrace();
}
if (env.isEnabled(installListenerTog)) {
reader.addIIOReadProgressListener(
new ReadProgressListener());
}
}
if (format.equals("wbmp")) {
// REMIND: this is a hack to create an image that the
// WBMPImageWriter can handle (a better approach
// would involve checking the ImageTypeSpecifier
// of the writer's default image param)
BufferedImage newimg =
new BufferedImage(size, size,
BufferedImage.TYPE_BYTE_BINARY);
Graphics g = newimg.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
image = newimg;
}
} else if (testType == TEST_TOOLKIT) {
format = (String)env.getModifier(toolkitReadFormatList);
} else { // testType == TEST_JPEGCODEC
format = "jpeg";
}
initInput();
}