[vte/wip/sixels: 1/82] sixels: Initial rebase of saitoha's patch.



commit 10934535d5b596ccee1565e14726f2e40734a825
Author: Hans Petter Jansson <hpj cl no>
Date:   Fri May 22 22:00:31 2020 +0200

    sixels: Initial rebase of saitoha's patch.

 src/debug.h           |   1 +
 src/ring.cc           | 166 +++++++++++
 src/sixel.cc          | 770 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sixel.h           |  71 +++++
 src/vte.cc            | 184 ++++++++++++
 src/vte/vteterminal.h |  18 ++
 src/vtedefines.hh     |   1 +
 src/vtegtk.cc         |  85 ++++++
 src/vtegtk.hh         |   2 +
 src/vteimage.cc       | 275 ++++++++++++++++++
 src/vteimage.h        |  61 ++++
 src/vteinternal.hh    |  17 ++
 src/vteseq.cc         | 216 +++++++++++++-
 13 files changed, 1866 insertions(+), 1 deletion(-)
---
diff --git a/src/debug.h b/src/debug.h
index 90be5c5f..a9970f5f 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -68,6 +68,7 @@ typedef enum {
         VTE_DEBUG_BIDI          = 1 << 28,
         VTE_DEBUG_CONVERSION    = 1 << 29,
         VTE_DEBUG_EXCEPTIONS    = 1 << 30,
+        VTE_DEBUG_IMAGE         = 1 << 31,
 } VteDebugFlags;
 
 void _vte_debug_init(void);
diff --git a/src/ring.cc b/src/ring.cc
index 2d76d136..99ff8b76 100644
--- a/src/ring.cc
+++ b/src/ring.cc
@@ -25,6 +25,7 @@
 #include "vterowdata.hh"
 
 #include <string.h>
+#include <new>
 
 /*
  * Copy the common attributes from VteCellAttr to VteStreamCellAttr or vice versa.
@@ -74,6 +75,7 @@ Ring::Ring(row_t max_rows,
                m_attr_stream = _vte_file_stream_new ();
                m_text_stream = _vte_file_stream_new ();
                m_row_stream = _vte_file_stream_new ();
+               m_image_stream = _vte_file_stream_new ();
        } else {
                m_attr_stream = m_text_stream = m_row_stream = nullptr;
        }
@@ -86,20 +88,33 @@ Ring::Ring(row_t max_rows,
         auto empty_str = g_string_new_len("", 0);
         g_ptr_array_add(m_hyperlinks, empty_str);
 
+        m_image_map = new (std::nothrow) std::map<gint, vte::image::image_object *>();
+        m_image_onscreen_resource_counter = 0;
+        m_image_offscreen_resource_counter = 0;
+
        validate();
 }
 
 Ring::~Ring()
 {
+       auto image_map = m_image_map;
+
        for (size_t i = 0; i <= m_mask; i++)
                _vte_row_data_fini (&m_array[i]);
 
        g_free (m_array);
 
+       /* Clear SIXEL images */
+       for (auto it = image_map->begin (); it != image_map->end (); ++it)
+               delete it->second;
+       image_map->clear();
+       delete m_image_map;
+
        if (m_has_streams) {
                g_object_unref (m_attr_stream);
                g_object_unref (m_text_stream);
                g_object_unref (m_row_stream);
+               g_object_unref (m_image_stream);
        }
 
        g_string_free (m_utf8_buffer, TRUE);
@@ -585,12 +600,21 @@ Ring::reset_streams(row_t position)
 Ring::row_t
 Ring::reset()
 {
+       auto image_map = m_image_map;
+
         _vte_debug_print (VTE_DEBUG_RING, "Reseting the ring at %lu.\n", m_end);
 
         reset_streams(m_end);
         m_start = m_writable = m_end;
         m_cached_row_num = (row_t)-1;
 
+       /* Clear SIXEL images */
+       for (auto it = image_map->begin (); it != image_map->end (); ++it)
+               delete it->second;
+       image_map->clear();
+       if (m_has_streams)
+               _vte_stream_reset (m_image_stream, _vte_stream_head (m_image_stream));
+
         return m_end;
 }
 
@@ -1483,3 +1507,145 @@ Ring::write_contents(GOutputStream* stream,
 
        return true;
 }
+
+/**
+ * _vte_ring_append_image:
+ * @ring: a #VteRing
+ * @surface: a Cairo surface object
+ * @pixelwidth: image width in pixels
+ * @pixelheight: image height in pixels
+ * @left: left position of image in cell unit
+ * @top: left position of image in cell unit
+ * @width: width of image in cell unit
+ * @height: width of image in cell unit
+ *
+ * Append an image into the internal image list.
+ */
+void
+_vte_ring_append_image (VteRing *ring, cairo_surface_t *surface, gint pixelwidth, gint pixelheight, glong 
left, glong top, glong width, glong height)
+{
+       using namespace vte::image;
+       image_object *image;
+       auto image_map = ring->image_map;
+       gulong char_width, char_height;
+
+       g_assert_true (image_map != NULL);
+
+       image = new (std::nothrow) image_object (surface, pixelwidth, pixelheight, left, top, width, height, 
ring->image_stream);
+       g_assert_true (image != NULL);
+
+       char_width = pixelwidth / width;
+       char_height = pixelwidth / height;
+
+       /* composition */
+       for (auto it = image_map->lower_bound (top); it != image_map->end (); ++it) {
+               image_object *current = it->second;
+
+               /* Combine two images if one's area includes another's area */
+               if (image->includes (current)) {
+                       /*
+                        * Replace current image with new image
+                        *
+                        *  +--------------+
+                        *  |     new      |
+                        *  | ...........  |
+                        *  | : current :  |
+                        *  | :.........:  |
+                        *  +--------------+
+                        */
+                       image_map->erase (image->get_bottom ());
+                       if (current->is_freezed())
+                               ring->image_offscreen_resource_counter -= current->resource_size ();
+                       else
+                               ring->image_onscreen_resource_counter -= current->resource_size ();
+                       delete current;
+               } else if (current->includes (image)) {
+                       /*
+                        * Copy new image to current image's sub-area.
+                        *
+                        *  +--------------+
+                        *  | +-----+      |
+                        *  | | new |      |
+                        *  | +-----+      |
+                        *  |    current   |
+                        *  +--------------+
+                        */
+                       if (current->is_freezed()) {
+                               ring->image_offscreen_resource_counter -= current->resource_size ();
+                               current->thaw ();
+                       } else {
+                               ring->image_onscreen_resource_counter -= current->resource_size ();
+                       }
+                       current->combine (image, char_width, char_height);
+                       ring->image_onscreen_resource_counter += current->resource_size ();
+                       delete image;
+                       goto end;
+               }
+
+               if ((current->get_bottom () - image->get_bottom ()) * (current->get_top () - image->get_top 
()) <= 0) {
+                        /*
+                        * Unite two images if one's [top, bottom] includes another's [top, bottom].
+                        * This operation ensures bottom-position-based order is same to top-position-based 
order.
+                        *
+                        *              +------+
+                        *  +---------+ |      |
+                        *  | current | | new  |
+                        *  |         | |      |
+                        *  +---------+ |      |
+                        *              +------+
+                        *  or
+                        *
+                        *  +---------+
+                        *  | current | +------+
+                        *  |         | | new  |
+                        *  |         | +------+
+                        *  +---------+
+                        *          |
+                        *          v
+                        *  +------------------+
+                        *  | new (united)     |
+                        *  |                  |
+                        *  +------------------+
+                        */
+                       image->unite (image, char_width, char_height);
+                       image_map->erase (current->get_bottom ());
+                       if (current->is_freezed())
+                               ring->image_offscreen_resource_counter -= current->resource_size ();
+                       else
+                               ring->image_onscreen_resource_counter -= current->resource_size ();
+                       delete current;
+                       goto end;
+               }
+       }
+
+register_to_map:
+       /*
+        * Now register new image to the image_map container.
+        * the key is bottom positon.
+        *  +----------+
+        *  |   new    |
+        *  |          |
+        *  +----------+ <- bottom position (key)
+        */
+       image_map->insert (std::make_pair (image->get_bottom (), image));
+       ring->image_onscreen_resource_counter += image->resource_size ();
+end:
+       /* noop */
+       ;
+}
+
+void
+_vte_ring_shrink_image_stream (VteRing *ring)
+{
+       using namespace vte::image;
+       image_object *first_image;
+
+       if (ring->image_map->empty())
+               return;
+
+       first_image = ring->image_map->begin()->second;
+
+       if (first_image->is_freezed ())
+               if (first_image->get_stream_position () > _vte_stream_tail (ring->image_stream))
+                       _vte_stream_advance_tail (ring->image_stream, first_image->get_stream_position ());
+}
diff --git a/src/sixel.cc b/src/sixel.cc
new file mode 100644
index 00000000..0e06ca66
--- /dev/null
+++ b/src/sixel.cc
@@ -0,0 +1,770 @@
+/*
+ * Copyright (C) Hayaki Saito
+ * originally written by kmiya@cluti (https://github.com/saitoha/sixel/blob/master/fromsixel.c)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>   /* isdigit */
+#include <string.h>  /* memcpy */
+#include <glib.h>
+
+#include "sixel.h"
+
+#define SIXEL_RGB(r, g, b) ((r) + ((g) << 8) +  ((b) << 16))
+#define PALVAL(n,a,m) (((n) * (a) + ((m) / 2)) / (m))
+#define SIXEL_XRGB(r,g,b) SIXEL_RGB(PALVAL(r, 255, 100), PALVAL(g, 255, 100), PALVAL(b, 255, 100))
+
+static int const sixel_default_color_table[] = {
+       SIXEL_XRGB(0,  0,  0),   /*  0 Black    */
+       SIXEL_XRGB(20, 20, 80),  /*  1 Blue     */
+       SIXEL_XRGB(80, 13, 13),  /*  2 Red      */
+       SIXEL_XRGB(20, 80, 20),  /*  3 Green    */
+       SIXEL_XRGB(80, 20, 80),  /*  4 Magenta  */
+       SIXEL_XRGB(20, 80, 80),  /*  5 Cyan     */
+       SIXEL_XRGB(80, 80, 20),  /*  6 Yellow   */
+       SIXEL_XRGB(53, 53, 53),  /*  7 Gray 50% */
+       SIXEL_XRGB(26, 26, 26),  /*  8 Gray 25% */
+       SIXEL_XRGB(33, 33, 60),  /*  9 Blue*    */
+       SIXEL_XRGB(60, 26, 26),  /* 10 Red*     */
+       SIXEL_XRGB(33, 60, 33),  /* 11 Green*   */
+       SIXEL_XRGB(60, 33, 60),  /* 12 Magenta* */
+       SIXEL_XRGB(33, 60, 60),  /* 13 Cyan*    */
+       SIXEL_XRGB(60, 60, 33),  /* 14 Yellow*  */
+       SIXEL_XRGB(80, 80, 80),  /* 15 Gray 75% */
+};
+
+/*
+ *  HLS-formatted color handling.
+ *  (0 degree = blue, double-hexcone model)
+ *  http://odl.sysworks.biz/disk$vaxdocdec021/progtool/d3qsaaa1.p64.bkb
+ */
+static int
+hls_to_rgb(int hue, int lum, int sat)
+{
+    double min, max;
+    int r, g, b;
+
+    if (sat == 0) {
+        r = g = b = lum;
+    }
+
+    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/17e876f7e3260ea7fed73f69e19c71eb715dd09d */
+    max = lum + sat * (100 - (lum > 50 ? 1 : -1) * ((lum << 1) - 100)) / 200.0;
+
+    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/f6721b57985ad83db3d5b800dc38c9980eedde1d */
+    min = lum - sat * (100 - (lum > 50 ? 1 : -1) * ((lum << 1) - 100)) / 200.0;
+
+    /* HLS hue color ring is roteted -120 degree from HSL's one. */
+    hue = (hue + 240) % 360;
+
+    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/937e8abdab308a22ff99de24d645ec9e70f1e384 */
+    switch (hue / 60) {
+    case 0:  /* 0 <= hue < 60 */
+        r = max;
+        g = (min + (max - min) * (hue / 60.0));
+        b = min;
+        break;
+    case 1:  /* 60 <= hue < 120 */
+        r = min + (max - min) * ((120 - hue) / 60.0);
+        g = max;
+        b = min;
+        break;
+    case 2:  /* 120 <= hue < 180 */
+        r = min;
+        g = max;
+        b = (min + (max - min) * ((hue - 120) / 60.0));
+        break;
+    case 3:  /* 180 <= hue < 240 */
+        r = min;
+        g = (min + (max - min) * ((240 - hue) / 60.0));
+        b = max;
+        break;
+    case 4:  /* 240 <= hue < 300 */
+        r = (min + (max - min) * ((hue - 240) / 60.0));
+        g = min;
+        b = max;
+        break;
+    case 5:  /* 300 <= hue < 360 */
+    default:
+        r = max;
+        g = min;
+        b = (min + (max - min) * ((360 - hue) / 60.0));
+        break;
+    }
+
+    return SIXEL_XRGB(r, g, b);
+}
+
+static int
+set_default_color(sixel_image_t *image)
+{
+       int i;
+       int n;
+       int r;
+       int g;
+       int b;
+
+       /* palette initialization */
+       for (n = 1; n < 17; n++) {
+               image->palette[n] = sixel_default_color_table[n - 1];
+       }
+
+       /* colors 17-232 are a 6x6x6 color cube */
+       for (r = 0; r < 6; r++) {
+               for (g = 0; g < 6; g++) {
+                       for (b = 0; b < 6; b++) {
+                               image->palette[n++] = SIXEL_RGB(r * 51, g * 51, b * 51);
+                       }
+               }
+       }
+
+       /* colors 233-256 are a grayscale ramp, intentionally leaving out */
+       for (i = 0; i < 24; i++) {
+               image->palette[n++] = SIXEL_RGB(i * 11, i * 11, i * 11);
+       }
+
+       for (; n < DECSIXEL_PALETTE_MAX; n++) {
+               image->palette[n] = SIXEL_RGB(255, 255, 255);
+       }
+
+       return (0);
+}
+
+static int
+sixel_image_init(
+    sixel_image_t    *image,
+    int              width,
+    int              height,
+    int              fgcolor,
+    int              bgcolor,
+    int              use_private_register)
+{
+       int status = (-1);
+       size_t size;
+
+       size = (size_t)(width * height) * sizeof(sixel_color_no_t);
+       image->width = width;
+       image->height = height;
+       image->data = (sixel_color_no_t *)g_malloc(size);
+       image->ncolors = 2;
+       image->use_private_register = use_private_register;
+
+       if (image->data == NULL) {
+               status = (-1);
+               goto end;
+       }
+       memset(image->data, 0, size);
+
+       image->palette[0] = bgcolor;
+
+       if (image->use_private_register)
+               image->palette[1] = fgcolor;
+
+       image->palette_modified = 0;
+
+       status = (0);
+
+end:
+       return status;
+}
+
+
+static int
+image_buffer_resize(
+    sixel_image_t   *image,
+    int              width,
+    int              height)
+{
+       int status = (-1);
+       size_t size;
+       sixel_color_no_t *alt_buffer;
+       int n;
+       int min_height;
+
+       size = (size_t)(width * height) * sizeof(sixel_color_no_t);
+       alt_buffer = (sixel_color_no_t *)g_malloc(size);
+       if (alt_buffer == NULL) {
+               /* free source image */
+               g_free(image->data);
+               image->data = NULL;
+               status = (-1);
+               goto end;
+       }
+
+       min_height = height > image->height ? image->height: height;
+       if (width > image->width) {  /* if width is extended */
+               for (n = 0; n < min_height; ++n) {
+                       /* copy from source image */
+                       memcpy(alt_buffer + width * n,
+                              image->data + image->width * n,
+                              (size_t)image->width * sizeof(sixel_color_no_t));
+                       /* fill extended area with background color */
+                       memset(alt_buffer + width * n + image->width,
+                              0,
+                              (size_t)(width - image->width) * sizeof(sixel_color_no_t));
+               }
+       } else {
+               for (n = 0; n < min_height; ++n) {
+                       /* copy from source image */
+                       memcpy(alt_buffer + width * n,
+                              image->data + image->width * n,
+                              (size_t)width * sizeof(sixel_color_no_t));
+               }
+       }
+
+       if (height > image->height) {  /* if height is extended */
+               /* fill extended area with background color */
+               memset(alt_buffer + width * image->height,
+                      0,
+                      (size_t)(width * (height - image->height)) * sizeof(sixel_color_no_t));
+       }
+
+       /* free source image */
+       g_free(image->data);
+
+       image->data = alt_buffer;
+       image->width = width;
+       image->height = height;
+
+       status = (0);
+
+end:
+       return status;
+}
+
+static void
+sixel_image_deinit(sixel_image_t *image)
+{
+       g_free(image->data);
+       image->data = NULL;
+}
+
+int
+sixel_parser_init(sixel_state_t *st,
+                  int fgcolor, int bgcolor,
+                  int use_private_register)
+{
+       int status = (-1);
+
+       st->state = PS_DCS;
+       st->pos_x = 0;
+       st->pos_y = 0;
+       st->max_x = 0;
+       st->max_y = 0;
+       st->attributed_pan = 2;
+       st->attributed_pad = 1;
+       st->attributed_ph = 0;
+       st->attributed_pv = 0;
+       st->repeat_count = 1;
+       st->color_index = 16;
+       st->nparams = 0;
+       st->param = 0;
+
+       /* buffer initialization */
+       status = sixel_image_init(&st->image, 1, 1, fgcolor, bgcolor, use_private_register);
+
+       return status;
+}
+
+int
+sixel_parser_set_default_color(sixel_state_t *st)
+{
+       return set_default_color(&st->image);
+}
+
+int
+sixel_parser_finalize(sixel_state_t *st, unsigned char *pixels)
+{
+       int status = (-1);
+       int sx;
+       int sy;
+       sixel_image_t *image = &st->image;
+       int x, y;
+       sixel_color_no_t *src;
+       unsigned char *dst;
+       int color;
+
+       if (++st->max_x < st->attributed_ph)
+               st->max_x = st->attributed_ph;
+
+       if (++st->max_y < st->attributed_pv)
+               st->max_y = st->attributed_pv;
+
+       sx = st->max_x;
+       sy = st->max_y;
+
+       if (image->width > sx || image->height > sy) {
+               status = image_buffer_resize(image, sx, sy);
+               if (status < 0)
+                       goto end;
+       }
+
+       if (image->use_private_register && image->ncolors > 2 && !image->palette_modified) {
+               status = set_default_color(image);
+               if (status < 0)
+                       goto end;
+       }
+
+       src = st->image.data;
+       dst = pixels;
+       for (y = 0; y < st->image.height; ++y) {
+               for (x = 0; x < st->image.width; ++x) {
+                       color = st->image.palette[*src++];
+                       *dst++ = color >> 16 & 0xff;   /* b */
+                       *dst++ = color >> 8 & 0xff;    /* g */
+                       *dst++ = color >> 0 & 0xff;    /* r */
+                       *dst++ = 0xff;                 /* a */
+               }
+       }
+
+       status = (0);
+
+end:
+       return status;
+}
+
+/* convert sixel data into indexed pixel bytes and palette data */
+int
+sixel_parser_parse(sixel_state_t *st, unsigned char *p, size_t len)
+{
+       int status = (-1);
+       int n;
+       int i;
+       int x;
+       int y;
+       int bits;
+       int sixel_vertical_mask;
+       int sx;
+       int sy;
+       int c;
+       int pos;
+       unsigned char *p0 = p;
+       sixel_image_t *image = &st->image;
+
+       if (! image->data)
+               goto end;
+
+       while (p < p0 + len) {
+               switch (st->state) {
+               case PS_ESC:
+                       switch (*p) {
+                       case '\\':
+                       case 0x9c:
+                               p++;
+                               break;
+                       case 'P':
+                               st->param = -1;
+                               st->state = PS_DCS;
+                               p++;
+                               break;
+                       default:
+                               p++;
+                               break;
+                       }
+                       goto end;
+               case PS_DCS:
+                       switch (*p) {
+                       case 0x1b:
+                               st->state = PS_ESC;
+                               p++;
+                               break;
+                       case '0':
+                       case '1':
+                       case '2':
+                       case '3':
+                       case '4':
+                       case '5':
+                       case '6':
+                       case '7':
+                       case '8':
+                       case '9':
+                               if (st->param < 0)
+                                       st->param = 0;
+                               st->param = st->param * 10 + *p - '0';
+                               p++;
+                               break;
+                       case ';':
+                               if (st->param < 0) {
+                                       st->param = 0;
+                               }
+                               if (st->nparams < DECSIXEL_PARAMS_MAX) {
+                                       st->params[st->nparams++] = st->param;
+                               }
+                               st->param = 0;
+                               p++;
+                               break;
+                       case 'q':
+                               if (st->param >= 0 && st->nparams < DECSIXEL_PARAMS_MAX) {
+                                       st->params[st->nparams++] = st->param;
+                               }
+                               if (st->nparams > 0) {
+                                       /* Pn1 */
+                                       switch (st->params[0]) {
+                                       case 0:
+                                       case 1:
+                                               st->attributed_pad = 2;
+                                               break;
+                                       case 2:
+                                               st->attributed_pad = 5;
+                                               break;
+                                       case 3:
+                                       case 4:
+                                               st->attributed_pad = 4;
+                                               break;
+                                       case 5:
+                                       case 6:
+                                               st->attributed_pad = 3;
+                                               break;
+                                       case 7:
+                                       case 8:
+                                               st->attributed_pad = 2;
+                                               break;
+                                       case 9:
+                                               st->attributed_pad = 1;
+                                               break;
+                                       default:
+                                               st->attributed_pad = 2;
+                                               break;
+                                       }
+                               }
+
+                               if (st->nparams > 2) {
+                                       /* Pn3 */
+                                       if (st->params[2] == 0)
+                                               st->params[2] = 10;
+                                       st->attributed_pan = st->attributed_pan * st->params[2] / 10;
+                                       st->attributed_pad = st->attributed_pad * st->params[2] / 10;
+                                       if (st->attributed_pan <= 0)
+                                               st->attributed_pan = 1;
+                                       if (st->attributed_pad <= 0)
+                                               st->attributed_pad = 1;
+                               }
+                               st->nparams = 0;
+                               st->state = PS_DECSIXEL;
+                               p++;
+                               break;
+                       default:
+                               p++;
+                               break;
+                       }
+                       break;
+
+               case PS_DECSIXEL:
+                       switch (*p) {
+                       case '\x1b':
+                               st->state = PS_ESC;
+                               p++;
+                               break;
+                       case '"':
+                               st->param = 0;
+                               st->nparams = 0;
+                               st->state = PS_DECGRA;
+                               p++;
+                               break;
+                       case '!':
+                               st->param = 0;
+                               st->nparams = 0;
+                               st->state = PS_DECGRI;
+                               p++;
+                               break;
+                       case '#':
+                               st->param = 0;
+                               st->nparams = 0;
+                               st->state = PS_DECGCI;
+                               p++;
+                               break;
+                       case '$':
+                               /* DECGCR Graphics Carriage Return */
+                               st->pos_x = 0;
+                               p++;
+                               break;
+                       case '-':
+                               /* DECGNL Graphics Next Line */
+                               st->pos_x = 0;
+                               if (st->pos_y < DECSIXEL_HEIGHT_MAX - 5 - 6)
+                                       st->pos_y += 6;
+                               else
+                                       st->pos_y = DECSIXEL_HEIGHT_MAX + 1;
+                               p++;
+                               break;
+                       default:
+                               if (*p >= '?' && *p <= '~') {  /* sixel characters */
+                                       if ((image->width < (st->pos_x + st->repeat_count) || image->height < 
(st->pos_y + 6))
+                                               && image->width < DECSIXEL_WIDTH_MAX && image->height < 
DECSIXEL_HEIGHT_MAX) {
+                                               sx = image->width * 2;
+                                               sy = image->height * 2;
+                                               while (sx < (st->pos_x + st->repeat_count) || sy < (st->pos_y 
+ 6)) {
+                                                       sx *= 2;
+                                                       sy *= 2;
+                                               }
+
+                                               if (sx > DECSIXEL_WIDTH_MAX)
+                                                       sx = DECSIXEL_WIDTH_MAX;
+                                               if (sy > DECSIXEL_HEIGHT_MAX)
+                                                       sy = DECSIXEL_HEIGHT_MAX;
+
+                                               status = image_buffer_resize(image, sx, sy);
+                                               if (status < 0)
+                                                       goto end;
+                                       }
+
+                                       if (st->color_index > image->ncolors)
+                                               image->ncolors = st->color_index;
+
+                                       if (st->pos_x + st->repeat_count > image->width)
+                                               st->repeat_count = image->width - st->pos_x;
+
+                                       if (st->repeat_count > 0 && st->pos_y - 5 < image->height) {
+                                               bits = *p - '?';
+                                               if (bits != 0) {
+                                                       sixel_vertical_mask = 0x01;
+                                                       if (st->repeat_count <= 1) {
+                                                               for (i = 0; i < 6; i++) {
+                                                                       if ((bits & sixel_vertical_mask) != 
0) {
+                                                                               pos = image->width * 
(st->pos_y + i) + st->pos_x;
+                                                                               image->data[pos] = 
st->color_index;
+                                                                               if (st->max_x < st->pos_x)
+                                                                                       st->max_x = st->pos_x;
+                                                                               if (st->max_y < (st->pos_y + 
i))
+                                                                                       st->max_y = st->pos_y 
+ i;
+                                                                       }
+                                                                       sixel_vertical_mask <<= 1;
+                                                               }
+                                                       } else {
+                                                               /* st->repeat_count > 1 */
+                                                               for (i = 0; i < 6; i++) {
+                                                                       if ((bits & sixel_vertical_mask) != 
0) {
+                                                                               c = sixel_vertical_mask << 1;
+                                                                               for (n = 1; (i + n) < 6; n++) 
{
+                                                                                       if ((bits & c) == 0)
+                                                                                               break;
+                                                                                       c <<= 1;
+                                                                               }
+                                                                               for (y = st->pos_y + i; y < 
st->pos_y + i + n; ++y) {
+                                                                                       for (x = st->pos_x; x 
< st->pos_x + st->repeat_count; ++x)
+                                                                                               
image->data[image->width * y + x] = st->color_index;
+                                                                               }
+                                                                               if (st->max_x < (st->pos_x + 
st->repeat_count - 1))
+                                                                                       st->max_x = st->pos_x 
+ st->repeat_count - 1;
+                                                                               if (st->max_y < (st->pos_y + 
i + n - 1))
+                                                                                       st->max_y = st->pos_y 
+ i + n - 1;
+                                                                               i += (n - 1);
+                                                                               sixel_vertical_mask <<= (n - 
1);
+                                                                       }
+                                                                       sixel_vertical_mask <<= 1;
+                                                               }
+                                                       }
+                                               }
+                                       }
+                                       if (st->repeat_count > 0)
+                                               st->pos_x += st->repeat_count;
+                                       st->repeat_count = 1;
+                               }
+                               p++;
+                               break;
+                       }
+                       break;
+
+               case PS_DECGRA:
+                       /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
+                       switch (*p) {
+                       case '\x1b':
+                               st->state = PS_ESC;
+                               p++;
+                               break;
+                       case '0':
+                       case '1':
+                       case '2':
+                       case '3':
+                       case '4':
+                       case '5':
+                       case '6':
+                       case '7':
+                       case '8':
+                       case '9':
+                               st->param = st->param * 10 + *p - '0';
+                               if (st->param > DECSIXEL_PARAMVALUE_MAX)
+                                       st->param = DECSIXEL_PARAMVALUE_MAX;
+                               p++;
+                               break;
+                       case ';':
+                               if (st->nparams < DECSIXEL_PARAMS_MAX)
+                                       st->params[st->nparams++] = st->param;
+                               st->param = 0;
+                               p++;
+                               break;
+                       default:
+                               if (st->nparams < DECSIXEL_PARAMS_MAX)
+                                       st->params[st->nparams++] = st->param;
+                               if (st->nparams > 0)
+                                       st->attributed_pad = st->params[0];
+                               if (st->nparams > 1)
+                                       st->attributed_pan = st->params[1];
+                               if (st->nparams > 2 && st->params[2] > 0)
+                                       st->attributed_ph = st->params[2];
+                               if (st->nparams > 3 && st->params[3] > 0)
+                                       st->attributed_pv = st->params[3];
+
+                               if (st->attributed_pan <= 0)
+                                       st->attributed_pan = 1;
+                               if (st->attributed_pad <= 0)
+                                       st->attributed_pad = 1;
+
+                               if (image->width < st->attributed_ph ||
+                                       image->height < st->attributed_pv) {
+                                       sx = st->attributed_ph;
+                                       if (image->width > st->attributed_ph)
+                                               sx = image->width;
+
+                                       sy = st->attributed_pv;
+                                       if (image->height > st->attributed_pv)
+                                               sy = image->height;
+
+                                       if (sx > DECSIXEL_WIDTH_MAX)
+                                               sx = DECSIXEL_WIDTH_MAX;
+                                       if (sy > DECSIXEL_HEIGHT_MAX)
+                                               sy = DECSIXEL_HEIGHT_MAX;
+
+                                       status = image_buffer_resize(image, sx, sy);
+                                       if (status < 0)
+                                               goto end;
+                               }
+                               st->state = PS_DECSIXEL;
+                               st->param = 0;
+                               st->nparams = 0;
+                       }
+                       break;
+
+               case PS_DECGRI:
+                       /* DECGRI Graphics Repeat Introducer ! Pn Ch */
+                       switch (*p) {
+                       case '\x1b':
+                               st->state = PS_ESC;
+                               p++;
+                               break;
+                       case '0':
+                       case '1':
+                       case '2':
+                       case '3':
+                       case '4':
+                       case '5':
+                       case '6':
+                       case '7':
+                       case '8':
+                       case '9':
+                               st->param = st->param * 10 + *p - '0';
+                               if (st->param > DECSIXEL_PARAMVALUE_MAX)
+                                       st->param = DECSIXEL_PARAMVALUE_MAX;
+                               p++;
+                               break;
+                       default:
+                               st->repeat_count = st->param;
+                               if (st->repeat_count == 0)
+                                       st->repeat_count = 1;
+                               st->state = PS_DECSIXEL;
+                               st->param = 0;
+                               st->nparams = 0;
+                               break;
+                       }
+                       break;
+
+               case PS_DECGCI:
+                       /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
+                       switch (*p) {
+                       case '\x1b':
+                               st->state = PS_ESC;
+                               p++;
+                               break;
+                       case '0':
+                       case '1':
+                       case '2':
+                       case '3':
+                       case '4':
+                       case '5':
+                       case '6':
+                       case '7':
+                       case '8':
+                       case '9':
+                               st->param = st->param * 10 + *p - '0';
+                               if (st->param > DECSIXEL_PARAMVALUE_MAX)
+                                       st->param = DECSIXEL_PARAMVALUE_MAX;
+                               p++;
+                               break;
+                       case ';':
+                               if (st->nparams < DECSIXEL_PARAMS_MAX)
+                                       st->params[st->nparams++] = st->param;
+                               st->param = 0;
+                               p++;
+                               break;
+                       default:
+                               st->state = PS_DECSIXEL;
+                               if (st->nparams < DECSIXEL_PARAMS_MAX)
+                                       st->params[st->nparams++] = st->param;
+                               st->param = 0;
+
+                               if (st->nparams > 0) {
+                                       st->color_index = 1 + st->params[0];  /* offset 1(background color) 
added */
+                                       if (st->color_index < 0)
+                                               st->color_index = 0;
+                                       else if (st->color_index >= DECSIXEL_PALETTE_MAX)
+                                               st->color_index = DECSIXEL_PALETTE_MAX - 1;
+                               }
+
+                               if (st->nparams > 4) {
+                                       st->image.palette_modified = 1;
+                                       if (st->params[1] == 1) {
+                                               /* HLS */
+                                               if (st->params[2] > 360)
+                                                       st->params[2] = 360;
+                                               if (st->params[3] > 100)
+                                                       st->params[3] = 100;
+                                               if (st->params[4] > 100)
+                                                       st->params[4] = 100;
+                                               image->palette[st->color_index]
+                                                   = hls_to_rgb(st->params[2], st->params[3], st->params[4]);
+                                       } else if (st->params[1] == 2) {
+                                               /* RGB */
+                                               if (st->params[2] > 100)
+                                                       st->params[2] = 100;
+                                               if (st->params[3] > 100)
+                                                       st->params[3] = 100;
+                                               if (st->params[4] > 100)
+                                                       st->params[4] = 100;
+                                               image->palette[st->color_index]
+                                                   = SIXEL_XRGB(st->params[2], st->params[3], st->params[4]);
+                                       }
+                               }
+                               break;
+                       }
+                       break;
+               default:
+                       break;
+               }
+       }
+
+       status = (0);
+
+end:
+       return status;
+}
+
+void
+sixel_parser_deinit(sixel_state_t *st)
+{
+       sixel_image_deinit(&st->image);
+}
diff --git a/src/sixel.h b/src/sixel.h
new file mode 100644
index 00000000..8e06ea56
--- /dev/null
+++ b/src/sixel.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) Hayaki Saito
+ * originally written by kmiya@cluti (https://github.com/saitoha/sixel/blob/master/fromsixel.c)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#define DECSIXEL_PARAMS_MAX 16
+#define DECSIXEL_PALETTE_MAX 1024
+#define DECSIXEL_PARAMVALUE_MAX 65535
+#define DECSIXEL_WIDTH_MAX 4096
+#define DECSIXEL_HEIGHT_MAX 4096
+
+typedef unsigned short sixel_color_no_t;
+typedef struct sixel_image_buffer {
+       sixel_color_no_t *data;
+       int width;
+       int height;
+       int palette[DECSIXEL_PALETTE_MAX];
+       sixel_color_no_t ncolors;
+       int palette_modified;
+       int use_private_register;
+} sixel_image_t;
+
+typedef enum parse_state {
+       PS_ESC        = 1,  /* ESC */
+       PS_DCS        = 2,  /* DCS */
+       PS_DECSIXEL   = 3,  /* DECSIXEL body part ", $, -, ? ... ~ */
+       PS_DECGRA     = 4,  /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
+       PS_DECGRI     = 5,  /* DECGRI Graphics Repeat Introducer ! Pn Ch */
+       PS_DECGCI     = 6,  /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
+} parse_state_t;
+
+typedef struct parser_context {
+       parse_state_t state;
+       int pos_x;
+       int pos_y;
+       int max_x;
+       int max_y;
+       int attributed_pan;
+       int attributed_pad;
+       int attributed_ph;
+       int attributed_pv;
+       int repeat_count;
+       int color_index;
+       int bgindex;
+       int param;
+       int nparams;
+       int params[DECSIXEL_PARAMS_MAX];
+       sixel_image_t image;
+} sixel_state_t;
+
+int sixel_parser_init(sixel_state_t *st, int fgcolor, int bgcolor, int use_private_register);
+int sixel_parser_parse(sixel_state_t *st, unsigned char *p, size_t len);
+int sixel_parser_set_default_color(sixel_state_t *st);
+int sixel_parser_finalize(sixel_state_t *st, unsigned char *pixels);
+void sixel_parser_deinit(sixel_state_t *st);
diff --git a/src/vte.cc b/src/vte.cc
index e6545ca7..2d7d56d1 100644
--- a/src/vte.cc
+++ b/src/vte.cc
@@ -3887,6 +3887,9 @@ Terminal::process_incoming_pcterm()
         /* After processing some data, do a hyperlink GC. The multiplier is totally arbitrary, feel free to 
fine tune. */
         _vte_ring_hyperlink_maybe_gc(m_screen->row_data, bytes_processed * 8);
 
+       if (m_sixel_enabled)
+               maybe_remove_images ();
+
        _vte_debug_print (VTE_DEBUG_WORK, ")");
        _vte_debug_print (VTE_DEBUG_IO,
                           "%" G_GSIZE_FORMAT " bytes in %" G_GSIZE_FORMAT " chunks left to process.\n",
@@ -4227,6 +4230,120 @@ Terminal::feed_child_binary(std::string_view const& data)
         connect_pty_write();
 }
 
+void
+VteTerminalPrivate::maybe_remove_images ()
+{
+       VteRing *ring = m_screen->row_data;
+       auto image_map = ring->image_map;
+       vte::image::image_object *image;
+
+       auto it = image_map->begin();
+
+       /* step 1. collect images out of scroll-back area */
+       while (it != image_map->end()) {
+               /* image_map is sorted from oldest to new */
+               image = it->second;
+
+               /* break if the image is still in scrollback area */
+               if (image->get_bottom () >= ring->start)
+                       break;
+
+               /* otherwise, delete it */
+               if (image->is_freezed ())
+                       ring->image_offscreen_resource_counter -= image->resource_size ();
+               else
+                       ring->image_onscreen_resource_counter -= image->resource_size ();
+               image_map->erase (image->get_bottom ());
+               delete image;
+               _vte_debug_print (VTE_DEBUG_IMAGE,
+                                 "deleted, offscreen: %zu\n",
+                                 ring->image_offscreen_resource_counter);
+       }
+
+       /* step 2. If the resource amount of freezed images (serialized into VteBoa)
+        * exceeds the upper limit, remove images from oldest.
+        */
+       if (ring->image_offscreen_resource_counter > m_freezed_image_limit) {
+               _vte_debug_print (VTE_DEBUG_IMAGE,
+                                 "checked, offscreen: %zu, max: %zu\n",
+                                 ring->image_offscreen_resource_counter,
+                                 m_freezed_image_limit);
+               while (it != image_map->end()) {
+                       image = it->second;
+                       ++it;
+
+                       /* remove */
+                       image_map->erase (image->get_bottom ());
+                       if (image->is_freezed ())
+                               ring->image_offscreen_resource_counter -= image->resource_size ();
+                       else
+                               ring->image_onscreen_resource_counter -= image->resource_size ();
+                       _vte_debug_print (VTE_DEBUG_IMAGE,
+                                         "deleted, offscreen: %zu\n",
+                                         ring->image_offscreen_resource_counter);
+                       delete image;
+
+                       /* break if the resource amount becomes less than limit */
+                       if (ring->image_offscreen_resource_counter <= m_freezed_image_limit)
+                               break;
+               }
+       }
+
+       /* step 3. shrink image stream with calling _vte_stream_advance_tail() */
+       if (ring->has_streams)
+               _vte_ring_shrink_image_stream (ring);
+}
+
+void
+VteTerminalPrivate::freeze_hidden_images_before_view_area (double start_pos, double end_pos)
+{
+       VteRing *ring = m_screen->row_data;
+       auto image_map = ring->image_map;
+       /* for images before view area */
+       vte::grid::row_t top_of_view = (vte::grid::row_t)start_pos;
+       typedef std::remove_pointer<decltype(ring->image_map)>::type map_t;
+
+       /* iterate from new to old */
+       for (auto it = map_t::reverse_iterator (image_map->lower_bound (top_of_view)); it != image_map->rend 
(); ++it) {
+               vte::image::image_object *image = it->second;
+               if (image->get_bottom () + 1 < end_pos)
+                       break;
+               if (! image->is_freezed ()) {
+                       ring->image_onscreen_resource_counter -= image->resource_size ();
+                       image->freeze ();
+                       ring->image_offscreen_resource_counter += image->resource_size ();
+                       _vte_debug_print (VTE_DEBUG_IMAGE,
+                                         "freezed, onscreen: %zu, offscreen: %zu\n",
+                                         ring->image_onscreen_resource_counter,
+                                         ring->image_offscreen_resource_counter);
+               }
+       }
+}
+
+void
+VteTerminalPrivate::freeze_hidden_images_after_view_area (double start_pos, double end_pos)
+{
+       VteRing *ring = m_screen->row_data;
+       auto image_map = ring->image_map;
+       vte::grid::row_t bottom_of_view = (vte::grid::row_t)(start_pos + m_row_count);
+
+       /* for images after view area */
+       for (auto it = image_map->lower_bound (bottom_of_view); it != image_map->end (); ++it) {
+               vte::image::image_object *image = it->second;
+               if (image->get_top () < end_pos + m_row_count)
+                       break;
+               if (image->get_top () > bottom_of_view && ! image->is_freezed ()) {
+                       ring->image_onscreen_resource_counter -= image->resource_size ();
+                       image->freeze ();
+                       ring->image_offscreen_resource_counter += image->resource_size ();
+                       _vte_debug_print (VTE_DEBUG_IMAGE,
+                                         "freezed, onscreen: %zu, offscreen: %zu\n",
+                                         ring->image_onscreen_resource_counter,
+                                         ring->image_offscreen_resource_counter);
+               }
+       }
+}
+
 void
 Terminal::send(vte::parser::u8SequenceBuilder const& builder,
                          bool c1,
@@ -7387,6 +7504,16 @@ Terminal::set_cell_height_scale(double scale)
         return true;
 }
 
+bool
+VteTerminalPrivate::set_freezed_image_limit(gulong limit)
+{
+        g_assert(limit >= 0);
+
+        m_freezed_image_limit = limit;
+
+        return true;
+}
+
 /* Read and refresh our perception of the size of the PTY. */
 void
 Terminal::refresh_size()
@@ -7550,6 +7677,14 @@ Terminal::screen_set_size(VteScreen *screen_,
                screen_->scroll_delta = new_scroll_delta;
 }
 
+bool
+VteTerminalPrivate::set_sixel_enabled(gboolean enabled)
+{
+        m_sixel_enabled = enabled;
+
+        return true;
+}
+
 void
 Terminal::set_size(long columns,
                              long rows)
@@ -7634,6 +7769,13 @@ Terminal::vadjustment_value_changed()
        if (!_vte_double_equal(dy, 0)) {
                _vte_debug_print(VTE_DEBUG_ADJ,
                            "Scrolling by %f\n", dy);
+
+                if (dy > 0.0) {
+                       freeze_hidden_images_before_view_area (adj, adj - dy);
+                } else {
+                       freeze_hidden_images_after_view_area (adj, adj - dy);
+                }
+
                 invalidate_all();
                 match_contents_clear();
                emit_text_scrolled(dy);
@@ -7713,6 +7855,10 @@ Terminal::Terminal(vte::platform::Widget* w,
         m_overline_position = 1;
         m_regex_underline_position = 1;
 
+        /* Image */
+        m_freezed_image_limit = VTE_DEFAULT_FREEZED_IMAGE_LIMIT;
+        m_sixel_enabled = TRUE;
+
         reset_default_attributes(true);
 
        /* Set up the desired palette. */
@@ -7741,6 +7887,9 @@ Terminal::Terminal(vte::platform::Widget* w,
         save_cursor(&m_normal_screen);
         save_cursor(&m_alternate_screen);
 
+       /* Initialize SIXEL color register */
+       sixel_parser_set_default_color(&m_sixel_state);
+
        /* Matching data. */
         m_match_span.clear(); // FIXMEchpe unnecessary
        match_hilite_clear(); // FIXMEchpe unnecessary
@@ -9193,6 +9342,7 @@ Terminal::widget_draw(cairo_t *cr)
         int allocated_width, allocated_height;
         int extra_area_for_cursor;
         bool text_blink_enabled_now;
+        Ring *ring = m_screen->row_data;
         gint64 now = 0;
 
         if (!gdk_cairo_get_clip_rectangle (cr, &clip_rect))
@@ -9220,6 +9370,32 @@ Terminal::widget_draw(cairo_t *cr)
                                  get_color(VTE_DEFAULT_BG), m_background_alpha);
         }
 
+       /* Draw SIXEL images */
+       if (m_sixel_enabled) {
+               vte::grid::row_t top_row = first_displayed_row();
+               vte::grid::row_t bottom_row = last_displayed_row();
+               auto image_map = ring->image_map;
+               auto it = image_map->lower_bound (top_row);
+               for (; it != image_map->end (); ++it) {
+                       vte::image::image_object *image = it->second;
+                       if (image->get_top () > bottom_row)
+                               break;
+                       if (image->is_freezed ()) {
+                               ring->image_offscreen_resource_counter -= image->resource_size ();
+                               image->thaw ();
+                               ring->image_onscreen_resource_counter += image->resource_size ();
+                               _vte_debug_print (VTE_DEBUG_IMAGE,
+                                                 "thawn, onscreen: %zu, offscreen: %zu\n",
+                                                 ring->image_onscreen_resource_counter,
+                                                 ring->image_offscreen_resource_counter);
+                       }
+                       /* Display images */
+                       int x = m_padding.left + image->get_left () * m_char_width;
+                       int y = m_padding.top + (image->get_top () - m_screen->scroll_delta) * m_char_height;
+                       image->paint (cr, x, y);
+               }
+       }
+
         /* Clip vertically, for the sake of smooth scrolling. We want the top and bottom paddings to be 
unused.
          * Don't clip horizontally so that antialiasing can legally overflow to the right padding. */
         cairo_save(cr);
@@ -9903,6 +10079,14 @@ Terminal::reset(bool clear_tabstops,
        m_mouse_smooth_scroll_delta = 0.;
        /* Clear modifiers. */
        m_modifiers = 0;
+       /* Reset SIXEL display mode */
+       m_sixel_display_mode = FALSE;
+       /* Reset SIXEL-scrolls-right mode */
+       m_sixel_scrolls_right = FALSE;
+       /* Reset privae color register mode */
+       m_sixel_use_private_register = FALSE;
+       /* Reset SIXEL color register */
+       sixel_parser_set_default_color(&m_sixel_state);
         /* Reset the saved cursor. */
         save_cursor(&m_normal_screen);
         save_cursor(&m_alternate_screen);
diff --git a/src/vte/vteterminal.h b/src/vte/vteterminal.h
index bdede897..25cd0f0a 100644
--- a/src/vte/vteterminal.h
+++ b/src/vte/vteterminal.h
@@ -503,6 +503,24 @@ gboolean vte_terminal_write_contents_sync (VteTerminal *terminal,
                                            GCancellable *cancellable,
                                            GError **error) _VTE_CXX_NOEXCEPT _VTE_GNUC_NONNULL(1) 
_VTE_GNUC_NONNULL(2);
 
+/* Images */
+
+/* Set or get maximum storage size for offscreen freezed images */
+_VTE_PUBLIC
+void vte_terminal_set_freezed_image_limit(VteTerminal *terminal,
+                                          gulong limit) _VTE_GNUC_NONNULL(1);
+
+_VTE_PUBLIC
+gulong vte_terminal_get_freezed_image_limit(VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
+
+/* Set or get whether the SIXEL graphics feature is enabled */
+_VTE_PUBLIC
+void vte_terminal_set_sixel_enabled (VteTerminal *terminal,
+                                     gboolean enabled) _VTE_GNUC_NONNULL(1);
+
+_VTE_PUBLIC
+gboolean vte_terminal_get_sixel_enabled (VteTerminal *terminal) _VTE_GNUC_NONNULL(1);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(VteTerminal, g_object_unref)
 
 G_END_DECLS
diff --git a/src/vtedefines.hh b/src/vtedefines.hh
index 8aa4d9dc..8f130eac 100644
--- a/src/vtedefines.hh
+++ b/src/vtedefines.hh
@@ -88,6 +88,7 @@
 #define VTE_MAX_PROCESS_TIME           100
 #define VTE_CELL_BBOX_SLACK            1
 #define VTE_DEFAULT_UTF8_AMBIGUOUS_WIDTH 1
+#define VTE_DEFAULT_FREEZED_IMAGE_LIMIT (16 * 1024 * 1024)  /* 16 MB */
 
 #define VTE_UTF8_BPC                    (4) /* Maximum number of bytes used per UTF-8 character */
 
diff --git a/src/vtegtk.cc b/src/vtegtk.cc
index 443f9479..c9dfebc4 100644
--- a/src/vtegtk.cc
+++ b/src/vtegtk.cc
@@ -1824,6 +1824,17 @@ vte_terminal_class_init(VteTerminalClass *klass)
                                      NULL,
                                      (GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS | 
G_PARAM_EXPLICIT_NOTIFY));
 
+        /**
+         * VteTerminal:freezed-image-limit:
+         *
+         * This property indicates allowed max storage size for offscreen freezed images
+         */
+        pspecs[PROP_FREEZED_IMAGE_LIMIT] =
+                g_param_spec_ulong ("freezed-image-limit", NULL, NULL,
+                                    0, G_MAXULONG, VTE_DEFAULT_FREEZED_IMAGE_LIMIT,
+                                    (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | 
G_PARAM_EXPLICIT_NOTIFY));
+
+
         /**
          * VteTerminal:input-enabled:
          *
@@ -1910,6 +1921,17 @@ vte_terminal_class_init(VteTerminalClass *klass)
                                       TRUE,
                                       (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | 
G_PARAM_EXPLICIT_NOTIFY));
 
+        /**
+         * VteTerminal:sixel-enabled:
+         *
+         * Controls whether the SIXEL graphics feature is enabled.
+         */
+        pspecs[PROP_SIXEL_ENABLED] =
+                g_param_spec_boolean ("sixel-enabled", NULL, NULL,
+                                      TRUE,
+                                      (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | 
G_PARAM_EXPLICIT_NOTIFY));
+
+
         /**
          * VteTerminal:text-blink-mode:
          *
@@ -5663,3 +5685,66 @@ catch (...)
 
 } // namespace glib
 } // namespace vte
+
+/**
+ * vte_terminal_set_freezed_image_limit:
+ * @terminal: a #VteTerminal
+ * @limit: 0 to G_MAXINT
+ *
+ * Set allowed max storage size for offscreen freezed images
+ */
+void
+vte_terminal_set_freezed_image_limit(VteTerminal *terminal, gulong limit)
+{
+        g_return_if_fail(VTE_IS_TERMINAL(terminal));
+
+        if (IMPL(terminal)->set_freezed_image_limit(limit))
+                g_object_notify_by_pspec(G_OBJECT(terminal), pspecs[PROP_FREEZED_IMAGE_LIMIT]);
+}
+
+/**
+ * vte_terminal_get_freezed_image_limit:
+ * @terminal: a #VteTerminal
+ *
+ * Get allowed max storage size for offscreen freezed images
+ */
+gulong
+vte_terminal_get_freezed_image_limit(VteTerminal *terminal)
+{
+        g_return_val_if_fail(VTE_IS_TERMINAL(terminal), NULL);
+
+        return IMPL(terminal)->m_freezed_image_limit;
+}
+
+/**
+ * vte_terminal_set_sixel_enabled:
+ * @terminal: a #VteTerminal
+ * @enabled: %TRUE enables SIXEL graphics feature.
+ *
+ * Set whether to enable SIXEL graphics feature
+ */
+void
+vte_terminal_set_sixel_enabled (VteTerminal *terminal, gboolean enabled)
+{
+        g_return_if_fail(VTE_IS_TERMINAL(terminal));
+
+        if (IMPL(terminal)->set_sixel_enabled(enabled))
+                g_object_notify_by_pspec(G_OBJECT(terminal), pspecs[PROP_SIXEL_ENABLED]);
+}
+
+/**
+ * vte_terminal_set_sixel_enabled:
+ * @terminal: a #VteTerminal
+ *
+ * Get whether the SIXEL graphics feature is enabled.
+ *
+ * Returns: %TRUE if SIXEL graphics feature is enabled.
+ */
+
+gboolean
+vte_terminal_get_sixel_enabled (VteTerminal *terminal)
+{
+        g_return_val_if_fail(VTE_IS_TERMINAL(terminal), NULL);
+
+        return IMPL(terminal)->m_sixel_enabled;
+}
diff --git a/src/vtegtk.hh b/src/vtegtk.hh
index ae9fb08c..2ebe22bc 100644
--- a/src/vtegtk.hh
+++ b/src/vtegtk.hh
@@ -81,6 +81,7 @@ enum {
         PROP_ENCODING,
         PROP_FONT_DESC,
         PROP_FONT_SCALE,
+        PROP_FREEZED_IMAGE_LIMIT,
         PROP_HYPERLINK_HOVER_URI,
         PROP_ICON_TITLE,
         PROP_INPUT_ENABLED,
@@ -93,6 +94,7 @@ enum {
         PROP_TEXT_BLINK_MODE,
         PROP_WINDOW_TITLE,
         PROP_WORD_CHAR_EXCEPTIONS,
+        PROP_SIXEL_ENABLED,
         LAST_PROP,
 
         /* override properties */
diff --git a/src/vteimage.cc b/src/vteimage.cc
new file mode 100644
index 00000000..628d01d4
--- /dev/null
+++ b/src/vteimage.cc
@@ -0,0 +1,275 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <config.h>
+#include <glib.h>
+#include <stdio.h>
+#include "vteimage.h"
+#include "vteinternal.hh"
+
+namespace vte {
+
+namespace image {
+
+/* image_object implementation */
+image_object::image_object (cairo_surface_t *surface, gint pixelwidth, gint pixelheight, gint col, gint row, 
gint w, gint h, _VteStream *stream)
+{
+       m_pixelwidth = pixelwidth;
+       m_pixelheight = pixelheight;
+       m_left = col;
+       m_top = row;
+       m_width = w;
+       m_height = h;
+       m_surface = surface;
+       m_stream = stream;
+
+       g_object_ref (m_stream);
+}
+
+image_object::~image_object ()
+{
+       if (m_surface)
+               cairo_surface_destroy (m_surface);
+       g_object_unref (m_stream);
+}
+
+glong
+image_object::get_left () const
+{
+       return (glong)m_left;
+}
+
+glong
+image_object::get_top () const
+{
+       return (glong)m_top;
+}
+
+glong
+image_object::get_bottom () const
+{
+       return (glong)(m_top + m_height - 1);
+}
+
+gulong
+image_object::get_stream_position () const
+{
+       return m_position;
+}
+
+/* Indicate whether the image is serialized to the stream */
+bool
+image_object::is_freezed () const
+{
+       return (m_surface == NULL);
+}
+
+/* Test whether this image includes given image */
+bool
+image_object::includes (const image_object *other) const
+{
+       g_assert_true (other != NULL);
+
+       return other->m_left >= m_left &&
+              other->m_top >= m_top &&
+              other->m_left + other->m_width <= m_left + m_width &&
+              other->m_top + other->m_height <= m_top + m_height;
+}
+
+size_t
+image_object::resource_size () const
+{
+       size_t result_size;
+
+       if (is_freezed ()) {
+               /* If freezed, return the size sent to VteBoa.
+                 * In reality, it may be more compressed on the real storage.
+                 */
+               result_size = m_nwrite;
+       } else {
+               /* If not freezed, return the pixel buffer size
+                 * width x height x 4
+                 */
+               result_size = m_pixelwidth * m_pixelheight * 4;
+       }
+
+       return result_size;
+}
+
+/* Deserialize the cairo image from the temporary file */
+bool
+image_object::thaw ()
+{
+       if (m_surface)
+               return true;
+       if (m_position < _vte_stream_tail (m_stream))
+               return false;
+
+       m_nread = 0;
+       m_surface = cairo_image_surface_create_from_png_stream ((cairo_read_func_t)read_callback, this);
+       if (! m_surface)
+               return false;
+
+       return true;
+}
+
+/* Serialize the image for saving RAM */
+void
+image_object::freeze ()
+{
+       cairo_status_t status;
+       double x_scale, y_scale;
+
+       if (! m_surface)
+               return;
+
+       m_position = _vte_stream_head (m_stream);
+       m_nwrite = 0;
+
+       cairo_surface_get_device_scale (m_surface, &x_scale, &y_scale);
+       if (x_scale != 1.0 || y_scale != 1.0) {
+               /* If device scale exceeds 1.0, large size of PNG image created with 
cairo_surface_write_to_png_stream()
+                 * So we need to convert m_surface into an image surface with resizing it.
+                 */
+               cairo_surface_t *image_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 
m_pixelwidth, m_pixelheight);
+               cairo_t *cr = cairo_create (image_surface);
+               paint (cr, 0, 0);
+               cairo_destroy (cr);
+               cairo_surface_destroy (m_surface);
+               m_surface = image_surface;
+       }
+       status = cairo_surface_write_to_png_stream (m_surface, (cairo_write_func_t)write_callback, this);
+       if (status == CAIRO_STATUS_SUCCESS) {
+               cairo_surface_destroy (m_surface);
+               m_surface = NULL;
+       }
+}
+
+/* Merge another image into this image */
+bool
+image_object::combine (image_object *other, gulong char_width, gulong char_height)
+{
+       cairo_t *cr;
+
+       g_assert_true (other != NULL);
+
+       gulong offsetx = (other->m_left - m_left) * char_width;
+       gulong offsety = (other->m_top - m_top) * char_height;
+
+       if (is_freezed ())
+               if (! thaw ())
+                       return false;
+
+       if (other->is_freezed ())
+               if (! other->thaw ())
+                       return false;
+
+       cr = cairo_create (m_surface);
+       cairo_rectangle (cr, offsetx, offsety, m_pixelwidth, m_pixelheight);
+       cairo_clip (cr);
+       cairo_set_source_surface (cr, other->m_surface, offsetx, offsety);
+       cairo_paint (cr);
+       cairo_destroy (cr);
+
+       return true;
+}
+
+bool
+image_object::unite (image_object *other, gulong char_width, gulong char_height)
+{
+       if (is_freezed ())
+               if (! thaw ())
+                       return false;
+
+       gint new_left = std::min (m_left, other->m_left);
+       gint new_top = std::min (m_top, other->m_top);
+       gint new_width = std::max (m_left + m_width, other->m_left + other->m_width) - new_left;
+       gint new_height = std::max (m_top + m_height, other->m_top + other->m_width) - new_top;
+       gint pixelwidth = new_width * char_width;
+       gint pixelheight = new_height * char_height;
+       gint offsetx = (m_left - new_left) * char_width;
+       gint offsety = (m_top - new_top) * char_height;
+
+       cairo_surface_t * new_surface = cairo_surface_create_similar (other->m_surface, 
CAIRO_CONTENT_COLOR_ALPHA, m_pixelwidth, m_pixelheight);
+       cairo_t *cr = cairo_create (new_surface);
+       cairo_rectangle (cr, offsetx, offsety, m_pixelwidth, m_pixelheight);
+       cairo_clip (cr);
+       cairo_set_source_surface (cr, m_surface, offsetx, offsety);
+       cairo_paint (cr);
+       cairo_destroy (cr);
+
+       cairo_surface_destroy (m_surface);
+
+       m_left = new_left;
+       m_top = new_top;
+       m_width = new_width;
+       m_height = new_height;
+       m_pixelwidth = pixelwidth;
+       m_pixelheight = pixelheight;
+       m_surface = new_surface;
+
+       return combine (other, char_width, char_height);
+}
+
+/* Paint the image into given cairo rendering context */
+bool
+image_object::paint (cairo_t *cr, gint offsetx, gint offsety)
+{
+       if (is_freezed ())
+               if (! thaw ())
+                       return false;
+
+       cairo_save (cr);
+       cairo_rectangle (cr, offsetx, offsety, m_pixelwidth, m_pixelheight);
+       cairo_clip (cr);
+       cairo_set_source_surface (cr, m_surface, offsetx, offsety);
+       cairo_paint (cr);
+       cairo_restore (cr);
+
+       return true;
+}
+
+/* callback routines for stream I/O */
+
+cairo_status_t
+image_object::read_callback (void *closure, char *data, unsigned int length)
+{
+       image_object *image = (image_object *)closure;
+
+       g_assert_true (image != NULL);
+
+       _vte_stream_read (image->m_stream, image->m_position + image->m_nread, data, length);
+       image->m_nread += length;
+
+       return CAIRO_STATUS_SUCCESS;
+}
+
+cairo_status_t
+image_object::write_callback (void *closure, const char *data, unsigned int length)
+{
+       image_object *image = (image_object *)closure;
+
+       g_assert_true (image != NULL);
+
+       _vte_stream_append (image->m_stream, data, length);
+       image->m_nwrite += length;
+
+       return CAIRO_STATUS_SUCCESS;
+}
+
+} // namespace image
+
+} // namespace vte
diff --git a/src/vteimage.h b/src/vteimage.h
new file mode 100644
index 00000000..76d4af20
--- /dev/null
+++ b/src/vteimage.h
@@ -0,0 +1,61 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <pango/pangocairo.h>
+#include "vtestream.h"
+
+namespace vte {
+
+namespace image {
+
+struct image_object {
+private:
+       gint m_left;                /* left position in cell unit at the vte virtual screen */
+       gint m_width;               /* width in cell unit */
+       gint m_top;                 /* top position in cell unit at the vte virtual screen */
+       gint m_height;              /* height in cell unit */
+       VteStream *m_stream;        /* NULL if it's serialized */
+       gint m_pixelwidth;          /* image width in pixels */
+       gint m_pixelheight;         /* image hieght in pixels */
+       gulong m_position;          /* indicates the position at the stream if it's serialized */
+       size_t m_nread;             /* private use: for read callback */
+       size_t m_nwrite;            /* private use: for write callback */
+       cairo_surface_t *m_surface; /* internal cairo image */
+public:
+       explicit image_object (cairo_surface_t *surface, gint pixelwidth, gint pixelheight, gint col, gint 
row, gint w, gint h, _VteStream *stream);
+       ~image_object ();
+       glong get_left () const;
+       glong get_top () const;
+       glong get_bottom () const;
+       gulong get_stream_position () const;
+       bool is_freezed () const;
+       bool includes (const image_object *rhs) const;
+       size_t resource_size () const;
+       void freeze ();
+       bool thaw ();
+       bool combine (image_object *rhs, gulong char_width, gulong char_height);
+       bool unite (image_object *rhs, gulong char_width, gulong char_height);
+       bool paint (cairo_t *cr, gint offsetx, gint offsety);
+public:
+       static cairo_status_t read_callback (void *closure, char *data, unsigned int length);
+       static cairo_status_t write_callback (void *closure, const char *data, unsigned int length);
+};
+
+} // namespace image
+
+} // namespace vte
diff --git a/src/vteinternal.hh b/src/vteinternal.hh
index bc75888e..6fc4b923 100644
--- a/src/vteinternal.hh
+++ b/src/vteinternal.hh
@@ -48,6 +48,7 @@
 
 #include "vtepcre2.h"
 #include "vteregexinternal.hh"
+#include "sixel.h"
 
 #include "chunk.hh"
 #include "pty.hh"
@@ -752,6 +753,14 @@ public:
                                                             this),
                                                   "mouse-autoscroll-timer"};
 
+        /* SIXEL feature */
+        gboolean m_sixel_display_mode;
+        gboolean m_sixel_scrolls_right;
+        gboolean m_sixel_use_private_register;
+        sixel_state_t m_sixel_state;
+        gulong m_freezed_image_limit;
+        gboolean m_sixel_enabled;
+
        /* State variables for handling match checks. */
         int m_match_regex_next_tag{0};
         auto regex_match_next_tag() noexcept { return m_match_regex_next_tag++; }
@@ -1503,12 +1512,14 @@ public:
                           GError** error);
         bool set_font_desc(PangoFontDescription const* desc);
         bool set_font_scale(double scale);
+        bool set_freezed_image_limit(gulong limit);
         bool set_input_enabled(bool enabled);
         bool set_mouse_autohide(bool autohide);
         bool set_rewrap_on_resize(bool rewrap);
         bool set_scrollback_lines(long lines);
         bool set_scroll_on_keystroke(bool scroll);
         bool set_scroll_on_output(bool scroll);
+        bool set_sixel_enabled(bool enabled);
         bool set_word_char_exceptions(std::optional<std::string_view> stropt);
         void set_clear_background(bool setting);
 
@@ -1585,6 +1596,7 @@ public:
                                    vte::grid::row_t end_row,
                                    vte::grid::column_t end_col);
 
+        void seq_load_sixel(char const* p);
         void subscribe_accessible_events();
         void select_text(vte::grid::column_t start_col,
                          vte::grid::row_t start_row,
@@ -1668,6 +1680,11 @@ public:
 #include "parser-cmd.hh"
 #undef _VTE_CMD
 #undef _VTE_NOP
+
+private:
+        void freeze_hidden_images_before_view_area(double start_pos, double end_pos);
+        void freeze_hidden_images_after_view_area(double start_pos, double end_pos);
+        void maybe_remove_images();
 };
 
 } // namespace terminal
diff --git a/src/vteseq.cc b/src/vteseq.cc
index ba9a2df6..f9220e05 100644
--- a/src/vteseq.cc
+++ b/src/vteseq.cc
@@ -35,6 +35,7 @@
 #include "vtegtk.hh"
 #include "caps.hh"
 #include "debug.h"
+#include "sixel.h"
 
 #define BEL_C0 "\007"
 #define ST_C0 _VTE_CAP_ST
@@ -589,6 +590,20 @@ Terminal::set_mode_private(int mode,
                 maybe_apply_bidi_attributes(VTE_BIDI_FLAG_AUTO);
                 break;
 
+#if 0
+        /* FIXME-hpj */
+
+        case vte::terminal::modes::Private::eSIXEL_DISPLAY_MODE:
+                /* 80: SIXEL display mode(DECSDM). */
+                break;
+        case vte::terminal::modes::Private::eSIXEL_USE_PRIVATE_REGISTER:
+                /* 1070: private color register mode. */
+                break;
+        case vtw::terminal::modes::Private::eSIXEL_SCROLLS_RIGHT:
+                /* 8452: SIXEL-scrolls-right mode. */
+                break;
+#endif
+
         default:
                 break;
         }
@@ -2376,7 +2391,7 @@ Terminal::DA1(vte::parser::Sequence const& seq)
         if (seq.collect1(0, 0) != 0)
                 return;
 
-        reply(seq, VTE_REPLY_DECDA1R, {65, 1, 9});
+        reply(seq, VTE_REPLY_DECDA1R, {65, 1, 9, 4});
 }
 
 void
@@ -3060,6 +3075,151 @@ Terminal::DECIC(vte::parser::Sequence const& seq)
          */
 }
 
+static void
+vte_sequence_handler_device_control_string (VteTerminalPrivate *that, GValueArray *params)
+{
+       GValue *value;
+       char *dcs = NULL;
+       char *p;
+       glong cmd = 0;
+       gint param;
+       size_t nparams = 0;
+       gint dcsparams[DECSIXEL_PARAMS_MAX];
+
+       value = g_value_array_get_nth(params, 0);
+       if (!value)
+               return;
+       if (G_VALUE_HOLDS_STRING(value)) {
+               /* Copy the string into the buffer. */
+               dcs = g_value_dup_string(value);
+       }
+       else if (G_VALUE_HOLDS_POINTER(value)) {
+               dcs = that->ucs4_to_utf8((const guchar *)g_value_get_pointer (value));
+       }
+       if (! dcs)
+               return;
+
+       for (p = dcs; p; ++p) {
+               switch (*p) {
+               case ' ' ... '/':
+                       cmd = cmd << 8 | *p;
+                       if (cmd > (1 << 24))
+                               goto end;
+                       break;
+               case '0' ... '9':
+                       if (param < 0)
+                               param = 0;
+                       param = param * 10 + *p - '0';
+                       break;
+               case ';':
+                       if (param < 0)
+                               param = 0;
+                       if (nparams < sizeof(dcsparams) / sizeof(dcsparams[0]))
+                               dcsparams[nparams++] = param;
+                       param = 0;
+                       break;
+               case '@' ... '~':
+                       cmd = cmd << 8 | *p;
+                       goto dispatch;
+               default:
+                   goto end;
+               }
+       }
+
+dispatch:
+       switch (cmd) {
+       case 'q':
+               if (that->m_sixel_enabled)
+                       that->seq_load_sixel(dcs);
+               break;
+       default:
+               break;
+       }
+
+end:
+       g_free(dcs);
+}
+
+void
+VteTerminalPrivate::seq_load_sixel(char const* dcs)
+{
+       unsigned char *pixels = NULL;
+       auto fg = get_color(VTE_DEFAULT_FG);
+       auto bg = get_color(VTE_DEFAULT_BG);
+       int nfg = fg->red >> 8 | fg->green >> 8 << 8 | fg->blue >> 8 << 16;
+       int nbg = bg->red >> 8 | bg->green >> 8 << 8 | bg->blue >> 8 << 16;
+       glong left, top, width, height;
+       glong pixelwidth, pixelheight;
+       glong i;
+       cairo_surface_t *image_surface, *surface;
+       cairo_t *cr;
+
+       /* Parse images */
+       if (sixel_parser_init(&m_sixel_state, nfg, nbg, m_sixel_use_private_register) < 0) {
+               sixel_parser_deinit(&m_sixel_state);
+               return;
+       }
+       if (sixel_parser_parse(&m_sixel_state, (unsigned char *)dcs, strlen(dcs)) < 0) {
+               sixel_parser_deinit(&m_sixel_state);
+               return;
+       }
+       pixels = (unsigned char *)g_malloc(m_sixel_state.image.width * m_sixel_state.image.height * 4);
+       if (! pixels) {
+               sixel_parser_deinit(&m_sixel_state);
+               return;
+       }
+       if (sixel_parser_finalize(&m_sixel_state, pixels) < 0) {
+               sixel_parser_deinit(&m_sixel_state);
+               return;
+       }
+       sixel_parser_deinit(&m_sixel_state);
+
+       if (m_sixel_display_mode)
+               seq_home_cursor();
+
+       /* Append new image to VteRing */
+       left = m_screen->cursor.col;
+       top = m_screen->cursor.row;
+       width = (m_sixel_state.image.width + m_char_width - 1) / m_char_width;
+       height = (m_sixel_state.image.height + m_char_height - 1) / m_char_height;
+       pixelwidth = m_sixel_state.image.width;
+       pixelheight = m_sixel_state.image.height;
+
+       /* create image surface (in-memory, device-independant) */
+       image_surface = cairo_image_surface_create_for_data (pixels, CAIRO_FORMAT_ARGB32, pixelwidth, 
pixelheight, pixelwidth * 4);
+       g_assert (image_surface);
+
+       /* create device-dependant surface compatible with m_widget */
+       surface = gdk_window_create_similar_surface (gtk_widget_get_window (m_widget), 
CAIRO_CONTENT_COLOR_ALPHA, pixelwidth, pixelheight);
+       g_assert (surface);
+
+       /* copy image surface to a device-compatible surface */
+       cr = cairo_create (surface);
+       cairo_set_source_surface (cr, image_surface, 0, 0);
+       cairo_paint (cr);
+       cairo_destroy (cr);
+       cairo_surface_destroy (image_surface);
+       free (pixels);
+
+       /* create image object */
+       _vte_ring_append_image (m_screen->row_data, surface, pixelwidth, pixelheight, left, top, width, 
height);
+
+       /* Erase characters on the image */
+       for (i = 0; i < height; ++i) {
+               seq_erase_characters(width);
+               if (i == height - 1) {
+                       if (m_sixel_scrolls_right)
+                               seq_cursor_forward(width);
+                       else
+                               cursor_down(true);
+               } else {
+                       cursor_down(true);
+               }
+       }
+       if (m_sixel_display_mode)
+               seq_home_cursor();
+}
+
 void
 Terminal::DECINVM(vte::parser::Sequence const& seq)
 {
@@ -8766,5 +8926,59 @@ Terminal::XTERM_WM(vte::parser::Sequence const& seq)
         }
 }
 
+#if 0
+/* FIXME-hpj */
+
+/* graphics attributes */
+static void
+vte_sequence_handler_graphics_attributes(VteTerminalPrivate *that, GValueArray *params)
+{
+       if (params == NULL || params->n_values != 3) {
+               return;
+       }
+       GValue* value = g_value_array_get_nth(params, 0);
+       if (!G_VALUE_HOLDS_LONG(value)) {
+               return;
+       }
+       auto param = g_value_get_long(value);
+
+       char buf[128];
+       long arg1, arg2;
+       arg1 = arg2 = -1;
+       if (params->n_values > 1) {
+               value = g_value_array_get_nth(params, 1);
+               if (G_VALUE_HOLDS_LONG(value)) {
+                       arg1 = g_value_get_long(value);
+               }
+       }
+       if (params->n_values > 2) {
+               value = g_value_array_get_nth(params, 2);
+               if (G_VALUE_HOLDS_LONG(value)) {
+                       arg2 = g_value_get_long(value);
+               }
+       }
+
+       switch (arg1) {
+       case 1:
+               switch (arg2) {
+               case 1:
+                       that->feed_child(_VTE_CAP_CSI "?1;0;256S", -1);
+                       break;
+               case 2:
+                       that->feed_child(_VTE_CAP_CSI "?1;0;256S", -1);
+                       break;
+               case 3:
+                       that->feed_child(_VTE_CAP_CSI "?1;3;0S", -1);
+                       break;
+               default:
+                       break;
+               }
+       default:
+                g_snprintf(buf, sizeof(buf), _VTE_CAP_CSI "?%ld;1;0S", arg1);
+               break;
+       }
+}
+#endif
+
 } // namespace terminal
 } // namespace vte


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]