libavcodec/escape130.c

   1 /*
   2  * Escape 130 video decoder
   3  * Copyright (C) 2008 Eli Friedman (eli.friedman <at> gmail.com)
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/attributes.h"
  23 #include "libavutil/mem.h"
  24
  25 #define BITSTREAM_READER_LE
  26 #include "avcodec.h"
  27 #include "get_bits.h"
  28 #include "internal.h"
  29
  30 typedef struct Escape130Context {
  31     uint8_t *old_y_avg;
  32
  33     uint8_t *new_y, *old_y;
  34     uint8_t *new_u, *old_u;
  35     uint8_t *new_v, *old_v;
  36
  37     uint8_t *buf1, *buf2;
  38     int     linesize[3];
  39 } Escape130Context;
  40
  41 static const uint8_t offset_table[] = { 2, 4, 10, 20 };
  42 static const int8_t sign_table[64][4] = {
  43     {  0,  0,  0,  0 },
  44     { -1,  1,  0,  0 },
  45     {  1, -1,  0,  0 },
  46     { -1,  0,  1,  0 },
  47     { -1,  1,  1,  0 },
  48     {  0, -1,  1,  0 },
  49     {  1, -1,  1,  0 },
  50     { -1, -1,  1,  0 },
  51     {  1,  0, -1,  0 },
  52     {  0,  1, -1,  0 },
  53     {  1,  1, -1,  0 },
  54     { -1,  1, -1,  0 },
  55     {  1, -1, -1,  0 },
  56     { -1,  0,  0,  1 },
  57     { -1,  1,  0,  1 },
  58     {  0, -1,  0,  1 },
  59
  60     {  0,  0,  0,  0 },
  61     {  1, -1,  0,  1 },
  62     { -1, -1,  0,  1 },
  63     { -1,  0,  1,  1 },
  64     { -1,  1,  1,  1 },
  65     {  0, -1,  1,  1 },
  66     {  1, -1,  1,  1 },
  67     { -1, -1,  1,  1 },
  68     {  0,  0, -1,  1 },
  69     {  1,  0, -1,  1 },
  70     { -1,  0, -1,  1 },
  71     {  0,  1, -1,  1 },
  72     {  1,  1, -1,  1 },
  73     { -1,  1, -1,  1 },
  74     {  0, -1, -1,  1 },
  75     {  1, -1, -1,  1 },
  76
  77     {  0,  0,  0,  0 },
  78     { -1, -1, -1,  1 },
  79     {  1,  0,  0, -1 },
  80     {  0,  1,  0, -1 },
  81     {  1,  1,  0, -1 },
  82     { -1,  1,  0, -1 },
  83     {  1, -1,  0, -1 },
  84     {  0,  0,  1, -1 },
  85     {  1,  0,  1, -1 },
  86     { -1,  0,  1, -1 },
  87     {  0,  1,  1, -1 },
  88     {  1,  1,  1, -1 },
  89     { -1,  1,  1, -1 },
  90     {  0, -1,  1, -1 },
  91     {  1, -1,  1, -1 },
  92     { -1, -1,  1, -1 },
  93
  94     {  0,  0,  0,  0 },
  95     {  1,  0, -1, -1 },
  96     {  0,  1, -1, -1 },
  97     {  1,  1, -1, -1 },
  98     { -1,  1, -1, -1 },
  99     {  1, -1, -1, -1 }
 100 };
 101
 102 static const int8_t luma_adjust[] = { -4, -3, -2, -1, 1, 2, 3, 4 };
 103
 104 static const int8_t chroma_adjust[2][8] = {
 105     { 1, 1, 0, -1, -1, -1,  0,  1 },
 106     { 0, 1, 1,  1,  0, -1, -1, -1 }
 107 };
 108
 109 static const uint8_t chroma_vals[] = {
 110      20,  28,  36,  44,  52,  60,  68,  76,
 111      84,  92, 100, 106, 112, 116, 120, 124,
 112     128, 132, 136, 140, 144, 150, 156, 164,
 113     172, 180, 188, 196, 204, 212, 220, 228
 114 };
 115
 116 static av_cold int escape130_decode_init(AVCodecContext *avctx)
 117 {
 118     Escape130Context *s = avctx->priv_data;
 119     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 120
 121     if ((avctx->width & 1) || (avctx->height & 1)) {
 122         av_log(avctx, AV_LOG_ERROR,
 123                "Dimensions should be a multiple of two.\n");
 124         return AVERROR_INVALIDDATA;
 125     }
 126
 127     s->old_y_avg = av_malloc(avctx->width * avctx->height / 4);
 128     s->buf1      = av_malloc(avctx->width * avctx->height * 3 / 2);
 129     s->buf2      = av_malloc(avctx->width * avctx->height * 3 / 2);
 130     if (!s->old_y_avg || !s->buf1 || !s->buf2) {
 131         av_freep(&s->old_y_avg);
 132         av_freep(&s->buf1);
 133         av_freep(&s->buf2);
 134         av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
 135         return AVERROR(ENOMEM);
 136     }
 137
 138     s->linesize[0] = avctx->width;
 139     s->linesize[1] =
 140     s->linesize[2] = avctx->width / 2;
 141
 142     s->new_y = s->buf1;
 143     s->new_u = s->new_y + avctx->width * avctx->height;
 144     s->new_v = s->new_u + avctx->width * avctx->height / 4;
 145     s->old_y = s->buf2;
 146     s->old_u = s->old_y + avctx->width * avctx->height;
 147     s->old_v = s->old_u + avctx->width * avctx->height / 4;
 148     memset(s->old_y, 0,    avctx->width * avctx->height);
 149     memset(s->old_u, 0x10, avctx->width * avctx->height / 4);
 150     memset(s->old_v, 0x10, avctx->width * avctx->height / 4);
 151
 152     return 0;
 153 }
 154
 155 static av_cold int escape130_decode_close(AVCodecContext *avctx)
 156 {
 157     Escape130Context *s = avctx->priv_data;
 158
 159     av_freep(&s->old_y_avg);
 160     av_freep(&s->buf1);
 161     av_freep(&s->buf2);
 162
 163     return 0;
 164 }
 165
 166 static int decode_skip_count(GetBitContext* gb)
 167 {
 168     int value;
 169
 170     if (get_bits_left(gb) < 1+3)
 171         return -1;
 172
 173     value = get_bits1(gb);
 174     if (value)
 175         return 0;
 176
 177     value = get_bits(gb, 3);
 178     if (value)
 179         return value;
 180
 181     value = get_bits(gb, 8);
 182     if (value)
 183         return value + 7;
 184
 185     value = get_bits(gb, 15);
 186     if (value)
 187         return value + 262;
 188
 189     return -1;
 190 }
 191
 192 static int escape130_decode_frame(AVCodecContext *avctx, void *data,
 193                                   int *got_frame, AVPacket *avpkt)
 194 {
 195     int buf_size        = avpkt->size;
 196     Escape130Context *s = avctx->priv_data;
 197     AVFrame *pic        = data;
 198     GetBitContext gb;
 199     int ret;
 200
 201     uint8_t *old_y, *old_cb, *old_cr,
 202             *new_y, *new_cb, *new_cr;
 203     uint8_t *dstY, *dstU, *dstV;
 204     unsigned old_y_stride, old_cb_stride, old_cr_stride,
 205              new_y_stride, new_cb_stride, new_cr_stride;
 206     unsigned total_blocks = avctx->width * avctx->height / 4,
 207              block_index, block_x = 0;
 208     unsigned y[4] = { 0 }, cb = 0x10, cr = 0x10;
 209     int skip = -1, y_avg = 0, i, j;
 210     uint8_t *ya = s->old_y_avg;
 211
 212     // first 16 bytes are header; no useful information in here
 213     if (buf_size <= 16) {
 214         av_log(avctx, AV_LOG_ERROR, "Insufficient frame data\n");
 215         return AVERROR_INVALIDDATA;
 216     }
 217
 218     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 219         return ret;
 220
 221     if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
 222         return ret;
 223     skip_bits_long(&gb, 16 * 8);
 224
 225     new_y  = s->new_y;
 226     new_cb = s->new_u;
 227     new_cr = s->new_v;
 228     new_y_stride  = s->linesize[0];
 229     new_cb_stride = s->linesize[1];
 230     new_cr_stride = s->linesize[2];
 231     old_y  = s->old_y;
 232     old_cb = s->old_u;
 233     old_cr = s->old_v;
 234     old_y_stride  = s->linesize[0];
 235     old_cb_stride = s->linesize[1];
 236     old_cr_stride = s->linesize[2];
 237
 238     for (block_index = 0; block_index < total_blocks; block_index++) {
 239         // Note that this call will make us skip the rest of the blocks
 240         // if the frame ends prematurely.
 241         if (skip == -1)
 242             skip = decode_skip_count(&gb);
 243         if (skip == -1) {
 244             av_log(avctx, AV_LOG_ERROR, "Error decoding skip value\n");
 245             return AVERROR_INVALIDDATA;
 246         }
 247
 248         if (skip) {
 249             y[0] = old_y[0];
 250             y[1] = old_y[1];
 251             y[2] = old_y[old_y_stride];
 252             y[3] = old_y[old_y_stride + 1];
 253             y_avg = ya[0];
 254             cb = old_cb[0];
 255             cr = old_cr[0];
 256         } else {
 257             if (get_bits1(&gb)) {
 258                 unsigned sign_selector       = get_bits(&gb, 6);
 259                 unsigned difference_selector = get_bits(&gb, 2);
 260                 y_avg = 2 * get_bits(&gb, 5);
 261                 for (i = 0; i < 4; i++) {
 262                     y[i] = av_clip(y_avg + offset_table[difference_selector] *
 263                                    sign_table[sign_selector][i], 0, 63);
 264                 }
 265             } else if (get_bits1(&gb)) {
 266                 if (get_bits1(&gb)) {
 267                     y_avg = get_bits(&gb, 6);
 268                 } else {
 269                     unsigned adjust_index = get_bits(&gb, 3);
 270                     y_avg = (y_avg + luma_adjust[adjust_index]) & 63;
 271                 }
 272                 for (i = 0; i < 4; i++)
 273                     y[i] = y_avg;
 274             }
 275
 276             if (get_bits1(&gb)) {
 277                 if (get_bits1(&gb)) {
 278                     cb = get_bits(&gb, 5);
 279                     cr = get_bits(&gb, 5);
 280                 } else {
 281                     unsigned adjust_index = get_bits(&gb, 3);
 282                     cb = (cb + chroma_adjust[0][adjust_index]) & 31;
 283                     cr = (cr + chroma_adjust[1][adjust_index]) & 31;
 284                 }
 285             }
 286         }
 287         *ya++ = y_avg;
 288
 289         new_y[0]                = y[0];
 290         new_y[1]                = y[1];
 291         new_y[new_y_stride]     = y[2];
 292         new_y[new_y_stride + 1] = y[3];
 293         *new_cb = cb;
 294         *new_cr = cr;
 295
 296         old_y += 2;
 297         old_cb++;
 298         old_cr++;
 299         new_y += 2;
 300         new_cb++;
 301         new_cr++;
 302         block_x++;
 303         if (block_x * 2 == avctx->width) {
 304             block_x = 0;
 305             old_y  += old_y_stride * 2  - avctx->width;
 306             old_cb += old_cb_stride     - avctx->width / 2;
 307             old_cr += old_cr_stride     - avctx->width / 2;
 308             new_y  += new_y_stride * 2  - avctx->width;
 309             new_cb += new_cb_stride     - avctx->width / 2;
 310             new_cr += new_cr_stride     - avctx->width / 2;
 311         }
 312
 313         skip--;
 314     }
 315
 316     new_y  = s->new_y;
 317     new_cb = s->new_u;
 318     new_cr = s->new_v;
 319     dstY   = pic->data[0];
 320     dstU   = pic->data[1];
 321     dstV   = pic->data[2];
 322     for (j = 0; j < avctx->height; j++) {
 323         for (i = 0; i < avctx->width; i++)
 324             dstY[i] = new_y[i] << 2;
 325         dstY  += pic->linesize[0];
 326         new_y += new_y_stride;
 327     }
 328     for (j = 0; j < avctx->height / 2; j++) {
 329         for (i = 0; i < avctx->width / 2; i++) {
 330             dstU[i] = chroma_vals[new_cb[i]];
 331             dstV[i] = chroma_vals[new_cr[i]];
 332         }
 333         dstU   += pic->linesize[1];
 334         dstV   += pic->linesize[2];
 335         new_cb += new_cb_stride;
 336         new_cr += new_cr_stride;
 337     }
 338
 339     ff_dlog(avctx, "Frame data: provided %d bytes, used %d bytes\n",
 340             buf_size, get_bits_count(&gb) >> 3);
 341
 342     FFSWAP(uint8_t*, s->old_y, s->new_y);
 343     FFSWAP(uint8_t*, s->old_u, s->new_u);
 344     FFSWAP(uint8_t*, s->old_v, s->new_v);
 345
 346     *got_frame = 1;
 347
 348     return buf_size;
 349 }
 350
 351 AVCodec ff_escape130_decoder = {
 352     .name           = "escape130",
 353     .long_name      = NULL_IF_CONFIG_SMALL("Escape 130"),
 354     .type           = AVMEDIA_TYPE_VIDEO,
 355     .id             = AV_CODEC_ID_ESCAPE130,
 356     .priv_data_size = sizeof(Escape130Context),
 357     .init           = escape130_decode_init,
 358     .close          = escape130_decode_close,
 359     .decode         = escape130_decode_frame,
 360     .capabilities   = AV_CODEC_CAP_DR1,
 361 };