jdk/src/java.desktop/share/classes/com/sun/imageio/plugins/gif/GIFImageWriter.java
changeset 41403 be56daafbeaa
parent 35667 ed476aba94de
child 41784 c1e614077765
equal deleted inserted replaced
41402:9ff91b2cd7a7 41403:be56daafbeaa
     1 /*
     1 /*
     2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.  Oracle designates this
     7  * published by the Free Software Foundation.  Oracle designates this
   572     private void write(boolean writeHeader,
   572     private void write(boolean writeHeader,
   573                        boolean writeTrailer,
   573                        boolean writeTrailer,
   574                        IIOMetadata sm,
   574                        IIOMetadata sm,
   575                        IIOImage iioimage,
   575                        IIOImage iioimage,
   576                        ImageWriteParam p) throws IOException {
   576                        ImageWriteParam p) throws IOException {
   577         clearAbortRequest();
       
   578 
   577 
   579         RenderedImage image = iioimage.getRenderedImage();
   578         RenderedImage image = iioimage.getRenderedImage();
   580 
   579 
   581         // Check for ability to encode image.
   580         // Check for ability to encode image.
   582         if (needToCreateIndex(image)) {
   581         if (needToCreateIndex(image)) {
   827         Raster raster =
   826         Raster raster =
   828             image.getNumXTiles() == 1 && image.getNumYTiles() == 1 ?
   827             image.getNumXTiles() == 1 && image.getNumYTiles() == 1 ?
   829             image.getTile(0, 0) : image.getData();
   828             image.getTile(0, 0) : image.getData();
   830         for (int y = dy; y < dh; y += ddy) {
   829         for (int y = dy; y < dh; y += ddy) {
   831             if (numRowsWritten % progressReportRowPeriod == 0) {
   830             if (numRowsWritten % progressReportRowPeriod == 0) {
       
   831                 processImageProgress((numRowsWritten*100.0F)/dh);
   832                 if (abortRequested()) {
   832                 if (abortRequested()) {
   833                     processWriteAborted();
   833                     processWriteAborted();
   834                     return;
   834                     return;
   835                 }
   835                 }
   836                 processImageProgress((numRowsWritten*100.0F)/dh);
       
   837             }
   836             }
   838 
   837 
   839             raster.getSamples(sx, sy, sw, 1, 0, sbuf);
   838             raster.getSamples(sx, sy, sw, 1, 0, sbuf);
   840             for (int i = 0, j = 0; i < dw; i++, j += sdx) {
   839             for (int i = 0, j = 0; i < dw; i++, j += sdx) {
   841                 dbuf[i] = (byte)sbuf[j];
   840                 dbuf[i] = (byte)sbuf[j];
   855 
   854 
   856         offset += dy*lineStride;
   855         offset += dy*lineStride;
   857         lineStride *= ddy;
   856         lineStride *= ddy;
   858         for (int y = dy; y < dh; y += ddy) {
   857         for (int y = dy; y < dh; y += ddy) {
   859             if (numRowsWritten % progressReportRowPeriod == 0) {
   858             if (numRowsWritten % progressReportRowPeriod == 0) {
       
   859                 processImageProgress((numRowsWritten*100.0F)/dh);
   860                 if (abortRequested()) {
   860                 if (abortRequested()) {
   861                     processWriteAborted();
   861                     processWriteAborted();
   862                     return;
   862                     return;
   863                 }
   863                 }
   864                 processImageProgress((numRowsWritten*100.0F)/dh);
       
   865             }
   864             }
   866 
   865 
   867             compressor.compress(data, offset, dw);
   866             compressor.compress(data, offset, dw);
   868             numRowsWritten++;
   867             numRowsWritten++;
   869             offset += lineStride;
   868             offset += lineStride;
   922 
   921 
   923         int numRowsWritten = 0;
   922         int numRowsWritten = 0;
   924 
   923 
   925         int progressReportRowPeriod = Math.max(destHeight/20, 1);
   924         int progressReportRowPeriod = Math.max(destHeight/20, 1);
   926 
   925 
       
   926         clearAbortRequest();
   927         processImageStarted(imageIndex);
   927         processImageStarted(imageIndex);
       
   928         if (abortRequested()) {
       
   929             processWriteAborted();
       
   930             return;
       
   931         }
   928 
   932 
   929         if (interlaceFlag) {
   933         if (interlaceFlag) {
   930             if (DEBUG) System.out.println("Writing interlaced");
   934             if (DEBUG) System.out.println("Writing interlaced");
   931 
   935 
   932             if (isOptimizedCase) {
   936             if (isOptimizedCase) {
   971                 numRowsWritten += (destHeight - 2)/4;
   975                 numRowsWritten += (destHeight - 2)/4;
   972 
   976 
   973                 writeRowsOpt(data, offset, lineStride, compressor,
   977                 writeRowsOpt(data, offset, lineStride, compressor,
   974                              1, 2, destWidth, destHeight,
   978                              1, 2, destWidth, destHeight,
   975                              numRowsWritten, progressReportRowPeriod);
   979                              numRowsWritten, progressReportRowPeriod);
       
   980                 if (abortRequested()) {
       
   981                     return;
       
   982                 }
   976             } else {
   983             } else {
   977                 writeRows(image, compressor,
   984                 writeRows(image, compressor,
   978                           sourceXOffset, periodX,
   985                           sourceXOffset, periodX,
   979                           sourceYOffset, 8*periodY,
   986                           sourceYOffset, 8*periodY,
   980                           sourceWidth,
   987                           sourceWidth,
  1014                 writeRows(image, compressor, sourceXOffset, periodX,
  1021                 writeRows(image, compressor, sourceXOffset, periodX,
  1015                           sourceYOffset + periodY, 2*periodY,
  1022                           sourceYOffset + periodY, 2*periodY,
  1016                           sourceWidth,
  1023                           sourceWidth,
  1017                           1, 2, destWidth, destHeight,
  1024                           1, 2, destWidth, destHeight,
  1018                           numRowsWritten, progressReportRowPeriod);
  1025                           numRowsWritten, progressReportRowPeriod);
       
  1026                 if (abortRequested()) {
       
  1027                     return;
       
  1028                 }
  1019             }
  1029             }
  1020         } else {
  1030         } else {
  1021             if (DEBUG) System.out.println("Writing non-interlaced");
  1031             if (DEBUG) System.out.println("Writing non-interlaced");
  1022 
  1032 
  1023             if (isOptimizedCase) {
  1033             if (isOptimizedCase) {
  1029                 int lineStride = csm.getScanlineStride();
  1039                 int lineStride = csm.getScanlineStride();
  1030 
  1040 
  1031                 writeRowsOpt(data, offset, lineStride, compressor,
  1041                 writeRowsOpt(data, offset, lineStride, compressor,
  1032                              0, 1, destWidth, destHeight,
  1042                              0, 1, destWidth, destHeight,
  1033                              numRowsWritten, progressReportRowPeriod);
  1043                              numRowsWritten, progressReportRowPeriod);
       
  1044                 if (abortRequested()) {
       
  1045                     return;
       
  1046                 }
  1034             } else {
  1047             } else {
  1035                 writeRows(image, compressor,
  1048                 writeRows(image, compressor,
  1036                           sourceXOffset, periodX,
  1049                           sourceXOffset, periodX,
  1037                           sourceYOffset, periodY,
  1050                           sourceYOffset, periodY,
  1038                           sourceWidth,
  1051                           sourceWidth,
  1039                           0, 1, destWidth, destHeight,
  1052                           0, 1, destWidth, destHeight,
  1040                           numRowsWritten, progressReportRowPeriod);
  1053                           numRowsWritten, progressReportRowPeriod);
  1041             }
  1054                 if (abortRequested()) {
  1042         }
  1055                     return;
  1043 
  1056                 }
  1044         if (abortRequested()) {
  1057             }
  1045             return;
  1058         }
  1046         }
       
  1047 
       
  1048         processImageProgress(100.0F);
       
  1049 
  1059 
  1050         compressor.flush();
  1060         compressor.flush();
  1051 
  1061 
  1052         stream.write(0x00);
  1062         stream.write(0x00);
  1053 
  1063