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

   1 /*
   2  * Interplay ACM decoder
   3  *
   4  * Copyright (c) 2004-2008 Marko Kreen
   5  * Copyright (c) 2008 Adam Gashlin
   6  * Copyright (c) 2015 Paul B Mahol
   7  *
   8  * Permission to use, copy, modify, and distribute this software for any
   9  * purpose with or without fee is hereby granted, provided that the above
  10  * copyright notice and this permission notice appear in all copies.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19  */
  20
  21 #include "libavutil/intreadwrite.h"
  22
  23 #define BITSTREAM_READER_LE
  24 #include "avcodec.h"
  25 #include "get_bits.h"
  26 #include "internal.h"
  27
  28 static const int8_t map_1bit[]      = { -1, +1 };
  29 static const int8_t map_2bit_near[] = { -2, -1, +1, +2 };
  30 static const int8_t map_2bit_far[]  = { -3, -2, +2, +3 };
  31 static const int8_t map_3bit[]      = { -4, -3, -2, -1, +1, +2, +3, +4 };
  32
  33 static int mul_3x3 [3 * 3 * 3];
  34 static int mul_3x5 [5 * 5 * 5];
  35 static int mul_2x11[11  *  11];
  36
  37 typedef struct InterplayACMContext {
  38     GetBitContext gb;
  39     uint8_t *bitstream;
  40     int max_framesize;
  41     int bitstream_size;
  42     int bitstream_index;
  43
  44     int level;
  45     int rows;
  46     int cols;
  47     int wrapbuf_len;
  48     int block_len;
  49     int skip;
  50
  51     int *block;
  52     int *wrapbuf;
  53     int *ampbuf;
  54     int *midbuf;
  55 } InterplayACMContext;
  56
  57 static av_cold int decode_init(AVCodecContext *avctx)
  58 {
  59     InterplayACMContext *s = avctx->priv_data;
  60     int x1, x2, x3;
  61
  62     if (avctx->extradata_size < 14)
  63         return AVERROR_INVALIDDATA;
  64
  65     if (avctx->channels <= 0) {
  66         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", avctx->channels);
  67         return AVERROR_INVALIDDATA;
  68     }
  69
  70     s->level = AV_RL16(avctx->extradata + 12) & 0xf;
  71     s->rows  = AV_RL16(avctx->extradata + 12) >>  4;
  72     s->cols  = 1 << s->level;
  73     s->wrapbuf_len = 2 * s->cols - 2;
  74     s->block_len = s->rows * s->cols;
  75     s->max_framesize = s->block_len;
  76
  77     s->block   = av_calloc(s->block_len, sizeof(int));
  78     s->wrapbuf = av_calloc(s->wrapbuf_len, sizeof(int));
  79     s->ampbuf  = av_calloc(0x10000, sizeof(int));
  80     s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*s->bitstream) + 1, sizeof(*s->bitstream));
  81     if (!s->block || !s->wrapbuf || !s->ampbuf || !s->bitstream)
  82         return AVERROR(ENOMEM);
  83
  84     s->midbuf  = s->ampbuf + 0x8000;
  85     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  86
  87     for (x3 = 0; x3 < 3; x3++)
  88         for (x2 = 0; x2 < 3; x2++)
  89             for (x1 = 0; x1 < 3; x1++)
  90                 mul_3x3[x1 + x2 * 3 + x3* 3 * 3] = x1 + (x2 << 4) + (x3 << 8);
  91     for (x3 = 0; x3 < 5; x3++)
  92         for (x2 = 0; x2 < 5; x2++)
  93             for (x1 = 0; x1 < 5; x1++)
  94                 mul_3x5[x1 + x2 * 5 + x3 * 5 * 5] = x1 + (x2 << 4) + (x3 << 8);
  95     for (x2 = 0; x2 < 11; x2++)
  96         for (x1 = 0; x1 < 11; x1++)
  97             mul_2x11[x1 + x2 * 11] = x1 + (x2 << 4);
  98
  99     return 0;
 100 }
 101
 102 #define set_pos(s, r, c, idx) do {               \
 103         unsigned pos = ((r) << s->level) + (c);  \
 104         s->block[pos] = s->midbuf[(idx)];        \
 105     } while (0)
 106
 107 static int zero(InterplayACMContext *s, unsigned ind, unsigned col)
 108 {
 109     unsigned i;
 110
 111     for (i = 0; i < s->rows; i++)
 112         set_pos(s, i, col, 0);
 113     return 0;
 114 }
 115
 116 static int bad(InterplayACMContext *s, unsigned ind, unsigned col)
 117 {
 118     return AVERROR_INVALIDDATA;
 119 }
 120
 121 static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
 122 {
 123     GetBitContext *gb = &s->gb;
 124     unsigned int i;
 125     int b, middle = 1 << (ind - 1);
 126
 127     for (i = 0; i < s->rows; i++) {
 128         b = get_bits(gb, ind);
 129         set_pos(s, i, col, b - middle);
 130     }
 131     return 0;
 132 }
 133
 134 static int k13(InterplayACMContext *s, unsigned ind, unsigned col)
 135 {
 136     GetBitContext *gb = &s->gb;
 137     unsigned i, b;
 138
 139     for (i = 0; i < s->rows; i++) {
 140         b = get_bits1(gb);
 141         if (b == 0) {
 142             set_pos(s, i++, col, 0);
 143             if (i >= s->rows)
 144                 break;
 145             set_pos(s, i, col, 0);
 146             continue;
 147         }
 148         b = get_bits1(gb);
 149         if (b == 0) {
 150             set_pos(s, i, col, 0);
 151             continue;
 152         }
 153         b = get_bits1(gb);
 154         set_pos(s, i, col, map_1bit[b]);
 155     }
 156     return 0;
 157 }
 158
 159 static int k12(InterplayACMContext *s, unsigned ind, unsigned col)
 160 {
 161     GetBitContext *gb = &s->gb;
 162     unsigned i, b;
 163
 164     for (i = 0; i < s->rows; i++) {
 165         b = get_bits1(gb);
 166         if (b == 0) {
 167             set_pos(s, i, col, 0);
 168             continue;
 169         }
 170
 171         b = get_bits1(gb);
 172         set_pos(s, i, col, map_1bit[b]);
 173     }
 174     return 0;
 175 }
 176
 177 static int k24(InterplayACMContext *s, unsigned ind, unsigned col)
 178 {
 179     GetBitContext *gb = &s->gb;
 180     unsigned i, b;
 181
 182     for (i = 0; i < s->rows; i++) {
 183         b = get_bits1(gb);
 184         if (b == 0) {
 185             set_pos(s, i++, col, 0);
 186             if (i >= s->rows) break;
 187             set_pos(s, i, col, 0);
 188             continue;
 189         }
 190
 191         b = get_bits1(gb);
 192         if (b == 0) {
 193             set_pos(s, i, col, 0);
 194             continue;
 195         }
 196
 197         b = get_bits(gb, 2);
 198         set_pos(s, i, col, map_2bit_near[b]);
 199     }
 200     return 0;
 201 }
 202
 203 static int k23(InterplayACMContext *s, unsigned ind, unsigned col)
 204 {
 205     GetBitContext *gb = &s->gb;
 206     unsigned i, b;
 207
 208     for (i = 0; i < s->rows; i++) {
 209         b = get_bits1(gb);
 210         if (b == 0) {
 211             set_pos(s, i, col, 0);
 212             continue;
 213         }
 214
 215         b = get_bits(gb, 2);
 216         set_pos(s, i, col, map_2bit_near[b]);
 217     }
 218     return 0;
 219 }
 220
 221 static int k35(InterplayACMContext *s, unsigned ind, unsigned col)
 222 {
 223     GetBitContext *gb = &s->gb;
 224     unsigned i, b;
 225
 226     for (i = 0; i < s->rows; i++) {
 227         b = get_bits1(gb);
 228         if (b == 0) {
 229             set_pos(s, i++, col, 0);
 230             if (i >= s->rows)
 231                 break;
 232             set_pos(s, i, col, 0);
 233             continue;
 234         }
 235
 236         b = get_bits1(gb);
 237         if (b == 0) {
 238             set_pos(s, i, col, 0);
 239             continue;
 240         }
 241
 242         b = get_bits1(gb);
 243         if (b == 0) {
 244             b = get_bits1(gb);
 245             set_pos(s, i, col, map_1bit[b]);
 246             continue;
 247         }
 248
 249         b = get_bits(gb, 2);
 250         set_pos(s, i, col, map_2bit_far[b]);
 251     }
 252     return 0;
 253 }
 254
 255 static int k34(InterplayACMContext *s, unsigned ind, unsigned col)
 256 {
 257     GetBitContext *gb = &s->gb;
 258     unsigned i, b;
 259
 260     for (i = 0; i < s->rows; i++) {
 261         b = get_bits1(gb);
 262         if (b == 0) {
 263             set_pos(s, i, col, 0);
 264             continue;
 265         }
 266
 267         b = get_bits1(gb);
 268         if (b == 0) {
 269             b = get_bits1(gb);
 270             set_pos(s, i, col, map_1bit[b]);
 271             continue;
 272         }
 273
 274         b = get_bits(gb, 2);
 275         set_pos(s, i, col, map_2bit_far[b]);
 276     }
 277     return 0;
 278 }
 279
 280 static int k45(InterplayACMContext *s, unsigned ind, unsigned col)
 281 {
 282     GetBitContext *gb = &s->gb;
 283     unsigned i, b;
 284
 285     for (i = 0; i < s->rows; i++) {
 286         b = get_bits1(gb);
 287         if (b == 0) {
 288             set_pos(s, i, col, 0); i++;
 289             if (i >= s->rows)
 290                 break;
 291             set_pos(s, i, col, 0);
 292             continue;
 293         }
 294
 295         b = get_bits1(gb);
 296         if (b == 0) {
 297             set_pos(s, i, col, 0);
 298             continue;
 299         }
 300
 301         b = get_bits(gb, 3);
 302         set_pos(s, i, col, map_3bit[b]);
 303     }
 304     return 0;
 305 }
 306
 307 static int k44(InterplayACMContext *s, unsigned ind, unsigned col)
 308 {
 309     GetBitContext *gb = &s->gb;
 310     unsigned i, b;
 311
 312     for (i = 0; i < s->rows; i++) {
 313         b = get_bits1(gb);
 314         if (b == 0) {
 315             set_pos(s, i, col, 0);
 316             continue;
 317         }
 318
 319         b = get_bits(gb, 3);
 320         set_pos(s, i, col, map_3bit[b]);
 321     }
 322     return 0;
 323 }
 324
 325 static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
 326 {
 327     GetBitContext *gb = &s->gb;
 328     unsigned i, b;
 329     int n1, n2, n3;
 330
 331     for (i = 0; i < s->rows; i++) {
 332         /* b = (x1) + (x2 * 3) + (x3 * 9) */
 333         b = get_bits(gb, 5);
 334         if (b > 26) {
 335             av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 26\n", b);
 336             return AVERROR_INVALIDDATA;
 337         }
 338
 339         n1 =  (mul_3x3[b] & 0x0F) - 1;
 340         n2 = ((mul_3x3[b] >> 4) & 0x0F) - 1;
 341         n3 = ((mul_3x3[b] >> 8) & 0x0F) - 1;
 342
 343         set_pos(s, i++, col, n1);
 344         if (i >= s->rows)
 345             break;
 346         set_pos(s, i++, col, n2);
 347         if (i >= s->rows)
 348             break;
 349         set_pos(s, i, col, n3);
 350     }
 351     return 0;
 352 }
 353
 354 static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
 355 {
 356     GetBitContext *gb = &s->gb;
 357     unsigned i, b;
 358     int n1, n2, n3;
 359
 360     for (i = 0; i < s->rows; i++) {
 361         /* b = (x1) + (x2 * 5) + (x3 * 25) */
 362         b = get_bits(gb, 7);
 363         if (b > 124) {
 364             av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 124\n", b);
 365             return AVERROR_INVALIDDATA;
 366         }
 367
 368         n1 =  (mul_3x5[b] & 0x0F) - 2;
 369         n2 = ((mul_3x5[b] >> 4) & 0x0F) - 2;
 370         n3 = ((mul_3x5[b] >> 8) & 0x0F) - 2;
 371
 372         set_pos(s, i++, col, n1);
 373         if (i >= s->rows)
 374             break;
 375         set_pos(s, i++, col, n2);
 376         if (i >= s->rows)
 377             break;
 378         set_pos(s, i, col, n3);
 379     }
 380     return 0;
 381 }
 382
 383 static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
 384 {
 385     GetBitContext *gb = &s->gb;
 386     unsigned i, b;
 387     int n1, n2;
 388     for (i = 0; i < s->rows; i++) {
 389         /* b = (x1) + (x2 * 11) */
 390         b = get_bits(gb, 7);
 391         if (b > 120) {
 392             av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 120\n", b);
 393             return AVERROR_INVALIDDATA;
 394         }
 395
 396         n1 =  (mul_2x11[b] & 0x0F) - 5;
 397         n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5;
 398
 399         set_pos(s, i++, col, n1);
 400         if (i >= s->rows)
 401             break;
 402         set_pos(s, i, col, n2);
 403     }
 404     return 0;
 405 }
 406
 407 typedef int (*filler)(InterplayACMContext *s, unsigned ind, unsigned col);
 408
 409 static const filler filler_list[] = {
 410     zero,   bad,    bad,    linear,
 411     linear, linear, linear, linear,
 412     linear, linear, linear, linear,
 413     linear, linear, linear, linear,
 414     linear, k13,    k12,    t15,
 415     k24,    k23,    t27,    k35,
 416     k34,    bad,    k45,    k44,
 417     bad,    t37,    bad,    bad,
 418 };
 419
 420 static int fill_block(InterplayACMContext *s)
 421 {
 422     GetBitContext *gb = &s->gb;
 423     unsigned i, ind;
 424     int ret;
 425
 426     for (i = 0; i < s->cols; i++) {
 427         ind = get_bits(gb, 5);
 428         ret = filler_list[ind](s, ind, i);
 429         if (ret < 0)
 430             return ret;
 431     }
 432     return 0;
 433 }
 434
 435 static void juggle(int *wrap_p, int *block_p, unsigned sub_len, unsigned sub_count)
 436 {
 437     unsigned i, j;
 438     int *p, r0, r1, r2, r3;
 439
 440     for (i = 0; i < sub_len; i++) {
 441         p = block_p;
 442         r0 = wrap_p[0];
 443         r1 = wrap_p[1];
 444         for (j = 0; j < sub_count/2; j++) {
 445             r2 = *p;
 446             *p = r1 * 2 + (r0 + r2);
 447             p += sub_len;
 448             r3 = *p;
 449             *p = r2 * 2 - (r1 + r3);
 450             p += sub_len;
 451             r0 = r2;
 452             r1 = r3;
 453         }
 454
 455         *wrap_p++ = r0;
 456         *wrap_p++ = r1;
 457         block_p++;
 458     }
 459 }
 460
 461 static void juggle_block(InterplayACMContext *s)
 462 {
 463     unsigned sub_count, sub_len, todo_count, step_subcount, i;
 464     int *wrap_p, *block_p, *p;
 465
 466     /* juggle only if subblock_len > 1 */
 467     if (s->level == 0)
 468         return;
 469
 470     /* 2048 / subblock_len */
 471     if (s->level > 9)
 472         step_subcount = 1;
 473     else
 474         step_subcount = (2048 >> s->level) - 2;
 475
 476     /* Apply juggle()  (rows)x(cols)
 477      * from (step_subcount * 2)            x (subblock_len/2)
 478      * to   (step_subcount * subblock_len) x (1)
 479      */
 480     todo_count = s->rows;
 481     block_p = s->block;
 482     while (1) {
 483         wrap_p = s->wrapbuf;
 484         sub_count = step_subcount;
 485         if (sub_count > todo_count)
 486             sub_count = todo_count;
 487
 488         sub_len = s->cols / 2;
 489         sub_count *= 2;
 490
 491         juggle(wrap_p, block_p, sub_len, sub_count);
 492         wrap_p += sub_len * 2;
 493
 494         for (i = 0, p = block_p; i < sub_count; i++) {
 495             p[0]++;
 496             p += sub_len;
 497         }
 498
 499         while (sub_len > 1) {
 500             sub_len /= 2;
 501             sub_count *= 2;
 502             juggle(wrap_p, block_p, sub_len, sub_count);
 503             wrap_p += sub_len * 2;
 504         }
 505
 506         if (todo_count <= step_subcount)
 507             break;
 508
 509         todo_count -= step_subcount;
 510         block_p += step_subcount << s->level;
 511     }
 512 }
 513
 514 static int decode_block(InterplayACMContext *s)
 515 {
 516     GetBitContext *gb = &s->gb;
 517     int pwr, count, val, i, x, ret;
 518
 519     pwr = get_bits(gb, 4);
 520     val = get_bits(gb, 16);
 521
 522     count = 1 << pwr;
 523
 524     for (i = 0, x = 0; i < count; i++) {
 525         s->midbuf[i] = x;
 526         x += val;
 527     }
 528
 529     for (i = 1, x = -val; i <= count; i++) {
 530         s->midbuf[-i] = x;
 531         x -= val;
 532     }
 533
 534     ret = fill_block(s);
 535     if (ret < 0)
 536         return ret;
 537
 538     juggle_block(s);
 539
 540     return 0;
 541 }
 542
 543 static int decode_frame(AVCodecContext *avctx, void *data,
 544                         int *got_frame_ptr, AVPacket *pkt)
 545 {
 546     InterplayACMContext *s = avctx->priv_data;
 547     GetBitContext *gb = &s->gb;
 548     AVFrame *frame = data;
 549     const uint8_t *buf;
 550     int16_t *samples;
 551     int ret, n, buf_size, input_buf_size;
 552
 553     if (!pkt->size && !s->bitstream_size) {
 554         *got_frame_ptr = 0;
 555         return 0;
 556     }
 557
 558     buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
 559     input_buf_size = buf_size;
 560     if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
 561         memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 562         s->bitstream_index = 0;
 563     }
 564     if (pkt->data)
 565         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
 566     buf                = &s->bitstream[s->bitstream_index];
 567     buf_size          += s->bitstream_size;
 568     s->bitstream_size  = buf_size;
 569     if (buf_size < s->max_framesize && pkt->data) {
 570         *got_frame_ptr = 0;
 571         return input_buf_size;
 572     }
 573
 574     if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
 575         return ret;
 576
 577     frame->nb_samples = s->block_len / avctx->channels;
 578     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 579         return ret;
 580
 581     skip_bits(gb, s->skip);
 582     ret = decode_block(s);
 583     if (ret < 0)
 584         return ret;
 585
 586     samples = (int16_t *)frame->data[0];
 587     for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
 588         int val = s->block[n] >> s->level;
 589         *samples++ = val;
 590     }
 591
 592     *got_frame_ptr = 1;
 593     s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
 594     n = get_bits_count(gb) / 8;
 595
 596     if (n > buf_size && pkt->data) {
 597         s->bitstream_size = 0;
 598         s->bitstream_index = 0;
 599         return AVERROR_INVALIDDATA;
 600     }
 601
 602     if (s->bitstream_size) {
 603         s->bitstream_index += n;
 604         s->bitstream_size  -= n;
 605         return input_buf_size;
 606     }
 607     return n;
 608 }
 609
 610 static av_cold int decode_close(AVCodecContext *avctx)
 611 {
 612     InterplayACMContext *s = avctx->priv_data;
 613
 614     av_freep(&s->block);
 615     av_freep(&s->wrapbuf);
 616     av_freep(&s->ampbuf);
 617     av_freep(&s->bitstream);
 618     s->bitstream_size = 0;
 619
 620     return 0;
 621 }
 622
 623 AVCodec ff_interplay_acm_decoder = {
 624     .name           = "interplayacm",
 625     .long_name      = NULL_IF_CONFIG_SMALL("Interplay ACM"),
 626     .type           = AVMEDIA_TYPE_AUDIO,
 627     .id             = AV_CODEC_ID_INTERPLAY_ACM,
 628     .init           = decode_init,
 629     .close          = decode_close,
 630     .decode         = decode_frame,
 631     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
 632     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 633     .priv_data_size = sizeof(InterplayACMContext),
 634 };