diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index f8673f0121..ceec1df972 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -536,6 +536,7 @@ OBJS-$(CONFIG_RA_144_DECODER)          += ra144dec.o ra144.o celp_filters.o
 OBJS-$(CONFIG_RA_144_ENCODER)          += ra144enc.o ra144.o celp_filters.o
 OBJS-$(CONFIG_RA_288_DECODER)          += ra288.o celp_filters.o
 OBJS-$(CONFIG_RALF_DECODER)            += ralf.o
+OBJS-$(CONFIG_RASC_DECODER)            += rasc.o
 OBJS-$(CONFIG_RAWVIDEO_DECODER)        += rawdec.o
 OBJS-$(CONFIG_RAWVIDEO_ENCODER)        += rawenc.o
 OBJS-$(CONFIG_REALTEXT_DECODER)        += realtextdec.o ass.o
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index a461131c78..8fc1aeab79 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -248,6 +248,7 @@ extern AVCodec ff_r10k_encoder;
 extern AVCodec ff_r10k_decoder;
 extern AVCodec ff_r210_encoder;
 extern AVCodec ff_r210_decoder;
+extern AVCodec ff_rasc_decoder;
 extern AVCodec ff_rawvideo_encoder;
 extern AVCodec ff_rawvideo_decoder;
 extern AVCodec ff_rl2_decoder;
diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index b6688b7af3..719c181a08 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -451,6 +451,7 @@ enum AVCodecID {
     AV_CODEC_ID_PROSUMER,
     AV_CODEC_ID_MWSC,
     AV_CODEC_ID_WCMV,
+    AV_CODEC_ID_RASC,
 
     /* various PCM "codecs" */
     AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
diff --git a/libavcodec/codec_desc.c b/libavcodec/codec_desc.c
index 46dfe3f5e5..67a30542d1 100644
--- a/libavcodec/codec_desc.c
+++ b/libavcodec/codec_desc.c
@@ -1682,6 +1682,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("WinCAM Motion Video"),
         .props     = AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_RASC,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "rasc",
+        .long_name = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
 
     /* various PCM "codecs" */
     {
diff --git a/libavcodec/rasc.c b/libavcodec/rasc.c
new file mode 100644
index 0000000000..288fe53a21
--- /dev/null
+++ b/libavcodec/rasc.c
@@ -0,0 +1,590 @@
+/*
+ * RemotelyAnywhere Screen Capture decoder
+ *
+ * Copyright (c) 2018 Paul B Mahol
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/imgutils.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#include <zlib.h>
+
+#define KBND MKTAG('K', 'B', 'N', 'D')
+#define FINT MKTAG('F', 'I', 'N', 'T')
+#define BNDL MKTAG('B', 'N', 'D', 'L')
+#define KFRM MKTAG('K', 'F', 'R', 'M')
+#define DLTA MKTAG('D', 'L', 'T', 'A')
+#define MOUS MKTAG('M', 'O', 'U', 'S') /* TODO */
+#define MPOS MKTAG('M', 'P', 'O', 'S') /* TODO */
+#define MOVE MKTAG('M', 'O', 'V', 'E') /* TODO */
+#define EMPT MKTAG('E', 'M', 'P', 'T')
+
+typedef struct RASCContext {
+    GetByteContext  gb;
+    uint8_t        *delta;
+    int             delta_size;
+    int             bndl;
+    z_stream        zstream;
+    AVFrame        *frame;
+    AVFrame        *frame1;
+    AVFrame        *frame2;
+} RASCContext;
+
+static void clear_plane(AVCodecContext *avctx, AVFrame *frame)
+{
+    uint8_t *dst = frame->data[0];
+
+    for (int y = 0; y < avctx->height; y++) {
+        memset(dst, 0, avctx->width);
+        dst += frame->linesize[0];
+    }
+}
+
+static int decode_fint(AVCodecContext *avctx, AVFrame *frame,
+                       AVPacket *avpkt, unsigned size)
+{
+    RASCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    unsigned w, h;
+    uint32_t *pal;
+    int ret;
+
+    clear_plane(avctx, frame);
+    bytestream2_skip(gb, 8);
+    w = bytestream2_get_le32(gb);
+    h = bytestream2_get_le32(gb);
+    bytestream2_skip(gb, 56);
+
+    ret = ff_set_dimensions(avctx, w, h);
+    if (ret < 0)
+        return ret;
+    avctx->width  = w;
+    avctx->height = h;
+
+    pal = (uint32_t *)frame->data[1];
+    for (int i = 0; i < 256; i++) {
+        pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
+    }
+
+    return 0;
+}
+
+static int decode_move(AVCodecContext *avctx, AVFrame *frame,
+                       AVPacket *avpkt, unsigned size)
+{
+    RASCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    unsigned compression, nb_moves;
+
+    bytestream2_skip(gb, 8);
+    nb_moves = bytestream2_get_le32(gb);
+    bytestream2_skip(gb, 8);
+    compression = bytestream2_get_le32(gb);
+
+    if (nb_moves > INT32_MAX / 16)
+        return AVERROR_INVALIDDATA;
+
+    if (bytestream2_get_bytes_left(gb) < 16 * nb_moves)
+        return AVERROR_INVALIDDATA;
+
+    for (int i = 0; i < nb_moves; i++) {
+        int type, start_x, start_y, end_x, end_y;
+
+        type = bytestream2_get_le16(gb);
+        start_x = bytestream2_get_le16(gb);
+        start_y = bytestream2_get_le16(gb);
+        end_x = bytestream2_get_le16(gb);
+        end_y = bytestream2_get_le16(gb);
+        bytestream2_skip(gb, 6);
+    }
+
+    return 0;
+}
+
+static int decode_dlta(AVCodecContext *avctx, AVFrame *frame,
+                       AVPacket *avpkt, unsigned size)
+{
+    RASCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    GetByteContext dc;
+    unsigned uncompressed_size, pos;
+    unsigned x, y, w, h;
+    int cx, compression, zret;
+    uint8_t *dst, *b1, *b2;
+
+    pos = bytestream2_tell(gb);
+    bytestream2_skip(gb, 12);
+    uncompressed_size = bytestream2_get_le32(gb);
+    x = bytestream2_get_le32(gb);
+    y = bytestream2_get_le32(gb);
+    w = bytestream2_get_le32(gb);
+    h = bytestream2_get_le32(gb);
+
+    if (x >= avctx->width || y >= avctx->height || w > avctx->width || h > avctx->height)
+        return AVERROR_INVALIDDATA;
+
+    if (x + w > avctx->width || y + h > avctx->height)
+        return AVERROR_INVALIDDATA;
+
+    bytestream2_skip(gb, 4);
+    compression = bytestream2_get_le32(gb);
+
+    if (compression == 1) {
+        zret = inflateReset(&s->zstream);
+        if (zret != Z_OK) {
+            av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
+            return AVERROR_EXTERNAL;
+        }
+
+        av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
+
+        s->zstream.next_in  = avpkt->data + bytestream2_tell(gb);
+        s->zstream.avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
+
+        s->zstream.next_out  = s->delta;
+        s->zstream.avail_out = s->delta_size;
+
+        zret = inflate(&s->zstream, Z_FINISH);
+        if (zret != Z_STREAM_END) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Inflate failed with return code: %d.\n", zret);
+            return AVERROR_INVALIDDATA;
+        }
+
+        bytestream2_init(&dc, s->delta, uncompressed_size);
+    } else if (compression == 0) {
+        if (bytestream2_get_bytes_left(gb) < uncompressed_size)
+            return AVERROR_INVALIDDATA;
+        bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb), uncompressed_size);
+    } else if (compression == 2) {
+        av_assert0(0);
+    } else {
+        return AVERROR_INVALIDDATA;
+    }
+
+
+    dst = frame->data[0] + frame->linesize[0] * (y + h - 1) + x;
+    b1  = s->frame1->data[0] + s->frame1->linesize[0] * (y + h - 1) + x;
+    b2  = s->frame2->data[0] + s->frame2->linesize[0] * (y + h - 1) + x;
+    cx = 0;
+    while (bytestream2_get_bytes_left(&dc) > 0) {
+        int type = bytestream2_get_byte(&dc);
+        int len = bytestream2_get_byte(&dc);
+        unsigned fill;
+
+        switch (type) {
+        case 1:
+            while (len > 0) {
+                dst[cx] = b2[cx];
+                cx++;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 2:
+            while (len > 0) {
+                int v0 = b1[cx];
+                int v1 = b2[cx];
+
+                b2[cx] = v0;
+                dst[cx] = v0;
+                b1[cx] = v1;
+                cx++;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 3:
+            while (len > 0) {
+                fill = bytestream2_get_byte(&dc);
+                AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+                AV_WL32(b2 + cx, fill);
+                dst[cx] = fill;
+                cx++;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 4:
+            fill = bytestream2_get_byte(&dc);
+            while (len > 0) {
+                AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+                AV_WL32(dst + cx, fill);
+                AV_WL32(b2 + cx, fill);
+                cx++;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 5:
+            fill = bytestream2_get_le16(&dc);
+            while (len > 0) {
+                AV_WL16(dst + cx, fill);
+                cx += 2;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 6:
+            fill = bytestream2_get_le24(&dc);
+            while (len > 0) {
+                AV_WL24(dst + cx, fill);
+                cx += 3;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 7:
+            fill = bytestream2_get_le32(&dc);
+            while (len > 0) {
+                AV_WL32(dst + cx, fill);
+                AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+                AV_WL32(b2 + cx, fill);
+                cx += 4;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 10:
+            while (len > 0) {
+                AV_WL32(dst + cx, AV_RL32(b2 + cx));
+                cx += 4;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 12:
+            while (len > 0) {
+                unsigned v0, v1;
+
+                v0 = AV_RL32(b2 + cx);
+                v1 = AV_RL32(b1 + cx);
+                AV_WL32(b2 + cx, v1);
+                AV_WL32(dst + cx, v1);
+                AV_WL32(b1 + cx, v0);
+                cx += 4;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        case 13:
+            while (len > 0) {
+                fill = bytestream2_get_le32(&dc);
+                AV_WL32(dst + cx, fill);
+                AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+                AV_WL32(b2 + cx, fill);
+                cx += 4;
+                if (cx >= w) {
+                    cx = 0;
+                    dst -= frame->linesize[0];
+                    b1 -= s->frame1->linesize[0];
+                    b2 -= s->frame2->linesize[0];
+                }
+                len--;
+            }
+            break;
+        default:
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+    return 0;
+}
+
+static int decode_kfrm(AVCodecContext *avctx, AVFrame *frame,
+                       AVPacket *avpkt, unsigned size)
+{
+    RASCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    uint32_t *pal;
+    uint8_t *dst, *cptr;
+    unsigned pos;
+    int zret;
+
+    pos = bytestream2_tell(gb);
+    bytestream2_skip(gb, 72);
+
+    pal = (uint32_t *)frame->data[1];
+    for (int i = 0; i < 256; i++) {
+        pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
+    }
+
+    zret = inflateReset(&s->zstream);
+    if (zret != Z_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
+        return AVERROR_EXTERNAL;
+    }
+
+    s->zstream.next_in  = avpkt->data + bytestream2_tell(gb);
+    s->zstream.avail_in = bytestream2_get_bytes_left(gb);
+
+    dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+    cptr = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
+    for (int i = 0; i < avctx->height; i++) {
+        s->zstream.next_out  = dst;
+        s->zstream.avail_out = FFALIGN(avctx->width, 4);
+
+        zret = inflate(&s->zstream, Z_SYNC_FLUSH);
+        if (zret != Z_OK && zret != Z_STREAM_END) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Inflate failed with return code: %d.\n", zret);
+            return AVERROR_INVALIDDATA;
+        }
+
+        memcpy(cptr, dst, FFALIGN(avctx->width, 4));
+        dst -= frame->linesize[0];
+        cptr -= s->frame2->linesize[0];
+    }
+
+    dst = s->frame1->data[0] + (avctx->height - 1) * frame->linesize[0];
+    for (int i = 0; i < avctx->height; i++) {
+        s->zstream.next_out  = dst;
+        s->zstream.avail_out = FFALIGN(avctx->width, 4);
+
+        zret = inflate(&s->zstream, Z_SYNC_FLUSH);
+        if (zret != Z_OK && zret != Z_STREAM_END) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Inflate failed with return code: %d.\n", zret);
+            return AVERROR_INVALIDDATA;
+        }
+
+        dst -= s->frame1->linesize[0];
+    }
+
+    bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+    return 0;
+}
+
+static int init_frames(AVCodecContext *avctx)
+{
+    RASCContext *s = avctx->priv_data;
+    int ret;
+
+    if (!s->frame1 || !s->frame1->data[0]) {
+        av_frame_free(&s->frame1);
+
+        s->frame1 = av_frame_alloc();
+        if (!s->frame1)
+            return AVERROR(ENOMEM);
+
+        if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
+            return ret;
+        clear_plane(avctx, s->frame1);
+    }
+
+    if (!s->frame2 || !s->frame2->data[0]) {
+        av_frame_free(&s->frame2);
+
+        s->frame2 = av_frame_alloc();
+        if (!s->frame2)
+            return AVERROR(ENOMEM);
+
+        if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
+            return ret;
+        clear_plane(avctx, s->frame2);
+    }
+
+    if (!s->frame) {
+        s->frame = av_frame_alloc();
+        if (!s->frame)
+            return AVERROR(ENOMEM);
+    }
+
+    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int decode_frame(AVCodecContext *avctx,
+                        void *data, int *got_frame,
+                        AVPacket *avpkt)
+{
+    RASCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    int ret;
+
+    ret = inflateReset(&s->zstream);
+    if (ret != Z_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
+        return AVERROR_EXTERNAL;
+    }
+
+    ret = init_frames(avctx);
+    if (ret < 0)
+        return ret;
+
+    bytestream2_init(gb, avpkt->data, avpkt->size);
+
+    while (bytestream2_get_bytes_left(gb) > 0) {
+        unsigned type, size = 0;
+
+        type = bytestream2_get_le32(gb);
+        s->bndl = 0;
+        if (type == KBND || type == BNDL) {
+            s->bndl = type == BNDL;
+            type = bytestream2_get_le32(gb);
+        }
+        if (type != EMPT)
+            size = bytestream2_get_le32(gb);
+        if (bytestream2_get_bytes_left(gb) < size)
+            return AVERROR_INVALIDDATA;
+
+        switch (type) {
+        case FINT:
+            ret = decode_fint(avctx, s->frame, avpkt, size);
+            break;
+        case KFRM:
+            ret = decode_kfrm(avctx, s->frame, avpkt, size);
+            break;
+        case DLTA:
+            ret = decode_dlta(avctx, s->frame, avpkt, size);
+            break;
+        case MOVE:
+            ret = decode_move(avctx, s->frame, avpkt, size);
+            break;
+        case EMPT:
+            return avpkt->size;
+        default:
+            bytestream2_skip(gb, size);
+        }
+
+        if (ret < 0)
+            return ret;
+    }
+
+    if ((ret = av_frame_ref(data, s->frame)) < 0)
+        return ret;
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static av_cold int decode_init(AVCodecContext *avctx)
+{
+    RASCContext *s = avctx->priv_data;
+    int zret;
+
+    avctx->pix_fmt = AV_PIX_FMT_PAL8;
+
+    s->zstream.zalloc = Z_NULL;
+    s->zstream.zfree = Z_NULL;
+    s->zstream.opaque = Z_NULL;
+    zret = inflateInit(&s->zstream);
+    if (zret != Z_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
+        return AVERROR_EXTERNAL;
+    }
+
+    return 0;
+}
+
+static av_cold int decode_close(AVCodecContext *avctx)
+{
+    RASCContext *s = avctx->priv_data;
+
+    av_freep(&s->delta);
+    s->delta_size = 0;
+    av_frame_free(&s->frame);
+    av_frame_free(&s->frame1);
+    av_frame_free(&s->frame2);
+    inflateEnd(&s->zstream);
+
+    return 0;
+}
+
+static void decode_flush(AVCodecContext *avctx)
+{
+    RASCContext *s = avctx->priv_data;
+
+    av_frame_free(&s->frame1);
+    av_frame_free(&s->frame2);
+}
+
+AVCodec ff_rasc_decoder = {
+    .name             = "rasc",
+    .long_name        = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_RASC,
+    .priv_data_size   = sizeof(RASCContext),
+    .init             = decode_init,
+    .close            = decode_close,
+    .decode           = decode_frame,
+    .flush            = decode_flush,
+    .capabilities     = AV_CODEC_CAP_DR1,
+    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
+                        FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/libavformat/riff.c b/libavformat/riff.c
index 5f1aafe514..3907e1a9f3 100644
--- a/libavformat/riff.c
+++ b/libavformat/riff.c
@@ -474,6 +474,7 @@ const AVCodecTag ff_codec_bmp_tags[] = {
     { AV_CODEC_ID_PROSUMER,     MKTAG('B', 'T', '2', '0') },
     { AV_CODEC_ID_MWSC,         MKTAG('M', 'W', 'S', 'C') },
     { AV_CODEC_ID_WCMV,         MKTAG('W', 'C', 'M', 'V') },
+    { AV_CODEC_ID_RASC,         MKTAG('R', 'A', 'S', 'C') },
     { AV_CODEC_ID_NONE,         0 }
 };
 
