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