diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index 5c84974e03..3c64e8f7ee 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -1599,6 +1599,12 @@ enum AVPacketSideDataType {
      */
     AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
 
+    /**
+     * The disposal method that should be used with the frame. If missing,
+     * the frame will not be disposed. This contains exactly one byte.
+     */
+    AV_PKT_DATA_GIF_FRAME_DISPOSAL,
+
     /**
      * The number of side data elements (in fact a bit more than it).
      * This is not part of the public API/ABI in the sense that it may
diff --git a/libavcodec/gif.c b/libavcodec/gif.c
index d9c99d52cf..758e16b83d 100644
--- a/libavcodec/gif.c
+++ b/libavcodec/gif.c
@@ -74,11 +74,35 @@ static int pick_palette_entry(const uint8_t *buf, int linesize, int w, int h)
     return -1;
 }
 
-static int gif_image_write_image(AVCodecContext *avctx,
-                                 uint8_t **bytestream, uint8_t *end,
-                                 const uint32_t *palette,
-                                 const uint8_t *buf, const int linesize,
-                                 AVPacket *pkt)
+// returns true if any of the pixels are transparent
+static int is_image_translucent(AVCodecContext *avctx,
+                                const uint32_t *palette,
+                                const uint8_t *buf, const int linesize)
+{
+    GIFContext *s = avctx->priv_data;
+    int trans = s->transparent_index;
+    int p;
+    const int m = avctx->width * avctx->height ;
+
+    if( trans < 0 ) {
+        return 0;
+    }
+
+    for( p=0; p<m; ++p ) {
+        if( buf[p] == trans ) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+// writes an opaque image. ie an image with no transparency.
+// it also works, and should be used, for a first image.
+static int gif_image_write_opaque(AVCodecContext *avctx,
+                                  uint8_t **bytestream, uint8_t *end,
+                                  const uint32_t *palette,
+                                  const uint8_t *buf, const int linesize,
+                                  AVPacket *pkt)
 {
     GIFContext *s = avctx->priv_data;
     int len = 0, height = avctx->height, width = avctx->width, x, y;
@@ -86,6 +110,7 @@ static int gif_image_write_image(AVCodecContext *avctx,
     int honor_transparency = (s->flags & GF_TRANSDIFF) && s->last_frame && !palette;
     const uint8_t *ptr;
 
+
     /* Crop image */
     if ((s->flags & GF_OFFSETTING) && s->last_frame && !palette) {
         const uint8_t *ref = s->last_frame->data[0];
@@ -137,6 +162,11 @@ static int gif_image_write_image(AVCodecContext *avctx,
                width, height, x_start, y_start, avctx->width, avctx->height);
     }
 
+    uint8_t *frame_disposal = av_packet_new_side_data(pkt, AV_PKT_DATA_GIF_FRAME_DISPOSAL, 1);
+    if (!frame_disposal)
+        return AVERROR(ENOMEM);
+    *frame_disposal = GCE_DISPOSAL_INPLACE;
+
     /* image block */
     bytestream_put_byte(bytestream, GIF_IMAGE_SEPARATOR);
     bytestream_put_le16(bytestream, x_start);
@@ -214,6 +244,164 @@ static int gif_image_write_image(AVCodecContext *avctx,
     return 0;
 }
 
+// wrtites an image that may contain transparency
+// this might work for opaque images as well, but will be less optimized.
+static int gif_image_write_translucent(AVCodecContext *avctx,
+                                       uint8_t **bytestream, uint8_t *end,
+                                       const uint32_t *palette,
+                                       const uint8_t *buf, const int linesize,
+                                       AVPacket *pkt)
+{
+    GIFContext *s = avctx->priv_data;
+    int len = 0, height = avctx->height, width = avctx->width, y;
+    int x_start = 0, y_start = 0, trans = s->transparent_index;
+    //int honor_transparency = (s->flags & GF_TRANSDIFF) && s->last_frame && !palette;
+    const uint8_t *ptr;
+
+    /* Crop Image */
+    if ( (s->flags & GF_OFFSETTING) && trans >=0 ) {
+        const int w = avctx->width;
+        const int h = avctx->height;
+        int x_end = w - 1,
+            y_end = h - 1;
+
+        // crop top
+        while (y_start < y_end) {
+            int i;
+            int is_trans = 1;
+            for( i=0; i<w; ++i ) {
+                if( buf[w*y_start+i] != trans ) {
+                    is_trans = 0;
+                    break;
+                }
+            }
+            if( !is_trans )
+                break;
+            ++y_start;
+        }
+
+        // crop bottom
+        while (y_end < h) {
+            int i;
+            int is_trans = 1;
+            for( i=0; i<w; ++i ) {
+                if( buf[w*y_end+i] != trans ) {
+                    is_trans = 0;
+                    break;
+                }
+            }
+            if( !is_trans )
+                break;
+            --y_end;
+        }
+
+        // crop left
+        while (x_start < x_end) {
+            int i;
+            int is_trans = 1;
+            for( i=y_start; i<y_end; ++i ) {
+                if( buf[w*i+x_start] != trans ) {
+                    is_trans = 0;
+                    break;
+                }
+            }
+            if( !is_trans )
+                break;
+            ++x_start;
+        }
+
+        // crop right
+        while (x_end < w) {
+            int i;
+            int is_trans = 1;
+            for( i=y_start; i<y_end; ++i ) {
+                if( buf[w*i+x_end] != trans ) {
+                    is_trans = 0;
+                    break;
+                }
+            }
+            if( !is_trans )
+                break;
+            --x_end;
+        }
+
+        height = y_end + 1 - y_start;
+        width  = x_end + 1 - x_start;
+        av_log(avctx, AV_LOG_DEBUG,"%dx%d image at pos (%d;%d) [area:%dx%d]\n",
+               width, height, x_start, y_start, avctx->width, avctx->height);
+    }
+
+
+    uint8_t *frame_disposal = av_packet_new_side_data(pkt, AV_PKT_DATA_GIF_FRAME_DISPOSAL, 1);
+    if (!frame_disposal)
+        return AVERROR(ENOMEM);
+    *frame_disposal = GCE_DISPOSAL_BACKGROUND;
+
+    /* image block */
+    bytestream_put_byte(bytestream, GIF_IMAGE_SEPARATOR);
+    bytestream_put_le16(bytestream, x_start);
+    bytestream_put_le16(bytestream, y_start);
+    bytestream_put_le16(bytestream, width);
+    bytestream_put_le16(bytestream, height);
+
+    if (!palette) {
+        bytestream_put_byte(bytestream, 0x00); /* flags */
+    } else {
+        unsigned i;
+        bytestream_put_byte(bytestream, 1<<7 | 0x7); /* flags */
+        for (i = 0; i < AVPALETTE_COUNT; i++) {
+            const uint32_t v = palette[i];
+            bytestream_put_be24(bytestream, v);
+        }
+    }
+
+    bytestream_put_byte(bytestream, 0x08);
+
+    ff_lzw_encode_init(s->lzw, s->buf, s->buf_size,
+                       12, FF_LZW_GIF, put_bits);
+
+    ptr = buf + y_start*linesize + x_start;
+
+    for (y = 0; y < height; y++) {
+        len += ff_lzw_encode(s->lzw, ptr, width);
+        ptr += linesize;
+    }
+
+    len += ff_lzw_encode_flush(s->lzw, flush_put_bits);
+
+    ptr = s->buf;
+    while (len > 0) {
+        int size = FFMIN(255, len);
+        bytestream_put_byte(bytestream, size);
+        if (end - *bytestream < size)
+            return -1;
+        bytestream_put_buffer(bytestream, ptr, size);
+        ptr += size;
+        len -= size;
+    }
+    bytestream_put_byte(bytestream, 0x00); /* end of image block */
+
+    return 0;
+}
+
+static int gif_image_write_image(AVCodecContext *avctx,
+                                 uint8_t **bytestream, uint8_t *end,
+                                 const uint32_t *palette,
+                                 const uint8_t *buf, const int linesize,
+                                 AVPacket *pkt)
+{
+    GIFContext *s = avctx->priv_data;
+    if( !s->last_frame ) {
+        return gif_image_write_opaque(avctx, bytestream, end, palette, buf, linesize, pkt);
+    }
+
+    if( is_image_translucent(avctx, palette, buf, linesize ) ) {
+        return gif_image_write_translucent(avctx, bytestream, end, palette, buf, linesize, pkt);
+    } else {
+        return gif_image_write_opaque(avctx, bytestream, end, palette, buf, linesize, pkt);
+    }
+}
+
 static av_cold int gif_encode_init(AVCodecContext *avctx)
 {
     GIFContext *s = avctx->priv_data;
diff --git a/libavfilter/vf_paletteuse.c b/libavfilter/vf_paletteuse.c
index ffd37bf1da..21870c22f5 100644
--- a/libavfilter/vf_paletteuse.c
+++ b/libavfilter/vf_paletteuse.c
@@ -56,7 +56,7 @@ enum diff_mode {
 };
 
 struct color_node {
-    uint8_t val[3];
+    uint8_t val[4];
     uint8_t palette_id;
     int split;
     int left_id, right_id;
@@ -86,6 +86,7 @@ typedef struct PaletteUseContext {
     struct cache_node cache[CACHE_SIZE];    /* lookup cache */
     struct color_node map[AVPALETTE_COUNT]; /* 3D-Tree (KD-Tree with K=3) for reverse colormap */
     uint32_t palette[AVPALETTE_COUNT];
+    int transparency_index; /* index in the palette of transparency. -1 if there isn't a transparency. */
     int palette_loaded;
     int dither;
     int new;
@@ -157,7 +158,8 @@ static int query_formats(AVFilterContext *ctx)
 
 static av_always_inline int dither_color(uint32_t px, int er, int eg, int eb, int scale, int shift)
 {
-    return av_clip_uint8((px >> 16 & 0xff) + ((er * scale) / (1<<shift))) << 16
+    return (px & 0xff000000)
+         | av_clip_uint8((px >> 16 & 0xff) + ((er * scale) / (1<<shift))) << 16
          | av_clip_uint8((px >>  8 & 0xff) + ((eg * scale) / (1<<shift))) <<  8
          | av_clip_uint8((px       & 0xff) + ((eb * scale) / (1<<shift)));
 }
@@ -165,10 +167,12 @@ static av_always_inline int dither_color(uint32_t px, int er, int eg, int eb, in
 static av_always_inline int diff(const uint8_t *c1, const uint8_t *c2)
 {
     // XXX: try L*a*b with CIE76 (dL*dL + da*da + db*db)
-    const int dr = c1[0] - c2[0];
-    const int dg = c1[1] - c2[1];
-    const int db = c1[2] - c2[2];
-    return dr*dr + dg*dg + db*db;
+    const static int max_diff = 255*255 + 255*255 + 255*255;
+    const int dr = c1[1] - c2[1];
+    const int dg = c1[2] - c2[2];
+    const int db = c1[3] - c2[3];
+
+    return ( c1[0] == 0 && c2[0] == 0 ) ? 0 : ( (c1[0] == c2[0]) ? (dr*dr + dg*dg + db*db) : (max_diff) ) ;
 }
 
 static av_always_inline uint8_t colormap_nearest_bruteforce(const uint32_t *palette, const uint8_t *rgb)
@@ -178,13 +182,14 @@ static av_always_inline uint8_t colormap_nearest_bruteforce(const uint32_t *pale
     for (i = 0; i < AVPALETTE_COUNT; i++) {
         const uint32_t c = palette[i];
 
-        if ((c & 0xff000000) == 0xff000000) { // ignore transparent entry
-            const uint8_t palrgb[] = {
+        if ((c & 0xff000000) == 0xff000000) {
+            const uint8_t palargb[] = {
+                palette[i]>>24 & 0xff,
                 palette[i]>>16 & 0xff,
                 palette[i]>> 8 & 0xff,
                 palette[i]     & 0xff,
             };
-            const int d = diff(palrgb, rgb);
+            const int d = diff(palargb, rgb);
             if (d < min_dist) {
                 pal_id = i;
                 min_dist = d;
@@ -195,6 +200,7 @@ static av_always_inline uint8_t colormap_nearest_bruteforce(const uint32_t *pale
 }
 
 /* Recursive form, simpler but a bit slower. Kept for reference. */
+/* has not been updated for transparency */
 struct nearest_color {
     int node_pos;
     int dist_sqd;
@@ -232,6 +238,7 @@ static void colormap_nearest_node(const struct color_node *map,
 
 static av_always_inline uint8_t colormap_nearest_recursive(const struct color_node *node, const uint8_t *rgb)
 {
+    printf( "colormap_nearest_recursive\n" );
     struct nearest_color res = {.dist_sqd = INT_MAX, .node_pos = -1};
     colormap_nearest_node(node, 0, rgb, &res);
     return node[res.node_pos].palette_id;
@@ -258,15 +265,16 @@ static av_always_inline uint8_t colormap_nearest_iterative(const struct color_no
          * it's actually better. */
         if (current_to_target < best_dist) {
             best_node_id = cur_color_id;
-            if (!current_to_target)
+            if (!current_to_target) {
                 goto end; // exact match, we can return immediately
+            }
             best_dist = current_to_target;
         }
 
         /* Check if it's not a leaf */
         if (kd->left_id != -1 || kd->right_id != -1) {
             const int split = kd->split;
-            const int dx = target[split] - current[split];
+            const int dx = target[split-1] - current[split-1];
             int nearer_kd_id, further_kd_id;
 
             /* Define which side is the most interesting. */
@@ -325,14 +333,15 @@ end:
  * Note: r, g, and b are the component of c but are passed as well to avoid
  * recomputing them (they are generally computed by the caller for other uses).
  */
-static av_always_inline int color_get(struct cache_node *cache, uint32_t color,
-                                      uint8_t r, uint8_t g, uint8_t b,
+static av_always_inline int color_get(struct cache_node *cache, uint32_t argb,
+                                      uint8_t a, uint8_t r, uint8_t g, uint8_t b,
+                                      int transparency_index,
                                       const struct color_node *map,
                                       const uint32_t *palette,
                                       const enum color_search_method search_method)
 {
     int i;
-    const uint8_t rgb[] = {r, g, b};
+    const uint8_t argb_elts[] = {a, r, g, b};
     const uint8_t rhash = r & ((1<<NBITS)-1);
     const uint8_t ghash = g & ((1<<NBITS)-1);
     const uint8_t bhash = b & ((1<<NBITS)-1);
@@ -340,9 +349,14 @@ static av_always_inline int color_get(struct cache_node *cache, uint32_t color,
     struct cache_node *node = &cache[hash];
     struct cached_color *e;
 
+    // is this transparent?
+    if( a == 0 && transparency_index >= 0 ) {
+        return transparency_index;
+    }
+
     for (i = 0; i < node->nb_entries; i++) {
         e = &node->entries[i];
-        if (e->color == color)
+        if (e->color == argb)
             return e->pal_entry;
     }
 
@@ -350,21 +364,24 @@ static av_always_inline int color_get(struct cache_node *cache, uint32_t color,
                          sizeof(*node->entries), NULL);
     if (!e)
         return AVERROR(ENOMEM);
-    e->color = color;
-    e->pal_entry = COLORMAP_NEAREST(search_method, palette, map, rgb);
+    e->color = argb;
+
+    e->pal_entry = COLORMAP_NEAREST(search_method, palette, map, argb_elts);
     return e->pal_entry;
 }
 
 static av_always_inline int get_dst_color_err(struct cache_node *cache,
-                                              uint32_t c, const struct color_node *map,
+                                              uint32_t argb, const struct color_node *map,
                                               const uint32_t *palette,
+                                              int transparency_index,
                                               int *er, int *eg, int *eb,
                                               const enum color_search_method search_method)
 {
-    const uint8_t r = c >> 16 & 0xff;
-    const uint8_t g = c >>  8 & 0xff;
-    const uint8_t b = c       & 0xff;
-    const int dstx = color_get(cache, c, r, g, b, map, palette, search_method);
+    const uint8_t a = argb >> 24 & 0xff;
+    const uint8_t r = argb >> 16 & 0xff;
+    const uint8_t g = argb >>  8 & 0xff;
+    const uint8_t b = argb       & 0xff;
+    const int dstx = color_get(cache, argb, a, r, g, b, transparency_index, map, palette, search_method);
     const uint32_t dstc = palette[dstx];
     *er = r - (dstc >> 16 & 0xff);
     *eg = g - (dstc >>  8 & 0xff);
@@ -385,6 +402,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
     const int dst_linesize = out->linesize[0];
     uint32_t *src = ((uint32_t *)in ->data[0]) + y_start*src_linesize;
     uint8_t  *dst =              out->data[0]  + y_start*dst_linesize;
+    int transparency_index = s->transparency_index;
 
     w += x_start;
     h += y_start;
@@ -395,14 +413,14 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
 
             if (dither == DITHERING_BAYER) {
                 const int d = s->ordered_dither[(y & 7)<<3 | (x & 7)];
+                const uint8_t a8 = src[x] >> 24 & 0xff;
                 const uint8_t r8 = src[x] >> 16 & 0xff;
                 const uint8_t g8 = src[x] >>  8 & 0xff;
                 const uint8_t b8 = src[x]       & 0xff;
                 const uint8_t r = av_clip_uint8(r8 + d);
                 const uint8_t g = av_clip_uint8(g8 + d);
                 const uint8_t b = av_clip_uint8(b8 + d);
-                const uint32_t c = r<<16 | g<<8 | b;
-                const int color = color_get(cache, c, r, g, b, map, palette, search_method);
+                const int color = color_get(cache, src[x], a8, r, g, b, transparency_index, map, palette, search_method);
 
                 if (color < 0)
                     return color;
@@ -410,7 +428,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
 
             } else if (dither == DITHERING_HECKBERT) {
                 const int right = x < w - 1, down = y < h - 1;
-                const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
+                const int color = get_dst_color_err(cache, src[x], map, palette, transparency_index, &er, &eg, &eb, search_method);
 
                 if (color < 0)
                     return color;
@@ -422,7 +440,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
 
             } else if (dither == DITHERING_FLOYD_STEINBERG) {
                 const int right = x < w - 1, down = y < h - 1, left = x > x_start;
-                const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
+                const int color = get_dst_color_err(cache, src[x], map, palette, transparency_index, &er, &eg, &eb, search_method);
 
                 if (color < 0)
                     return color;
@@ -436,7 +454,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
             } else if (dither == DITHERING_SIERRA2) {
                 const int right  = x < w - 1, down  = y < h - 1, left  = x > x_start;
                 const int right2 = x < w - 2,                    left2 = x > x_start + 1;
-                const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
+                const int color = get_dst_color_err(cache, src[x], map, palette, transparency_index, &er, &eg, &eb, search_method);
 
                 if (color < 0)
                     return color;
@@ -455,7 +473,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
 
             } else if (dither == DITHERING_SIERRA2_4A) {
                 const int right = x < w - 1, down = y < h - 1, left = x > x_start;
-                const int color = get_dst_color_err(cache, src[x], map, palette, &er, &eg, &eb, search_method);
+                const int color = get_dst_color_err(cache, src[x], map, palette, transparency_index, &er, &eg, &eb, search_method);
 
                 if (color < 0)
                     return color;
@@ -466,10 +484,11 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
                 if (         down) src[src_linesize + x    ] = dither_color(src[src_linesize + x    ], er, eg, eb, 1, 2);
 
             } else {
+                const uint8_t a = src[x] >> 24 & 0xff;
                 const uint8_t r = src[x] >> 16 & 0xff;
                 const uint8_t g = src[x] >>  8 & 0xff;
                 const uint8_t b = src[x]       & 0xff;
-                const int color = color_get(cache, src[x] & 0xffffff, r, g, b, map, palette, search_method);
+                const int color = color_get(cache, src[x], a, r, g, b, transparency_index, map, palette, search_method);
 
                 if (color < 0)
                     return color;
@@ -489,19 +508,19 @@ static void disp_node(AVBPrint *buf,
                       int depth)
 {
     const struct color_node *node = &map[node_id];
-    const uint32_t fontcolor = node->val[0] > 0x50 &&
-                               node->val[1] > 0x50 &&
-                               node->val[2] > 0x50 ? 0 : 0xffffff;
+    const uint32_t fontcolor = node->val[1] > 0x50 &&
+                               node->val[2] > 0x50 &&
+                               node->val[3] > 0x50 ? 0 : 0xffffff;
     av_bprintf(buf, "%*cnode%d ["
                "label=\"%c%02X%c%02X%c%02X%c\" "
                "fillcolor=\"#%02x%02x%02x\" "
                "fontcolor=\"#%06"PRIX32"\"]\n",
                depth*INDENT, ' ', node->palette_id,
-               "[  "[node->split], node->val[0],
-               "][ "[node->split], node->val[1],
-               " ]["[node->split], node->val[2],
+               "[  "[node->split], node->val[1],
+               "][ "[node->split], node->val[2],
+               " ]["[node->split], node->val[3],
                "  ]"[node->split],
-               node->val[0], node->val[1], node->val[2],
+               node->val[1], node->val[2], node->val[3],
                fontcolor);
     if (parent_id != -1)
         av_bprintf(buf, "%*cnode%d -> node%d\n", depth*INDENT, ' ',
@@ -584,17 +603,18 @@ static int cmp_##name(const void *pa, const void *pb)   \
 {                                                       \
     const struct color *a = pa;                         \
     const struct color *b = pb;                         \
-    return   (a->value >> (8 * (2 - (pos))) & 0xff)     \
-           - (b->value >> (8 * (2 - (pos))) & 0xff);    \
+    return   (a->value >> (8 * (3 - (pos))) & 0xff)     \
+           - (b->value >> (8 * (3 - (pos))) & 0xff);    \
 }
 
-DECLARE_CMP_FUNC(r, 0)
-DECLARE_CMP_FUNC(g, 1)
-DECLARE_CMP_FUNC(b, 2)
+DECLARE_CMP_FUNC(a, 0)
+DECLARE_CMP_FUNC(r, 1)
+DECLARE_CMP_FUNC(g, 2)
+DECLARE_CMP_FUNC(b, 3)
 
-static const cmp_func cmp_funcs[] = {cmp_r, cmp_g, cmp_b};
+static const cmp_func cmp_funcs[] = {cmp_a, cmp_r, cmp_g, cmp_b};
 
-static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
+static int get_next_color(const uint8_t *color_used, const uint32_t *palette, const int nb_colors,
                           int *component, const struct color_rect *box)
 {
     int wr, wg, wb;
@@ -607,7 +627,7 @@ static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
     ranges.min[0] = ranges.min[1] = ranges.min[2] = 0xff;
     ranges.max[0] = ranges.max[1] = ranges.max[2] = 0x00;
 
-    for (i = 0; i < AVPALETTE_COUNT; i++) {
+    for (i = 0; i < nb_colors; i++) {
         const uint32_t c = palette[i];
         const uint8_t r = c >> 16 & 0xff;
         const uint8_t g = c >>  8 & 0xff;
@@ -639,9 +659,9 @@ static int get_next_color(const uint8_t *color_used, const uint32_t *palette,
     wr = ranges.max[0] - ranges.min[0];
     wg = ranges.max[1] - ranges.min[1];
     wb = ranges.max[2] - ranges.min[2];
-    if (wr >= wg && wr >= wb) longest = 0;
-    if (wg >= wr && wg >= wb) longest = 1;
-    if (wb >= wr && wb >= wg) longest = 2;
+    if (wr >= wg && wr >= wb) longest = 1;
+    if (wg >= wr && wg >= wb) longest = 2;
+    if (wb >= wr && wb >= wg) longest = 3;
     cmpf = cmp_funcs[longest];
     *component = longest;
 
@@ -655,6 +675,7 @@ static int colormap_insert(struct color_node *map,
                            uint8_t *color_used,
                            int *nb_used,
                            const uint32_t *palette,
+                           const int nb_colors,
                            const struct color_rect *box)
 {
     uint32_t c;
@@ -662,7 +683,7 @@ static int colormap_insert(struct color_node *map,
     int node_left_id = -1, node_right_id = -1;
     struct color_node *node;
     struct color_rect box1, box2;
-    const int pal_id = get_next_color(color_used, palette, &component, box);
+    const int pal_id = get_next_color(color_used, palette, nb_colors, &component, box);
 
     if (pal_id < 0)
         return -1;
@@ -673,21 +694,22 @@ static int colormap_insert(struct color_node *map,
     node = &map[cur_id];
     node->split = component;
     node->palette_id = pal_id;
-    node->val[0] = c>>16 & 0xff;
-    node->val[1] = c>> 8 & 0xff;
-    node->val[2] = c     & 0xff;
+    node->val[0] = c>>24 & 0xff;
+    node->val[1] = c>>16 & 0xff;
+    node->val[2] = c>> 8 & 0xff;
+    node->val[3] = c     & 0xff;
 
     color_used[pal_id] = 1;
 
     /* get the two boxes this node creates */
     box1 = box2 = *box;
-    box1.max[component] = node->val[component];
-    box2.min[component] = node->val[component] + 1;
+    box1.max[component-1] = node->val[component-1];
+    box2.min[component-1] = node->val[component-1] + 1;
 
-    node_left_id = colormap_insert(map, color_used, nb_used, palette, &box1);
+    node_left_id = colormap_insert(map, color_used, nb_used, palette, nb_colors, &box1);
 
-    if (box2.min[component] <= box2.max[component])
-        node_right_id = colormap_insert(map, color_used, nb_used, palette, &box2);
+    if (box2.min[component-1] <= box2.max[component-1])
+        node_right_id = colormap_insert(map, color_used, nb_used, palette, nb_colors, &box2);
 
     node->left_id  = node_left_id;
     node->right_id = node_right_id;
@@ -700,9 +722,10 @@ static int cmp_pal_entry(const void *a, const void *b)
     const int c1 = *(const uint32_t *)a & 0xffffff;
     const int c2 = *(const uint32_t *)b & 0xffffff;
     return c1 - c2;
+    // return *(const uint32_t *)a - *(const uint32_t *)b ;
 }
 
-static void load_colormap(PaletteUseContext *s)
+static void load_colormap(PaletteUseContext *s, int nb_colors)
 {
     int i, nb_used = 0;
     uint8_t color_used[AVPALETTE_COUNT] = {0};
@@ -710,24 +733,24 @@ static void load_colormap(PaletteUseContext *s)
     struct color_rect box;
 
     /* disable transparent colors and dups */
-    qsort(s->palette, AVPALETTE_COUNT, sizeof(*s->palette), cmp_pal_entry);
-    for (i = 0; i < AVPALETTE_COUNT; i++) {
+    qsort(s->palette, nb_colors, sizeof(*s->palette), cmp_pal_entry);
+    for (i = 0; i < nb_colors; i++) {
         const uint32_t c = s->palette[i];
         if (i != 0 && c == last_color) {
             color_used[i] = 1;
             continue;
         }
         last_color = c;
-        if ((c & 0xff000000) != 0xff000000) {
-            color_used[i] = 1; // ignore transparent color(s)
-            continue;
-        }
     }
 
     box.min[0] = box.min[1] = box.min[2] = 0x00;
     box.max[0] = box.max[1] = box.max[2] = 0xff;
 
-    colormap_insert(s->map, color_used, &nb_used, s->palette, &box);
+    colormap_insert(s->map, color_used, &nb_used, s->palette, nb_colors, &box);
+
+    // for (i = 0; i < nb_used; i++) {
+    //     printf( "map: %3d %3d %3d %3d  -> %3d\n", s->map[i].val[0], s->map[i].val[1], s->map[i].val[2], s->map[i].val[3], s->map[i].palette_id );
+    // }
 
     if (s->dot_filename)
         disp_tree(s->map, s->dot_filename);
@@ -937,10 +960,13 @@ static int config_input_palette(AVFilterLink *inlink)
 
 static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame)
 {
-    int i, x, y;
+    int pal_index, i, has_transparency, x, y;
     const uint32_t *p = (const uint32_t *)palette_frame->data[0];
     const int p_linesize = palette_frame->linesize[0] >> 2;
 
+    s->transparency_index = -1;
+    has_transparency = 0;
+
     if (s->new) {
         memset(s->palette, 0, sizeof(s->palette));
         memset(s->map, 0, sizeof(s->map));
@@ -949,14 +975,34 @@ static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame)
         memset(s->cache, 0, sizeof(s->cache));
     }
 
-    i = 0;
+    pal_index = 0;
     for (y = 0; y < palette_frame->height; y++) {
-        for (x = 0; x < palette_frame->width; x++)
-            s->palette[i++] = p[x];
+        for (x = 0; x < palette_frame->width; x++) {
+            if( (p[x]>>24 & 0xff) > 0 ) {
+                s->palette[pal_index] = p[x];
+                ++pal_index;
+            } else {
+                has_transparency = 1;
+                //printf( "ti set %d\n", pal_index );
+            }
+        }
         p += p_linesize;
     }
 
-    load_colormap(s);
+    load_colormap(s, pal_index);
+
+    if( has_transparency ) {
+        s->transparency_index = pal_index;
+        //printf( "ti set\n" );
+    }
+    //printf( "%d\n", s->transparency_index );
+
+
+    // for (int j=0; j<palette_frame->height * palette_frame->width; ++j ) {
+    //     printf( "palette: %3i: %3d, %3d, %3d, %3d\n", j, ( s->palette[j] >> 24 ) & 0xff, ( s->palette[j] >> 16 ) & 0xff, ( s->palette[j] >>  8 ) & 0xff, ( s->palette[j] >>  0 ) & 0xff );
+    // }
+
+    // printf( "::palette loaded with transparency index :: %d\n", s->transparency_index );
 
     if (!s->new)
         s->palette_loaded = 1;
diff --git a/libavformat/gif.c b/libavformat/gif.c
index 91cd40db5c..4662720049 100644
--- a/libavformat/gif.c
+++ b/libavformat/gif.c
@@ -144,6 +144,8 @@ static int flush_packet(AVFormatContext *s, AVPacket *new)
     AVIOContext *pb = s->pb;
     const uint32_t *palette;
     AVPacket *pkt = gif->prev_pkt;
+    uint8_t *disposal;
+    uint8_t packed;
 
     if (!pkt)
         return 0;
@@ -157,16 +159,28 @@ static int flush_packet(AVFormatContext *s, AVPacket *new)
     }
     bcid = get_palette_transparency_index(palette);
 
+    disposal = av_packet_get_side_data(pkt, AV_PKT_DATA_GIF_FRAME_DISPOSAL, &size);
+    if( disposal && size != 1 ) {
+        av_log(s, AV_LOG_ERROR, "Invalid gif frame disposal extradata\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     if (new && new->pts != AV_NOPTS_VALUE)
         gif->duration = av_clip_uint16(new->pts - gif->prev_pkt->pts);
     else if (!new && gif->last_delay >= 0)
         gif->duration = gif->last_delay;
 
     /* graphic control extension block */
+    if( disposal ) {
+        packed = (0xff & (*disposal)<<2) | (bcid >= 0);
+    } else {
+        packed = 1<<2 | (bcid >= 0);
+    }
+
     avio_w8(pb, 0x21);
     avio_w8(pb, 0xf9);
     avio_w8(pb, 0x04); /* block size */
-    avio_w8(pb, 1<<2 | (bcid >= 0));
+    avio_w8(pb, packed);
     avio_wl16(pb, gif->duration);
     avio_w8(pb, bcid < 0 ? DEFAULT_TRANSPARENCY_INDEX : bcid);
     avio_w8(pb, 0x00);