git.sesse.net Git - ffmpeg/blob - libavcodec/gdv.c

   1 /*
   2  * Gremlin Digital Video (GDV) decoder
   3  * Copyright (c) 2017 Konstantin Shishkov
   4  * Copyright (c) 2017 Paul B Mahol
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "libavutil/common.h"
  24 #include "avcodec.h"
  25 #include "bytestream.h"
  26 #include "internal.h"
  27
  28 typedef struct GDVContext {
  29     AVCodecContext *avctx;
  30
  31     GetByteContext gb;
  32     GetByteContext g2;
  33     PutByteContext pb;
  34
  35     uint32_t pal[256];
  36     uint8_t *frame;
  37     unsigned frame_size;
  38     unsigned scale_h, scale_v;
  39 } GDVContext;
  40
  41 typedef struct Bits8 {
  42     uint8_t queue;
  43     uint8_t fill;
  44 } Bits8;
  45
  46 typedef struct Bits32 {
  47     uint32_t queue;
  48     uint8_t  fill;
  49 } Bits32;
  50
  51 #define PREAMBLE_SIZE 4096
  52
  53 static av_cold int gdv_decode_init(AVCodecContext *avctx)
  54 {
  55     GDVContext *gdv = avctx->priv_data;
  56     int i, j, k;
  57
  58     avctx->pix_fmt  = AV_PIX_FMT_PAL8;
  59     gdv->frame_size = avctx->width * avctx->height + PREAMBLE_SIZE;
  60     gdv->frame = av_calloc(gdv->frame_size, 1);
  61     if (!gdv->frame)
  62         return AVERROR(ENOMEM);
  63
  64     for (i = 0; i < 2; i++) {
  65         for (j = 0; j < 256; j++) {
  66             for (k = 0; k < 8; k++) {
  67                 gdv->frame[i * 2048 + j * 8 + k] = j;
  68             }
  69         }
  70     }
  71
  72     return 0;
  73 }
  74
  75 static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
  76 {
  77     int i, j, y, x;
  78
  79     if ((gdv->scale_v == scale_v) && (gdv->scale_h == scale_h)) {
  80         return;
  81     }
  82
  83     if (gdv->scale_h && gdv->scale_v) {
  84         for (j = 0; j < h; j++) {
  85             int y = h - j - 1;
  86             for (i = 0; i < w; i++) {
  87                 int x = w - i - 1;
  88                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + (y/2) * (w/2)];
  89             }
  90         }
  91     } else if (gdv->scale_h) {
  92         for (j = 0; j < h; j++) {
  93             int y = h - j - 1;
  94             for (x = 0; x < w; x++) {
  95                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + (y/2) * w];
  96             }
  97         }
  98     } else if (gdv->scale_v) {
  99         for (j = 0; j < h; j++) {
 100             int y = h - j - 1;
 101             for (i = 0; i < w; i++) {
 102                 int x = w - i - 1;
 103                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + y * (w/2)];
 104             }
 105         }
 106     }
 107
 108     if (scale_h && scale_v) {
 109         for (y = 0; y < h/2; y++) {
 110             for (x = 0; x < w/2; x++) {
 111                 dst[PREAMBLE_SIZE + x + y * (w/2)] = dst[PREAMBLE_SIZE + x*2 + y*2 * w];
 112             }
 113         }
 114     } else if (scale_h) {
 115         for (y = 0; y < h/2; y++) {
 116             for (x = 0; x < w; x++) {
 117                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + y*2 * w];
 118             }
 119         }
 120     } else if (scale_v) {
 121         for (y = 0; y < h; y++) {
 122             for (x = 0; x < w/2; x++) {
 123                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x*2 + y * w];
 124             }
 125         }
 126     }
 127
 128     gdv->scale_v = scale_v;
 129     gdv->scale_h = scale_h;
 130 }
 131
 132 static int read_bits2(Bits8 *bits, GetByteContext *gb)
 133 {
 134     int res;
 135
 136     if (bits->fill == 0) {
 137         bits->queue |= bytestream2_get_byte(gb);
 138         bits->fill   = 8;
 139     }
 140     res = bits->queue >> 6;
 141     bits->queue <<= 2;
 142     bits->fill   -= 2;
 143
 144     return res;
 145 }
 146
 147 static void fill_bits32(Bits32 *bits, GetByteContext *gb)
 148 {
 149     bits->queue = bytestream2_get_le32(gb);
 150     bits->fill  = 32;
 151 }
 152
 153 static int read_bits32(Bits32 *bits, GetByteContext *gb, int nbits)
 154 {
 155     int res = bits->queue & ((1 << nbits) - 1);
 156
 157     bits->queue >>= nbits;
 158     bits->fill   -= nbits;
 159     if (bits->fill <= 16) {
 160         bits->queue |= bytestream2_get_le16(gb) << bits->fill;
 161         bits->fill  += 16;
 162     }
 163
 164     return res;
 165 }
 166
 167 static void lz_copy(PutByteContext *pb, GetByteContext *g2, int offset, unsigned len)
 168 {
 169     int i;
 170
 171     if (offset == -1) {
 172         int c;
 173
 174         bytestream2_seek(g2, bytestream2_tell_p(pb) - 1, SEEK_SET);
 175         c = bytestream2_get_byte(g2);
 176         for (i = 0; i < len; i++) {
 177             bytestream2_put_byte(pb, c);
 178         }
 179     } else if (offset < 0) {
 180         int start = bytestream2_tell_p(pb) - (-offset);
 181
 182         bytestream2_seek(g2, start, SEEK_SET);
 183         for (i = 0; i < len; i++) {
 184             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
 185         }
 186     } else {
 187         int start = bytestream2_tell_p(pb) + offset;
 188
 189         bytestream2_seek(g2, start, SEEK_SET);
 190         for (i = 0; i < len; i++) {
 191             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
 192         }
 193     }
 194 }
 195
 196 static int decompress_2(AVCodecContext *avctx)
 197 {
 198     GDVContext *gdv = avctx->priv_data;
 199     GetByteContext *gb = &gdv->gb;
 200     GetByteContext *g2 = &gdv->g2;
 201     PutByteContext *pb = &gdv->pb;
 202     Bits8 bits = { 0 };
 203     int c, i;
 204
 205     bytestream2_init(g2, gdv->frame, gdv->frame_size);
 206     bytestream2_skip_p(pb, PREAMBLE_SIZE);
 207
 208     for (c = 0; c < 256; c++) {
 209         for (i = 0; i < 16; i++) {
 210             gdv->frame[c * 16 + i] = c;
 211         }
 212     }
 213
 214     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
 215         int tag = read_bits2(&bits, gb);
 216         if (tag == 0) {
 217             bytestream2_put_byte(pb, bytestream2_get_byte(gb));
 218         } else if (tag == 1) {
 219             int b = bytestream2_get_byte(gb);
 220             int len = (b & 0xF) + 3;
 221             int top = (b >> 4) & 0xF;
 222             int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
 223             lz_copy(pb, g2, off, len);
 224         } else if (tag == 2) {
 225             int len = (bytestream2_get_byte(gb)) + 2;
 226             bytestream2_skip_p(pb, len);
 227         } else {
 228             break;
 229         }
 230     }
 231     return 0;
 232 }
 233
 234 static int decompress_5(AVCodecContext *avctx, unsigned skip)
 235 {
 236     GDVContext *gdv = avctx->priv_data;
 237     GetByteContext *gb = &gdv->gb;
 238     GetByteContext *g2 = &gdv->g2;
 239     PutByteContext *pb = &gdv->pb;
 240     Bits8 bits = { 0 };
 241
 242     bytestream2_init(g2, gdv->frame, gdv->frame_size);
 243     bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
 244
 245     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
 246         int tag = read_bits2(&bits, gb);
 247         if (tag == 0) {
 248             bytestream2_put_byte(pb, bytestream2_get_byte(gb));
 249         } else if (tag == 1) {
 250             int b = bytestream2_get_byte(gb);
 251             int len = (b & 0xF) + 3;
 252             int top = b >> 4;
 253             int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
 254             lz_copy(pb, g2, off, len);
 255         } else if (tag == 2) {
 256             int len;
 257             int b = bytestream2_get_byte(gb);
 258             if (b == 0) {
 259                 break;
 260             }
 261             if (b != 0xFF) {
 262                 len = b;
 263             } else {
 264                 len = bytestream2_get_le16(gb);
 265             }
 266             bytestream2_skip_p(pb, len + 1);
 267         } else {
 268             int b = bytestream2_get_byte(gb);
 269             int len = (b & 0x3) + 2;
 270             int off = -(b >> 2) - 1;
 271             lz_copy(pb, g2, off, len);
 272         }
 273     }
 274     return 0;
 275 }
 276
 277 static int decompress_68(AVCodecContext *avctx, unsigned skip, unsigned use8)
 278 {
 279     GDVContext *gdv = avctx->priv_data;
 280     GetByteContext *gb = &gdv->gb;
 281     GetByteContext *g2 = &gdv->g2;
 282     PutByteContext *pb = &gdv->pb;
 283     Bits32 bits;
 284
 285     bytestream2_init(g2, gdv->frame, gdv->frame_size);
 286     bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
 287     fill_bits32(&bits, gb);
 288
 289     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
 290         int tag = read_bits32(&bits, gb, 2);
 291         if (tag == 0) {
 292             int b = read_bits32(&bits, gb, 1);
 293             if (b == 0) {
 294                 bytestream2_put_byte(pb, bytestream2_get_byte(gb));
 295             } else {
 296                 int i, len = 2;
 297                 int lbits = 0;
 298                 while (1) {
 299                     int val;
 300
 301                     lbits += 1;
 302                     val = read_bits32(&bits, gb, lbits);
 303                     len += val;
 304                     if (val != ((1 << lbits) - 1)) {
 305                         break;
 306                     }
 307                     assert(lbits < 16);
 308                 }
 309                 for (i = 0; i < len; i++) {
 310                     bytestream2_put_byte(pb, bytestream2_get_byte(gb));
 311                 }
 312             }
 313         } else if (tag == 1) {
 314             int b = read_bits32(&bits, gb, 1);
 315             int len;
 316
 317             if (b == 0) {
 318                 len = (read_bits32(&bits, gb, 4)) + 2;
 319             } else {
 320                 int bb = bytestream2_get_byte(gb);
 321                 if ((bb & 0x80) == 0) {
 322                     len = bb + 18;
 323                 } else {
 324                     int top = (bb & 0x7F) << 8;
 325                     len = top + bytestream2_get_byte(gb) + 146;
 326                 }
 327             }
 328             bytestream2_skip_p(pb, len);
 329         } else if (tag == 2) {
 330             int i, subtag = read_bits32(&bits, gb, 2);
 331
 332             if (subtag != 3) {
 333                 int top = (read_bits32(&bits, gb, 4)) << 8;
 334                 int offs = top + bytestream2_get_byte(gb);
 335                 if ((subtag != 0) || (offs <= 0xF80)) {
 336                     int len = (subtag) + 3;
 337                     lz_copy(pb, g2, (offs) - 4096, len);
 338                 } else {
 339                     int real_off, len, c1, c2;
 340
 341                     if (offs == 0xFFF) {
 342                         return 0;
 343                     }
 344
 345                     real_off = ((offs >> 4) & 0x7) + 1;
 346                     len = ((offs & 0xF) + 2) * 2;
 347                     c1 = gdv->frame[bytestream2_tell_p(pb) - real_off];
 348                     c2 = gdv->frame[bytestream2_tell_p(pb) - real_off + 1];
 349                     for (i = 0; i < len/2; i++) {
 350                         bytestream2_put_byte(pb, c1);
 351                         bytestream2_put_byte(pb, c2);
 352                     }
 353                 }
 354             } else {
 355                 int b = bytestream2_get_byte(gb);
 356                 int off = ((b & 0x7F)) + 1;
 357                 int len = ((b & 0x80) == 0) ? 2 : 3;
 358
 359                 lz_copy(pb, g2, -off, len);
 360             }
 361         } else {
 362             int len;
 363             int off;
 364             if (use8) {
 365                 int q, b = bytestream2_get_byte(gb);
 366                 if ((b & 0xC0) == 0xC0) {
 367                     len = ((b & 0x3F)) + 8;
 368                     q = read_bits32(&bits, gb, 4);
 369                     off = (q << 8) + (bytestream2_get_byte(gb)) + 1;
 370                 } else {
 371                     int ofs1;
 372                     if ((b & 0x80) == 0) {
 373                         len = ((b >> 4)) + 6;
 374                         ofs1 = (b & 0xF);
 375                     } else {
 376                         len = ((b & 0x3F)) + 14;
 377                         ofs1 = read_bits32(&bits, gb, 4);
 378                     }
 379                     off = (ofs1 << 8) + (bytestream2_get_byte(gb)) - 4096;
 380                 }
 381             } else {
 382                 int ofs1, b = bytestream2_get_byte(gb);
 383
 384                 if ((b >> 4) == 0xF) {
 385                     len = bytestream2_get_byte(gb) + 21;
 386                 } else {
 387                     len = (b >> 4) + 6;
 388                 }
 389                 ofs1 = (b & 0xF);
 390                 off = (ofs1 << 8) + bytestream2_get_byte(gb) - 4096;
 391             }
 392             lz_copy(pb, g2, off, len);
 393         }
 394     }
 395
 396     return 0;
 397 }
 398
 399 static int gdv_decode_frame(AVCodecContext *avctx, void *data,
 400                             int *got_frame, AVPacket *avpkt)
 401 {
 402     GDVContext *gdv = avctx->priv_data;
 403     GetByteContext *gb = &gdv->gb;
 404     PutByteContext *pb = &gdv->pb;
 405     AVFrame *frame = data;
 406     int ret, i, pal_size;
 407     const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
 408     int compression;
 409     unsigned flags;
 410     uint8_t *dst;
 411
 412     bytestream2_init(gb, avpkt->data, avpkt->size);
 413     bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);
 414
 415     flags = bytestream2_get_le32(gb);
 416     compression = flags & 0xF;
 417
 418     if (compression == 4 || compression == 7 || compression > 8)
 419         return AVERROR_INVALIDDATA;
 420
 421     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 422         return ret;
 423     if (pal && pal_size == AVPALETTE_SIZE)
 424         memcpy(gdv->pal, pal, AVPALETTE_SIZE);
 425
 426     rescale(gdv, gdv->frame, avctx->width, avctx->height,
 427             !!(flags & 0x10), !!(flags & 0x20));
 428
 429     switch (compression) {
 430     case 1:
 431         memset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);
 432     case 0:
 433         if (bytestream2_get_bytes_left(gb) < 256*3)
 434             return AVERROR_INVALIDDATA;
 435         for (i = 0; i < 256; i++) {
 436             unsigned r = bytestream2_get_byte(gb);
 437             unsigned g = bytestream2_get_byte(gb);
 438             unsigned b = bytestream2_get_byte(gb);
 439             gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
 440         }
 441         break;
 442     case 2:
 443         ret = decompress_2(avctx);
 444         break;
 445     case 3:
 446         break;
 447     case 5:
 448         ret = decompress_5(avctx, flags >> 8);
 449         break;
 450     case 6:
 451         ret = decompress_68(avctx, flags >> 8, 0);
 452         break;
 453     case 8:
 454         ret = decompress_68(avctx, flags >> 8, 1);
 455         break;
 456     default:
 457         av_assert0(0);
 458     }
 459
 460     memcpy(frame->data[1], gdv->pal, AVPALETTE_SIZE);
 461     dst = frame->data[0];
 462
 463     if (!gdv->scale_v && !gdv->scale_h) {
 464         int sidx = PREAMBLE_SIZE, didx = 0;
 465         int y, x;
 466
 467         for (y = 0; y < avctx->height; y++) {
 468             for (x = 0; x < avctx->width; x++) {
 469                 dst[x+didx] = gdv->frame[x+sidx];
 470             }
 471             sidx += avctx->width;
 472             didx += frame->linesize[0];
 473         }
 474     } else {
 475         int sidx = PREAMBLE_SIZE, didx = 0;
 476         int y, x;
 477
 478         for (y = 0; y < avctx->height; y++) {
 479             if (!gdv->scale_v) {
 480                 for (x = 0; x < avctx->width; x++) {
 481                     dst[didx + x] = gdv->frame[sidx + x];
 482                 }
 483             } else {
 484                 for (x = 0; x < avctx->width; x++) {
 485                     dst[didx + x] = gdv->frame[sidx + x/2];
 486                 }
 487             }
 488             if (!gdv->scale_h || ((y & 1) == 1)) {
 489                 sidx += !gdv->scale_v ? avctx->width : avctx->width/2;
 490             }
 491             didx += frame->linesize[0];
 492         }
 493     }
 494
 495     *got_frame = 1;
 496
 497     return ret < 0 ? ret : avpkt->size;
 498 }
 499
 500 static av_cold int gdv_decode_close(AVCodecContext *avctx)
 501 {
 502     GDVContext *gdv = avctx->priv_data;
 503     av_freep(&gdv->frame);
 504     return 0;
 505 }
 506
 507 AVCodec ff_gdv_decoder = {
 508     .name           = "gdv",
 509     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
 510     .type           = AVMEDIA_TYPE_VIDEO,
 511     .id             = AV_CODEC_ID_GDV,
 512     .priv_data_size = sizeof(GDVContext),
 513     .init           = gdv_decode_init,
 514     .close          = gdv_decode_close,
 515     .decode         = gdv_decode_frame,
 516     .capabilities   = AV_CODEC_CAP_DR1,
 517     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 518 };