diff --git a/src/main/java/org/saturnclient/cosmetics/Cloaks.java b/src/main/java/org/saturnclient/cosmetics/Cloaks.java new file mode 100644 index 0000000..82a0d77 --- /dev/null +++ b/src/main/java/org/saturnclient/cosmetics/Cloaks.java @@ -0,0 +1,256 @@ +package org.saturnclient.cosmetics; + +import org.saturnclient.client.ServiceClient; +import org.saturnclient.client.player.SaturnPlayer; +import org.saturnclient.common.provider.Providers; +import org.saturnclient.common.ref.asset.IdentifierRef; + +import javax.imageio.ImageIO; +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.io.InputStream; +import java.util.*; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import org.saturnclient.cosmetics.utils.AnimatedCloakData; +import org.saturnclient.cosmetics.utils.GifDecoder; +// import org.saturnclient.cosmetics.utils.IdentifierUtils; + +/** + * Manages the cloak system for Saturn Client. + * Handles loading and caching of player cloaks. + * Originally created by IIpho3nix and modified for Saturn Client by leo. + */ +public class Cloaks { + public static final String[] ALL_CLOAKS = { "glitch", "mercedes_flow", "crimson_mark", "bmw", "amg", "amg_petronas", + "ferrari", "redbull", "black_hole_amethyst", "black_hole_flame", "black_hole_white" }; + private static final String[] ANIMATED_CLOAKS = { "glitch", "black_hole_amethyst", "black_hole_flame", + "black_hole_white" }; + + private static final String CLOAKS_RESOURCE_PATH = "assets/saturnclient/textures/cloaks/"; + public static final List availableCloaks = new ArrayList<>(); + public static IdentifierRef cloakCacheIdentifier = null; + public static final Map> animatedCloaks = new ConcurrentHashMap<>(); + private static final Map lastFrameTime = new ConcurrentHashMap<>(); + + private static final ExecutorService CLOAK_LOADER_EXECUTOR = Executors.newFixedThreadPool( + Math.min(4, Runtime.getRuntime().availableProcessors()), + r -> { + Thread t = new Thread(r, "cloak-loader"); + t.setDaemon(true); + t.setPriority(Thread.NORM_PRIORITY - 1); + return t; + }); + + private static final ConcurrentHashMap> CLOAK_CACHE = new ConcurrentHashMap<>(); + + /** + * Initializes the cloak system. + * Loads cloak textures from resources. + */ + public static void initialize() { + availableCloaks.add(0, ""); + } + + /** + * Sets cloak of the current player + * + * @param cloakName Name of the cloak file to load + */ + public static void setCloak(String cloakName) { + if (availableCloaks.contains(cloakName)) { + setCloak(ServiceClient.uuid, cloakName); + ServiceClient.setCloak(cloakName); + } + } + + /** + * Handles loading and caching of a new cloak texture, without connecting to the + * server. + * + * @param cloakName Name of the cloak file to load + */ + public static void setCloak(UUID uuid, String cloakName) { + SaturnPlayer player = SaturnPlayer.get(uuid); + + if (player != null) { + player.cloak = cloakName; + } + + loadCloak(uuid); + } + + /** + * Handles loading and caching of a new cloak texture, without connecting to the + * server. + * + * @param cloakName Name of the cloak file to load + */ + public static void loadCloak(UUID uuid) { + SaturnPlayer player = SaturnPlayer.get(uuid); + + if (player != null && player.cloak != null) { + if (!player.cloak.isEmpty()) { + if (Arrays.asList(ANIMATED_CLOAKS).contains(player.cloak)) { + loadAnimatedCloakAsync(uuid, player.cloak) + .exceptionally(throwable -> { + Providers.saturn.logError("Failed to load animated cloak for player: " + player.cloak, + throwable); + return null; + }); + + } else { + // SaturnClient.client.execute(() -> loadStaticCloak(player.cloak + ".png")); + } + } + } + } + + /** + * Loads and processes a static cloak from a PNG file in resources. + * + * @param fileName Name of the PNG file to load + */ + private static void loadStaticCloak(String fileName) { + try { + String resourcePath = CLOAKS_RESOURCE_PATH + fileName; + InputStream inputStream = Cloaks.class.getClassLoader().getResourceAsStream(resourcePath); + + if (inputStream != null) { + BufferedImage image = ImageIO.read(inputStream); + + // Add debug logging for static cloak + Providers.saturn.logInfo("Static cloak dimensions: " + image.getWidth() + "x" + image.getHeight()); + + String safeFileName = fileName.toLowerCase(Locale.ROOT) + .replace(' ', '_') + .replaceAll("[^a-z0-9/._-]", ""); + + cloakCacheIdentifier = IdentifierRef.ofSaturn("cloaks_" + safeFileName); + Providers.saturn.registerBufferedImageTexture(cloakCacheIdentifier, image); + } + } catch (IOException e) { + Providers.saturn.logError("Failed to load static cloak from resources: " + fileName, e); + } + } + + public static CompletableFuture loadAnimatedCloakAsync(UUID uuid, String cloakName) { + return CompletableFuture.runAsync(() -> { + String fileName = cloakName + ".gif"; + + // Check cache first + List cached = CLOAK_CACHE.get(fileName); + if (cached != null) { + animatedCloaks.put(uuid, cached); + lastFrameTime.put(uuid, System.currentTimeMillis()); + return; + } + + String resourcePath = CLOAKS_RESOURCE_PATH + fileName; + + try (InputStream inputStream = Cloaks.class.getClassLoader().getResourceAsStream(resourcePath)) { + if (inputStream == null) { + Providers.saturn.logError("Cloak resource not found: " + resourcePath); + return; + } + + // Read all bytes at once - more efficient than multiple reads + byte[] data = inputStream.readAllBytes(); + GifDecoder.GifImage gif = GifDecoder.read(data); + + int frameCount = gif.getFrameCount(); + if (frameCount == 0) { + Providers.saturn.logError("No frames found in animated cloak: " + fileName); + return; + } + + // Pre-allocate collections with known size + List animatedFrames = new ArrayList<>(frameCount); + String baseFrameId = fileName.replace(".gif", ""); + + // Process frames in batch + for (int i = 0; i < frameCount; i++) { + BufferedImage frame = gif.getFrame(i); + int delay = Math.max(gif.getDelay(i) * 10, 50); // Minimum 50ms delay + + String frameId = baseFrameId + "_frame_" + i; + IdentifierRef frameIdentifier = IdentifierRef.ofSaturn("cloaks_" + frameId); + + try { + Providers.saturn.registerBufferedImageTexture(frameIdentifier, frame); + animatedFrames.add(new AnimatedCloakData(frameIdentifier, delay)); + } catch (Exception e) { + Providers.saturn.logError("Failed to register frame " + i + " for cloak: " + fileName, e); + // Continue with other frames instead of failing completely + } + } + + if (!animatedFrames.isEmpty()) { + // Cache the result for future use + CLOAK_CACHE.put(fileName, animatedFrames); + animatedCloaks.put(uuid, animatedFrames); + lastFrameTime.put(uuid, System.currentTimeMillis()); + + Providers.saturn.logInfo("Loaded " + animatedFrames.size() + " frames for animated cloak: " + + fileName + " (cached)"); + } else { + Providers.saturn.logError("No valid frames could be loaded for cloak: " + fileName); + } + + } catch (IOException e) { + Providers.saturn.logError("Failed to load animated cloak from resources: " + fileName, e); + } catch (Exception e) { + Providers.saturn.logError("Unexpected error loading animated cloak: " + fileName, e); + } + }, CLOAK_LOADER_EXECUTOR); + } + + public static IdentifierRef getCurrentCloakTexture(UUID uuid) { + SaturnPlayer player = SaturnPlayer.get(uuid); + + if (player == null || player.cloak.isEmpty()) { + return null; + } + + String cloakName = player.cloak; + + if (Arrays.asList(ANIMATED_CLOAKS).contains(cloakName)) { + List frames = animatedCloaks.get(uuid); + if (frames == null || frames.isEmpty()) { + return null; + } + + long currentTime = System.currentTimeMillis(); + long lastTime = lastFrameTime.getOrDefault(uuid, currentTime); + int currentFrame = 0; + + long elapsedTime = currentTime - lastTime; + long totalTime = 0; + for (int i = 0; i < frames.size(); i++) { + totalTime += frames.get(i).getDelayMs(); + if (elapsedTime < totalTime) { + currentFrame = i; + break; + } + } + + if (elapsedTime >= totalTime) { + lastFrameTime.put(uuid, currentTime); + currentFrame = 0; + } + + IdentifierRef identifier = frames.get(currentFrame).getTextureId(); + + if (identifier == null) { + return IdentifierRef.ofSaturn("textures/cloaks/" + cloakName + ".png"); + } + + return identifier; + } else { + return IdentifierRef.ofSaturn("textures/cloaks/" + cloakName + ".png"); + } + } +} \ No newline at end of file diff --git a/src/main/java/org/saturnclient/cosmetics/utils/GifDecoder.java b/src/main/java/org/saturnclient/cosmetics/utils/GifDecoder.java new file mode 100644 index 0000000..2b57a84 --- /dev/null +++ b/src/main/java/org/saturnclient/cosmetics/utils/GifDecoder.java @@ -0,0 +1,791 @@ +package org.saturnclient.cosmetics.utils; + +import java.awt.*; +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferInt; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/* + * Copyright 2014 Dhyan Blum + * + * 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. + */ + +/** + *

+ * A thread-safe decoder capable of processing a GIF data stream to render the graphics + * contained in it. This implementation follows the official + * GIF + * specification. + *

+ * + *

+ * Example usage: + *

+ * + *

+ * + * 

+ * final GifImage gifImage = GifDecoder.read(int[] data);
+ * final int width = gifImage.getWidth();
+ * final int height = gifImage.getHeight();
+ * final int frameCount = gifImage.getFrameCount();
+ * for (int i = 0; i < frameCount; i++) {
+ * 	final BufferedImage image = gifImage.getFrame(i);
+ * 	final int delay = gif.getDelay(i);
+ * }
+ *
+ * + *

+ * + * @author Dhyan Blum + * @version 1.09 November 2017 (Thread-safe version) + */ +public final class GifDecoder { + + // Thread-local storage for reusable objects to avoid synchronization overhead + private static final ThreadLocal DECODING_CONTEXT = + ThreadLocal.withInitial(DecodingContext::new); + + /** + * Thread-local context containing reusable objects for decoding operations. + * This eliminates the need for synchronization while maintaining performance benefits + * of object reuse within each thread. + */ + static final class DecodingContext { + final BitReader bitReader = new BitReader(); + final CodeTable codeTable = new CodeTable(); + int[] pixelBuffer; + int[] prevPixelBuffer; + int[] tempBuffer; + + // Get or create a pixel buffer of the specified size + int[] getPixelBuffer(int size) { + if (pixelBuffer == null || pixelBuffer.length < size) { + pixelBuffer = new int[Math.max(size, 1024)]; // Minimum size to reduce allocations + } + return pixelBuffer; + } + + // Get or create a previous pixel buffer of the specified size + int[] getPrevPixelBuffer(int size) { + if (prevPixelBuffer == null || prevPixelBuffer.length < size) { + prevPixelBuffer = new int[Math.max(size, 1024)]; + } + return prevPixelBuffer; + } + + // Get or create a temporary buffer of the specified size + int[] getTempBuffer(int size) { + if (tempBuffer == null || tempBuffer.length < size) { + tempBuffer = new int[Math.max(size, 1024)]; + } + return tempBuffer; + } + } + + static final class BitReader { + private int nextBitToRead; + private int numberOfBitsToRead; + private int bitMask; // Used to kill unwanted higher bits + private byte[] bytes; // Data array + + // To avoid costly bounds checks, 'in' needs 2 more 0-bytes at the end + private void init(final byte[] bytes) { + this.bytes = bytes; + nextBitToRead = 0; + } + + private int read() { + // Byte indices: (bitPos / 8), (bitPos / 8) + 1, (bitPos / 8) + 2 + final int byteIndex = nextBitToRead >>> 3; // Byte = bit / 8 + final int bitsToShiftRight = nextBitToRead & 7; // & 7 is the same as MODULO 8 + + // Use int operations to avoid repeated array access + final int byte0 = bytes[byteIndex] & 0xFF; + final int byte1 = bytes[byteIndex + 1] & 0xFF; + final int byte2 = bytes[byteIndex + 2] & 0xFF; + + // Optimized bit manipulation + final int buffer = ((byte2 << 16) | (byte1 << 8) | byte0) >>> bitsToShiftRight; + nextBitToRead += numberOfBitsToRead; + return buffer & bitMask; // Kill the unwanted higher bits + } + + private void setNumberOfBitsToRead(final int numberOfBitsToRead) { + this.numberOfBitsToRead = numberOfBitsToRead; + bitMask = (1 << numberOfBitsToRead) - 1; + } + } + + static final class CodeTable { + private final int[][] table; // Maps codes to lists of colors + private int initTableSize; // Number of colors +2 for CLEAR + EOI + private int initCodeSize; // Initial code size + private int initCodeLimit; // First code limit + private int codeSize; // Current code size, maximum is 12 bits + private int nextCode; // Next available code for a new entry + private int nextCodeLimit; // Increase codeSize when nextCode == limit + private BitReader bitReader; // Notify when code sizes increases + + public CodeTable() { + table = new int[4096][]; + } + + private int add(final int[] indices) { + if (nextCode < 4096) { + if (nextCode == nextCodeLimit && codeSize < 12) { + codeSize++; // Max code size is 12 + bitReader.setNumberOfBitsToRead(codeSize); + nextCodeLimit = (1 << codeSize) - 1; // 2^codeSize - 1 + } + table[nextCode++] = indices; + } + return codeSize; + } + + private int clear() { + codeSize = initCodeSize; + bitReader.setNumberOfBitsToRead(codeSize); + nextCodeLimit = initCodeLimit; + nextCode = initTableSize; // Don't recreate table, reset pointer + return codeSize; + } + + private void init(final GifFrame fr, final int[] activeColTbl, final BitReader br) { + this.bitReader = br; + final int numColors = activeColTbl.length; + initCodeSize = fr.firstCodeSize; + initCodeLimit = (1 << initCodeSize) - 1; // 2^initCodeSize - 1 + initTableSize = fr.endOfInfoCode + 1; + nextCode = initTableSize; + + // Initialize single color entries + for (int c = 0; c < numColors; c++) { + table[c] = new int[]{activeColTbl[c]}; // Single element array + } + + table[fr.clearCode] = new int[] { fr.clearCode }; // CLEAR + table[fr.endOfInfoCode] = new int[] { fr.endOfInfoCode }; // EOI + + // Locate transparent color in code table and set to 0 + if (fr.transpColFlag && fr.transpColIndex < numColors) { + table[fr.transpColIndex] = new int[]{0}; + } + } + } + + final class GifFrame { + // Graphic control extension (optional) + // Disposal: 0=NO_ACTION, 1=NO_DISPOSAL, 2=RESTORE_BG, 3=RESTORE_PREV + private volatile int disposalMethod; // 0-3 as above, 4-7 undefined + private volatile boolean transpColFlag; // 1 Bit + private volatile int delay; // Unsigned, LSByte first, n * 1/100 * s + private volatile int transpColIndex; // 1 Byte + // Image descriptor + private volatile int x; // Position on the canvas from the left + private volatile int y; // Position on the canvas from the top + private volatile int w; // May be smaller than the base image + private volatile int h; // May be smaller than the base image + private volatile int wh; // width * height + private volatile boolean hasLocColTbl; // Has local color table? 1 Bit + private volatile boolean interlaceFlag; // Is an interlace image? 1 Bit + @SuppressWarnings("unused") + private volatile boolean sortFlag; // True if local colors are sorted, 1 Bit + private volatile int sizeOfLocColTbl; // Size of the local color table, 3 Bits + private volatile int[] localColTbl; // Local color table (optional) + // Image data + private volatile int firstCodeSize; // LZW minimum code size + 1 for CLEAR & EOI + private volatile int clearCode; + private volatile int endOfInfoCode; + private volatile byte[] data; // Holds LZW encoded data + private volatile BufferedImage img; // Full drawn image, not just the frame area + + // Synchronization for frame image creation + private final Object imageLock = new Object(); + } + + public final class GifImage { + public volatile String header; // Bytes 0-5, GIF87a or GIF89a + private volatile int w; // Unsigned 16 Bit, the least significant byte first + private volatile int h; // Unsigned 16 Bit, the least significant byte first + private volatile int wh; // Image width * image height + public volatile boolean hasGlobColTbl; // 1 Bit + public volatile int colorResolution; // 3 Bits + public volatile boolean sortFlag; // True if global colors are sorted, 1 Bit + public volatile int sizeOfGlobColTbl; // 2^(val(3 Bits) + 1), see spec + public volatile int bgColIndex; // Background color index, 1 Byte + public volatile int pxAspectRatio; // Pixel aspect ratio, 1 Byte + public volatile int[] globalColTbl; // Global color table + private final List frames = new ArrayList<>(64); + public volatile String appId = ""; // 8 Bytes at in[i+3], usually "NETSCAPE" + public volatile String appAuthCode = ""; // 3 Bytes at in[i+11], usually "2.0" + public volatile int repetitions = 0; // 0: infinite loop, N: number of loops + + // Thread-safe frame rendering state + private volatile BufferedImage img = null; // Currently, drawn frame + private volatile Graphics2D g; + private final ReadWriteLock renderLock = new ReentrantReadWriteLock(); + + // Synchronization objects + private final Object initLock = new Object(); + + private int[] decode(final GifFrame fr, final int[] activeColTbl) { + final DecodingContext ctx = DECODING_CONTEXT.get(); + ctx.codeTable.init(fr, activeColTbl, ctx.bitReader); + ctx.bitReader.init(fr.data); // Incoming codes + final int clearCode = fr.clearCode, endCode = fr.endOfInfoCode; + + // Use thread-local pixel buffer + final int[] out = ctx.getPixelBuffer(wh); + + final int[][] tbl = ctx.codeTable.table; // Code table + int outPos = 0; // Next pixel position in the output image array + ctx.codeTable.clear(); // Init code table + ctx.bitReader.read(); // Skip leading clear code + int code = ctx.bitReader.read(); // Read first code + int[] pixels = tbl[code]; // Output pixel for first code + + // Use System.arraycopy for better performance + System.arraycopy(pixels, 0, out, outPos, pixels.length); + outPos += pixels.length; + + try { + while (true) { + final int prevCode = code; + code = ctx.bitReader.read(); // Get next code in stream + if (code == clearCode) { // After a CLEAR table, there is + ctx.codeTable.clear(); // no previous code, we need to read + code = ctx.bitReader.read(); // a new one + pixels = tbl[code]; // Output pixels + System.arraycopy(pixels, 0, out, outPos, pixels.length); + outPos += pixels.length; + continue; // Back to the loop with a valid previous code + } else if (code == endCode) { + break; + } + final int[] prevVals = tbl[prevCode]; + final int[] prevValsAndK = new int[prevVals.length + 1]; + System.arraycopy(prevVals, 0, prevValsAndK, 0, prevVals.length); + if (code < ctx.codeTable.nextCode) { // Code table contains code + pixels = tbl[code]; // Output pixels + System.arraycopy(pixels, 0, out, outPos, pixels.length); + outPos += pixels.length; + prevValsAndK[prevVals.length] = tbl[code][0]; // K + } else { + prevValsAndK[prevVals.length] = prevVals[0]; // K + System.arraycopy(prevValsAndK, 0, out, outPos, prevValsAndK.length); + outPos += prevValsAndK.length; + } + ctx.codeTable.add(prevValsAndK); // Previous indices + K + } + } catch (final ArrayIndexOutOfBoundsException ignored) { + } + + // Return a properly sized array + return Arrays.copyOf(out, outPos); + } + + private int[] deinterlace(final int[] src, final GifFrame fr) { + final int w = fr.w, h = fr.h, wh = fr.wh; + final DecodingContext ctx = DECODING_CONTEXT.get(); + final int[] dest = ctx.getTempBuffer(src.length); + + // Interlaced images are organized in 4 sets of pixel lines + final int set2Y = (h + 7) >>> 3; // Line no. = ceil(h/8.0) + final int set3Y = set2Y + ((h + 3) >>> 3); // ceil(h-4/8.0) + final int set4Y = set3Y + ((h + 1) >>> 2); // ceil(h-2/4.0) + + // Sets' start indices in source array + final int set2 = w * set2Y, set3 = w * set3Y, set4 = w * set4Y; + + // Line skips in destination array - use bit shifts for multiplication + final int w2 = w << 1, w4 = w2 << 1, w8 = w4 << 1; + + // Group 1 contains every 8th line starting from 0 + int from = 0, to = 0; + for (; from < set2; from += w, to += w8) { + System.arraycopy(src, from, dest, to, w); + } + // Group 2 contains every 8th line starting from 4 + for (to = w4; from < set3; from += w, to += w8) { + System.arraycopy(src, from, dest, to, w); + } + // Group 3 contains every 4th line starting from 2 + for (to = w2; from < set4; from += w, to += w4) { + System.arraycopy(src, from, dest, to, w); + } + // Group 4 contains every 2nd line starting from 1 (biggest group) + for (to = w; from < wh; from += w, to += w2) { + System.arraycopy(src, from, dest, to, w); + } + return Arrays.copyOf(dest, src.length); // Return a copy, not the shared buffer + } + + private void drawFrame(final GifFrame fr) { + renderLock.writeLock().lock(); + try { + // Determine the color table that will be active for this frame + final int[] activeColTbl = fr.hasLocColTbl ? fr.localColTbl : globalColTbl; + + // Get pixels from data stream + int[] pixels = decode(fr, activeColTbl); + if (fr.interlaceFlag) { + pixels = deinterlace(pixels, fr); // Rearrange pixel lines + } + + // Create image of type TYPE_INT_ARGB for frame area + final BufferedImage frame = new BufferedImage(fr.w, fr.h, BufferedImage.TYPE_INT_ARGB); + final int[] frameData = ((DataBufferInt) frame.getRaster().getDataBuffer()).getData(); + System.arraycopy(pixels, 0, frameData, 0, Math.min(pixels.length, fr.wh)); + + // Draw frame area on top of working image + g.drawImage(frame, fr.x, fr.y, null); + + // Keep a copy of the previous frame's pixels + final DecodingContext ctx = DECODING_CONTEXT.get(); + final int[] prevPixelBuffer = ctx.getPrevPixelBuffer(wh); + final int[] imgData = ((DataBufferInt) img.getRaster().getDataBuffer()).getData(); + System.arraycopy(imgData, 0, prevPixelBuffer, 0, wh); + + // Create another copy for the end user to not expose internal state + synchronized (fr.imageLock) { + if (fr.img == null) { // Double-checked locking + fr.img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + final int[] frameImgData = ((DataBufferInt) fr.img.getRaster().getDataBuffer()).getData(); + System.arraycopy(prevPixelBuffer, 0, frameImgData, 0, wh); + } + } + + // Handle disposal of current frame + if (fr.disposalMethod == 2) { + // Restore to background color (clear frame area only) + g.clearRect(fr.x, fr.y, fr.w, fr.h); + } else if (fr.disposalMethod == 3) { + // Restore previous frame + System.arraycopy(prevPixelBuffer, 0, imgData, 0, wh); + } + } finally { + renderLock.writeLock().unlock(); + } + } + + /** + * Returns the background color of the first frame in this GIF image. If + * the frame has a local color table, the returned color will be from + * that table. If not, the color will be from the global color table. + * Returns 0 if there is neither a local nor a global color table. + * + * @return 32 bit ARGB color in the form 0xAARRGGBB + */ + public final int getBackgroundColor() { + renderLock.readLock().lock(); + try { + final GifFrame frame = frames.get(0); + if (frame.hasLocColTbl) { + return frame.localColTbl[bgColIndex]; + } else if (hasGlobColTbl) { + return globalColTbl[bgColIndex]; + } + return 0; + } finally { + renderLock.readLock().unlock(); + } + } + + /** + * If not 0, the delay specifies how many hundredths (1/100) of a second + * to wait before displaying the frame after the current frame. + * + * @param index Index of the current frame, 0 to N-1 + * @return Delay as number of hundredths (1/100) of a second + */ + public final int getDelay(final int index) { + renderLock.readLock().lock(); + try { + return frames.get(index).delay; + } finally { + renderLock.readLock().unlock(); + } + } + + /** + * @param index Index of the frame to return as image, starting from 0. + * For incremental calls such as [0, 1, 2, ...] the method's + * run time is O(1) as only one frame is drawn per call. For + * random access calls such as [7, 12, ...] the run time is + * O(N+1) with N being the number of previous frames that + * need to be drawn before N+1 can be drawn on top. Once a + * frame has been drawn it is being cached and the run time + * is more or less O(0) to retrieve it from the list. + * @return A BufferedImage for the specified frame. + */ + public BufferedImage getFrame(final int index) { + // Initialize rendering context if needed + if (img == null) { + synchronized (initLock) { + if (img == null) { // Double-checked locking + img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); + g = img.createGraphics(); + g.setBackground(new Color(0, true)); // Transparent color + // Set rendering hints for better performance + g.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED); + g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED); + } + } + } + + GifFrame fr = frames.get(index); + + // Check if frame is already rendered using double-checked locking + if (fr.img == null) { + synchronized (fr.imageLock) { + if (fr.img == null) { + // Draw all frames until and including the requested frame + for (int i = 0; i <= index; i++) { + fr = frames.get(i); + if (fr.img == null) { + drawFrame(fr); + } + } + } + } + } + + return fr.img; + } + + /** + * @return The number of frames contained in this GIF image + */ + public final int getFrameCount() { + return frames.size(); + } + + /** + * @return The height of the GIF image + */ + public final int getHeight() { + return h; + } + + /** + * @return The width of the GIF image + */ + public final int getWidth() { + return w; + } + } + + static final boolean DEBUG_MODE = false; + + /** + * @param in Raw image data as a byte[] array + * @return A GifImage object exposing the properties of the GIF image. + * @throws IOException If the image violates the GIF specification or is + * truncated. + */ + public static GifImage read(final byte[] in) throws IOException { + final GifDecoder decoder = new GifDecoder(); + final GifImage img = decoder.new GifImage(); + GifFrame frame = null; // Currently open frame + int pos = readHeader(in, img); // Read header, get next byte position + pos = readLogicalScreenDescriptor(img, in, pos); + if (img.hasGlobColTbl) { + img.globalColTbl = new int[img.sizeOfGlobColTbl]; + pos = readColTbl(in, img.globalColTbl, pos); + } + + // Main parsing loop with bounds checking optimization + while (pos < in.length) { + final int block = in[pos] & 0xFF; + switch (block) { + case 0x21: // Extension introducer + if (pos + 1 >= in.length) { + throw new IOException("Unexpected end of file."); + } + switch (in[pos + 1] & 0xFF) { + case 0xFE: // Comment extension + pos = readTextExtension(in, pos); + break; + case 0xFF: // Application extension + pos = readAppExt(img, in, pos); + break; + case 0x01: // Plain text extension + frame = null; // End of current frame + pos = readTextExtension(in, pos); + break; + case 0xF9: // Graphic control extension + if (frame == null) { + frame = decoder.new GifFrame(); + img.frames.add(frame); + } + pos = readGraphicControlExt(frame, in, pos); + break; + default: + throw new IOException("Unknown extension at " + pos); + } + break; + case 0x2C: // Image descriptor + if (frame == null) { + frame = decoder.new GifFrame(); + img.frames.add(frame); + } + pos = readImgDescr(frame, in, pos); + if (frame.hasLocColTbl) { + frame.localColTbl = new int[frame.sizeOfLocColTbl]; + pos = readColTbl(in, frame.localColTbl, pos); + } + pos = readImgData(frame, in, pos); + frame = null; // End of current frame + break; + case 0x3B: // GIF Trailer + return img; // Found trailer, finished reading. + default: + // Unknown block. The image is corrupted. Strategies: a) Skip + // and wait for a valid block. Experience: It'll get worse. b) + // Throw exception. c) Return gracefully if we are almost done + // processing. The frames we have so far should be error-free. + final double progress = (double) pos / in.length; + if (progress < 0.9) { + throw new IOException("Unknown block at: " + pos); + } + pos = in.length; // Exit loop + } + } + return img; + } + + /** + * @param is Image data as input stream. This method will read from the + * input stream's current position. It will not reset the + * position before reading and won't reset or close the stream + * afterwards. Call these methods before and after calling this + * method as needed. + * @return A GifImage object exposing the properties of the GIF image. + * @throws IOException If an I/O error occurs, the image violates the GIF + * specification or the GIF is truncated. + */ + public static GifImage read(final InputStream is) throws IOException { + final byte[] data = new byte[is.available()]; + is.read(data, 0, data.length); + return read(data); + } + + /** + * @param img GIF image + * @param in Raw data + * @param i Index of the first byte of the application extension + * @return Index of the first byte after this extension + */ + static int readAppExt(final GifImage img, final byte[] in, int i) { + // Use StandardCharsets for better performance if available, otherwise fallback + img.appId = new String(in, i + 3, 8); // should be "NETSCAPE" + img.appAuthCode = new String(in, i + 11, 3); // should be "2.0" + i += 14; // Go to sub-block size, it's value should be 3 + final int subBlockSize = in[i] & 0xFF; + // The only app extension widely used is NETSCAPE, it's got 3 data bytes + if (subBlockSize == 3) { + // in[i+1] should have value 01, in[i+5] should be block terminator + img.repetitions = (in[i + 2] & 0xFF) | ((in[i + 3] & 0xFF) << 8); // Short + return i + 5; + } // Skip unknown application extensions + while ((in[i] & 0xFF) != 0) { // While sub-block size != 0 + i += (in[i] & 0xFF) + 1; // Skip to next sub-block + } + return i + 1; + } + + /** + * @param in Raw data + * @param colors Pre-initialized target array to store ARGB colors + * @param i Index of the color table's first byte + * @return Index of the first byte after the color table + */ + static int readColTbl(final byte[] in, final int[] colors, int i) { + final int numColors = colors.length; + for (int c = 0; c < numColors; c++) { + final int r = in[i++] & 0xFF; // 1st byte is red + final int g = in[i++] & 0xFF; // 2nd byte is green + final int b = in[i++] & 0xFF; // 3rd byte is blue + // Optimized color packing - alpha is always 0xFF for opaque + colors[c] = 0xFF000000 | (r << 16) | (g << 8) | b; + } + return i; + } + + /** + * @param fr GIF frame + * @param in Raw data + * @param i Index of the extension introducer + * @return Index of the first byte after this block + */ + static int readGraphicControlExt(final GifFrame fr, final byte[] in, final int i) { + final int packed = in[i + 3] & 0xFF; + fr.disposalMethod = (packed & 0b00011100) >>> 2; // Bits 4-2 + fr.transpColFlag = (packed & 1) == 1; // Bit 0 + fr.delay = (in[i + 4] & 0xFF) | ((in[i + 5] & 0xFF) << 8); // 16 bit LSB + fr.transpColIndex = in[i + 6] & 0xFF; // Byte 6 + return i + 8; // Skipped byte 7 (blockTerminator), as it's always 0x00 + } + + /** + * @param in Raw data + * @param img The GifImage object that is currently read + * @return Index of the first byte after this block + * @throws IOException If the GIF header/trailer is missing, incomplete or + * unknown + */ + static int readHeader(final byte[] in, final GifImage img) throws IOException { + if (in.length < 6) { // Check first 6 bytes + throw new IOException("Image is truncated."); + } + // Use ASCII encoding for header - faster than default charset + img.header = new String(in, 0, 6); + if (!img.header.equals("GIF87a") && !img.header.equals("GIF89a")) { + throw new IOException("Invalid GIF header."); + } + return 6; + } + + /** + * @param fr The GIF frame to whom this image descriptor belongs + * @param in Raw data + * @param i Index of the first byte of this block, i.e. the minCodeSize + * @return Byte index + */ + static int readImgData(final GifFrame fr, final byte[] in, int i) { + final int fileSize = in.length; + final int minCodeSize = in[i++] & 0xFF; // Read code size, go to block + final int clearCode = 1 << minCodeSize; // CLEAR = 2^minCodeSize + fr.firstCodeSize = minCodeSize + 1; // Add 1 bit for CLEAR and EOI + fr.clearCode = clearCode; + fr.endOfInfoCode = clearCode + 1; + + // Pre-calculate image data size for better memory allocation + final int imgDataSize = readImgDataSize(in, i); + final byte[] imgData = new byte[imgDataSize + 2]; + int imgDataPos = 0; + int subBlockSize = in[i] & 0xFF; + + while (subBlockSize > 0) { // While block has data + try { // Next line may throw exception if sub-block size is fake + final int nextSubBlockSizePos = i + subBlockSize + 1; + final int nextSubBlockSize = in[nextSubBlockSizePos] & 0xFF; + System.arraycopy(in, i + 1, imgData, imgDataPos, subBlockSize); + imgDataPos += subBlockSize; // Move output data position + i = nextSubBlockSizePos; // Move to next sub-block size + subBlockSize = nextSubBlockSize; + } catch (final Exception e) { + // Sub-block exceeds file end, only use remaining bytes + subBlockSize = fileSize - i - 1; // Remaining bytes + if (subBlockSize > 0) { + System.arraycopy(in, i + 1, imgData, imgDataPos, subBlockSize); + imgDataPos += subBlockSize; // Move output data position + } + i += subBlockSize + 1; // Move to next sub-block size + break; + } + } + fr.data = imgData; // Holds LZW encoded data + i++; // Skip last sub-block size, should be 0 + return i; + } + + static int readImgDataSize(final byte[] in, int i) { + final int fileSize = in.length; + int imgDataPos = 0; + int subBlockSize = in[i] & 0xFF; + while (subBlockSize > 0) { // While block has data + try { // Next line may throw exception if sub-block size is fake + final int nextSubBlockSizePos = i + subBlockSize + 1; + final int nextSubBlockSize = in[nextSubBlockSizePos] & 0xFF; + imgDataPos += subBlockSize; // Move output data position + i = nextSubBlockSizePos; // Move to next sub-block size + subBlockSize = nextSubBlockSize; + } catch (final Exception e) { + // Sub-block exceeds file end, only use remaining bytes + subBlockSize = fileSize - i - 1; // Remaining bytes + if (subBlockSize > 0) { + imgDataPos += subBlockSize; // Move output data position + } + break; + } + } + return imgDataPos; + } + + /** + * @param fr The GIF frame to whom this image descriptor belongs + * @param in Raw data + * @param i Index of the image separator, i.e. the first block byte + * @return Index of the first byte after this block + */ + static int readImgDescr(final GifFrame fr, final byte[] in, int i) { + fr.x = (in[++i] & 0xFF) | ((in[++i] & 0xFF) << 8); // Byte 1-2: left + fr.y = (in[++i] & 0xFF) | ((in[++i] & 0xFF) << 8); // Byte 3-4: top + fr.w = (in[++i] & 0xFF) | ((in[++i] & 0xFF) << 8); // Byte 5-6: width + fr.h = (in[++i] & 0xFF) | ((in[++i] & 0xFF) << 8); // Byte 7-8: height + fr.wh = fr.w * fr.h; + final int packed = in[++i] & 0xFF; // Byte 9 is a packed byte + fr.hasLocColTbl = (packed & 0b10000000) != 0; // Bit 7 + fr.interlaceFlag = (packed & 0b01000000) != 0; // Bit 6 + fr.sortFlag = (packed & 0b00100000) != 0; // Bit 5 + final int colTblSizePower = (packed & 7) + 1; // Bits 2-0 + fr.sizeOfLocColTbl = 1 << colTblSizePower; // 2^(N+1), As per the spec + return ++i; + } + + /** + * @param img GIF image + * @param i Start index of this block. + * @return Index of the first byte after this block. + */ + static int readLogicalScreenDescriptor(final GifImage img, final byte[] in, final int i) { + img.w = (in[i] & 0xFF) | ((in[i + 1] & 0xFF) << 8); // 16 bit, LSB 1st + img.h = (in[i + 2] & 0xFF) | ((in[i + 3] & 0xFF) << 8); // 16 bit + img.wh = img.w * img.h; + final int packed = in[i + 4] & 0xFF; // Byte 4 is a packed byte + img.hasGlobColTbl = (packed & 0b10000000) != 0; // Bit 7 + final int colResPower = ((packed & 0b01110000) >>> 4) + 1; // Bits 6-4 + img.colorResolution = 1 << colResPower; // 2^(N+1), As per the spec + img.sortFlag = (packed & 0b00001000) != 0; // Bit 3 + final int globColTblSizePower = (packed & 7) + 1; // Bits 0-2 + img.sizeOfGlobColTbl = 1 << globColTblSizePower; // 2^(N+1), see spec + img.bgColIndex = in[i + 5] & 0xFF; // 1 Byte + img.pxAspectRatio = in[i + 6] & 0xFF; // 1 Byte + return i + 7; + } + + /** + * @param in Raw data + * @param pos Index of the extension introducer + * @return Index of the first byte after this block + */ + static int readTextExtension(final byte[] in, final int pos) { + int i = pos + 2; // Skip extension introducer and label + int subBlockSize = in[i++] & 0xFF; + while (subBlockSize != 0 && i < in.length) { + i += subBlockSize; + if (i >= in.length) break; // Safety check + subBlockSize = in[i++] & 0xFF; + } + return i; + } +} \ No newline at end of file