Changed: Increase Sixel and iTerm Image limits

The `TerminalBitmap.MAX_BITMAP_SIZE` defines the max size of a Terminal bitmap for its pixels. Each pixel is stored on 4 bytes for a `Bitmap.Config.ARGB_8888` bitmap color config. The value should normally be between `100-200MB` depending on device and Android version. Check the variable docs for more info.

The sixel image size cannot be greater than `TerminalBitmap.MAX_BITMAP_SIZE`. The repeat value for sixel Graphics Repeat Introducer command cannot be greater than `TerminalSixel.SIXEL__MAX_REPEAT` (`8192`).

The iTerm image data sent for `File=` and `MultipartFile=` protocols cannot be greater than `TerminalBitmap.MAX_BITMAP_SIZE` bytes.

Author: agnostic-apollo

terminal-emulator/src/main/java/com/termux/terminal/AndroidUtils.java

@@ -0,0 +1,65 @@
+package com.termux.terminal;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class AndroidUtils {
+
+    /**
+     * Get system properties as {@link Properties} from `/system/bin/getprop` command output
+     * that reads the `/system/build.prop` file.
+     *
+     * Sourced from https://github.com/termux/termux-app/blob/30ebb2dee381d292ade0f2868cfde0f9f20b89fe/termux-shared/src/main/java/com/termux/shared/android/AndroidUtils.java#L170.
+     */
+    public static Properties getSystemProperties(String logTag) {
+        Properties systemProperties = new Properties();
+
+        // getprop commands returns values in the format `[key]: [value]`
+        // Regex matches string starting with a literal `[`,
+        // followed by one or more characters that do not match a closing square bracket as the key,
+        // followed by a literal `]: [`,
+        // followed by one or more characters as the value,
+        // followed by string ending with literal `]`
+        // multiline values will be ignored
+        Pattern propertiesPattern = Pattern.compile("^\\[([^]]+)]: \\[(.+)]$");
+
+        try {
+            Process process = new ProcessBuilder()
+                .command("/system/bin/getprop")
+                .redirectErrorStream(true)
+                .start();
+
+            InputStream inputStream = process.getInputStream();
+            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+            String line, key, value;
+
+            while ((line = bufferedReader.readLine()) != null) {
+                Matcher matcher = propertiesPattern.matcher(line);
+                if (matcher.matches()) {
+                    key = matcher.group(1);
+                    value = matcher.group(2);
+                    if (key != null && value != null && !key.isEmpty() && !value.isEmpty())
+                        systemProperties.put(key, value);
+                }
+            }
+
+            bufferedReader.close();
+            process.destroy();
+
+        } catch (IOException e) {
+            Logger.logStackTraceWithMessage(null, logTag, "Failed to get run \"/system/bin/getprop\" to get system properties.", e);
+        }
+
+        //for (String key : systemProperties.stringPropertyNames()) {
+        //    Logger.logVerbose(null, logTag, key + ": " +  systemProperties.get(key));
+        //}
+
+        return systemProperties;
+    }
+
+}

terminal-emulator/src/main/java/com/termux/terminal/TerminalBitmap.java

@@ -1,7 +1,16 @@
 package com.termux.terminal;
 
+import android.app.WallpaperManager;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.RecordingCanvas;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Build;
+
+import java.util.Properties;
 
 /**
  * A terminal bitmap for images.
@@ -10,6 +19,110 @@ public class TerminalBitmap {
 
     public static final String LOG_TAG = "TerminalBitmap";
 
+    private static int initMaxBitmapSize() {
+        int defaultSize =
+                Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM ?
+                    150 * 1024 * 1024 : // 150 MB
+                    100 * 1024 * 1024;  // 100 MB
+
+        Properties systemProperties = AndroidUtils.getSystemProperties(LOG_TAG);
+        String maxTextureSizeString = systemProperties.getProperty("ro.hwui.max_texture_allocation_size");
+
+        if (maxTextureSizeString == null) return defaultSize;
+
+        try {
+            int maxTextureSize = Integer.parseInt(maxTextureSizeString);
+            return maxTextureSize > 0 ? maxTextureSize : defaultSize;
+        }
+        catch (Exception e) {
+            return defaultSize;
+        }
+    }
+
+    /**
+     * The max size of a Terminal {@link Bitmap} for its pixels. The limit is defined as per how
+     * `RecordingCanvas.MAX_BITMAP_SIZE` value is defined, check below for details. The value should
+     * normally be between `100-200MB` depending on device and Android version.
+     *
+     * Each pixel is stored on 4 bytes for a {@link Bitmap.Config#ARGB_8888} bitmap color config.
+     * The bitmap will have following memory usage for its respective resolution (`width x height x 4`).
+     * - 1280x720 (HD): 3,686,400 bytes/3.6MB.
+     * - 1920x1080 (FHD): 8,294,400 bytes/8MB.
+     * - 2560x1440 (QHD): 14,745,600 bytes/14.7MB.
+     * - 3840x2160 (4K UHD): 33,177,600 bytes/33MB.
+     * - 7680x4320 (8K UHD): 132,710,400 bytes/132MB.
+     * .
+     * - https://en.wikipedia.org/wiki/Display_resolution_standards#High-definition
+     *
+     * The terminal uses {@link Canvas#drawBitmap(Bitmap, Rect, RectF, Paint)} to draw the bitmap
+     * when `TerminalRenderer.render()` is called.
+     *
+     * The {@link Canvas} class defines `Canvas.MAXIMUM_BITMAP_SIZE` for the maximum dimension
+     * for a bitmap which is returned by {@link Canvas#getMaximumBitmapWidth()} and
+     * {@link Canvas#getMaximumBitmapHeight()}. It is hardcoded with the value `32766` as defined by
+     * Skia (2D graphics library), which technically has the limit `32767` as it requires supporting
+     * math on 16-bit buffers.
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/f61970fc79e9c5cf340fa942597628242361864a
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/graphics/java/android/graphics/Canvas.java;l=76-78
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:external/skia/src/shaders/SkImageShader.cpp;l=254-267
+     *
+     * The {@link RecordingCanvas} class defines `RecordingCanvas.MAX_BITMAP_SIZE` for the
+     * maximum size (not dimension) for a bitmap, which is checked by
+     * `RecordingCanvas.throwIfCannotDraw()` when `BaseRecordingCanvas.drawBitmap()` is called.
+     * The `RecordingCanvas` is a specialized implementation of the `Canvas` class that is designed
+     * to record draw commands for deferred rendering instead of executing draw commands instantly.
+     * By recording draw commands, they can be cached so that complex views can be efficiently
+     * re-drawn without recalculating them again for every frame. The caching part is similar to
+     * how a terminal behaves, where it stores all the bitmaps for rendering depending on scroll
+     * position. So both {@link RecordingCanvas} and a terminal require similar limits on bitmap
+     * sizes considering memory consumption limits of apps, and multiple bitmaps being loaded
+     * instead of a single one like for wallpapers, hence why `TerminalBitmap.MAX_BITMAP_SIZE` is
+     * synced with  {@link RecordingCanvas}.
+     * The `RecordingCanvas.MAX_BITMAP_SIZE` is set from `ro.hwui.max_texture_allocation_size`
+     * system property if set for Android `>= 12`, otherwise `150MB` (`100MB` for Android `10-14`).
+     * The values `>= 150MB` are enough to support `7680x4320` (8K UHD) bitmaps.
+     * Some devices like larger xiaomi devices have `ro.hwui.max_texture_allocation_size` set to `209715200` (`200MB`).
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/e4d011201cea40d46cb2b2eef401db8fddc5c9c6
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/0e717a9d06ded980908649393bd73e46ffafcd54
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/97396260ed06cc9d1834d4d8e4e649a3ef09f1f3
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/graphics/java/android/graphics/RecordingCanvas.java;l=42-50
+     *
+     * The Android wallpaper manager service also checks if dimensions of cropped wallpaper exceeds
+     * max texture size that the GPU can support, otherwise it will cause System UI to keep crashing
+     * because it can not initialize EGL with an appropriate surface. The `GLHelper.getMaxTextureSize()`
+     * returns the max texture size, which is defined by `sys.max_texture_size` system property if set,
+     * otherwise by value for `GL_MAX_TEXTURE_SIZE`. The `sys.max_texture_size` defines the maximum
+     * width or height of a texture, not total size. Its value can be low like `2048` or high like
+     * `16384` for 16K support.
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/32c6a7c691b0d91085c1ed13fe6f1c473c94b4c8
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperCropper.java;l=461
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/GLHelper.java;l=145
+     * - https://developer.android.com/reference/android/opengl/GLES10#GL_MAX_TEXTURE_SIZE
+     *
+     * The {@link WallpaperManager#getDesiredMinimumWidth()} and {@link WallpaperManager#getDesiredMinimumHeight()}
+     * can also be called to get minimum suggested width and height of the wallpaper that an app
+     * should use when setting the wallpaper. This normally is equal to the width and height of the
+     * current device display, but the width can be higher than display width if the homescreen is
+     * scrollable horizontally with multiple pages, in which case the width returned is equal to
+     * entire workspace width. The launcher apps can provide Android their desired width and height
+     * dimensions depending on the homescreen pages config by calling
+     * {@link WallpaperManager#suggestDesiredDimensions(int, int)}, which also ensures that values
+     * passed are scaled down to `sys.max_texture_size` system property if its set.
+     * - https://cs.android.com/android/_/android/platform/frameworks/base/+/289c273ec49462c7bfdbf6238e9016936da7307c
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/core/java/android/app/WallpaperManager.java;l=2737-2794
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java;l=2330-2366
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/services/core/java/com/android/server/wallpaper/WallpaperDisplayHelper.java;l=108-115
+     * - https://cs.android.com/android/platform/superproject/+/android-16.0.0_r1:frameworks/base/core/java/android/view/Display.java;l=1052-1063
+     *
+     * If an app specifies `largeHeap=true` in its `AndroidManifest.xml`, then it can be allocated
+     * larger heap memory to load larger bitmaps maps instead of resulting in an OOM. The Termux app
+     * does not have it enabled, and hence is more likely to have OOMs when loading larger bitmaps.
+     * - https://developer.android.com/guide/topics/manifest/application-element#largeHeap
+     * - https://developer.android.com/topic/performance/memory
+     */
+    public static final int MAX_BITMAP_SIZE = initMaxBitmapSize();
+
+
 
     protected final TerminalSessionClient mClient;
 
@@ -304,8 +417,15 @@ public static Bitmap resizeBitmap(String logTag, String label, TerminalSessionCl
 
         Bitmap newBitmap;
         try {
-            int[] pixels = new int[bitmap.getAllocationByteCount()];
+            int newBitmapSize = bitmapWidth * bitmapHeight * 4;
+            if (newBitmapSize < 0 || newBitmapSize > MAX_BITMAP_SIZE) {
+                Logger.logError(client, logTag, "The new " + label + " bitmap after resize with" +
+                    " width " + bitmapWidth + " and height " + bitmapHeight +
+                    " has size " + newBitmapSize + " greater than max bitmap size " + MAX_BITMAP_SIZE);
+                return null;
+            }
 
+            int[] pixels = new int[bitmap.getAllocationByteCount()];
             bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
 
             newBitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888);

terminal-emulator/src/main/java/com/termux/terminal/TerminalBuffer.java

@@ -630,13 +630,22 @@ public synchronized void sixelClear() {
         mTerminalSixel = null;
     }
 
+    /**
+     * Clears the {@link #mTerminalSixel} by setting it to `null` and logs error.
+     * Call this on error if further sixel commands/data should be parsed to prevent them from
+     * printing on terminal, but sixel rendering should be ignored.
+     */
+    public synchronized void sixelIgnore() {
+        Logger.logError(mClient, LOG_TAG, "Ignoring sixel rendering");
+        mTerminalSixel = null;
+    }
+
     public synchronized boolean sixelReadData(int codePoint, int repeat) {
         //  If an error occurred during processing (like OOM), then remaining sixel command is
         //  completely read, but is ignored.
         if (mTerminalSixel != null) {
             if (!mTerminalSixel.readData(codePoint, repeat)) {
-                // Ignore further commands/data.
-                mTerminalSixel = null;
+                sixelIgnore();
                 return false;
             }
         }
@@ -648,8 +657,7 @@ public synchronized boolean sixelResize(int sixelWidth, int sixelHeight) {
         //  completely read, but is ignored.
         if (mTerminalSixel != null) {
             if (!mTerminalSixel.resize(sixelWidth, sixelHeight)) {
-                // Ignore further commands/data.
-                mTerminalSixel = null;
+                sixelIgnore();
                 return false;
             }
         }