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;
 439     unsigned int r0, r1, r2, r3;
 440
 441     for (i = 0; i < sub_len; i++) {
 442         p = block_p;
 443         r0 = wrap_p[0];
 444         r1 = wrap_p[1];
 445         for (j = 0; j < sub_count/2; j++) {
 446             r2 = *p;
 447             *p = r1 * 2 + (r0 + r2);
 448             p += sub_len;
 449             r3 = *p;
 450             *p = r2 * 2 - (r1 + r3);
 451             p += sub_len;
 452             r0 = r2;
 453             r1 = r3;
 454         }
 455
 456         *wrap_p++ = r0;
 457         *wrap_p++ = r1;
 458         block_p++;
 459     }
 460 }
 461
 462 static void juggle_block(InterplayACMContext *s)
 463 {
 464     unsigned sub_count, sub_len, todo_count, step_subcount, i;
 465     int *wrap_p, *block_p, *p;
 466
 467     /* juggle only if subblock_len > 1 */
 468     if (s->level == 0)
 469         return;
 470
 471     /* 2048 / subblock_len */
 472     if (s->level > 9)
 473         step_subcount = 1;
 474     else
 475         step_subcount = (2048 >> s->level) - 2;
 476
 477     /* Apply juggle()  (rows)x(cols)
 478      * from (step_subcount * 2)            x (subblock_len/2)
 479      * to   (step_subcount * subblock_len) x (1)
 480      */
 481     todo_count = s->rows;
 482     block_p = s->block;
 483     while (1) {
 484         wrap_p = s->wrapbuf;
 485         sub_count = step_subcount;
 486         if (sub_count > todo_count)
 487             sub_count = todo_count;
 488
 489         sub_len = s->cols / 2;
 490         sub_count *= 2;
 491
 492         juggle(wrap_p, block_p, sub_len, sub_count);
 493         wrap_p += sub_len * 2;
 494
 495         for (i = 0, p = block_p; i < sub_count; i++) {
 496             p[0]++;
 497             p += sub_len;
 498         }
 499
 500         while (sub_len > 1) {
 501             sub_len /= 2;
 502             sub_count *= 2;
 503             juggle(wrap_p, block_p, sub_len, sub_count);
 504             wrap_p += sub_len * 2;
 505         }
 506
 507         if (todo_count <= step_subcount)
 508             break;
 509
 510         todo_count -= step_subcount;
 511         block_p += step_subcount << s->level;
 512     }
 513 }
 514
 515 static int decode_block(InterplayACMContext *s)
 516 {
 517     GetBitContext *gb = &s->gb;
 518     int pwr, count, val, i, x, ret;
 519
 520     pwr = get_bits(gb, 4);
 521     val = get_bits(gb, 16);
 522
 523     count = 1 << pwr;
 524
 525     for (i = 0, x = 0; i < count; i++) {
 526         s->midbuf[i] = x;
 527         x += val;
 528     }
 529
 530     for (i = 1, x = -val; i <= count; i++) {
 531         s->midbuf[-i] = x;
 532         x -= (unsigned)val;
 533     }
 534
 535     ret = fill_block(s);
 536     if (ret < 0)
 537         return ret;
 538
 539     juggle_block(s);
 540
 541     return 0;
 542 }
 543
 544 static int decode_frame(AVCodecContext *avctx, void *data,
 545                         int *got_frame_ptr, AVPacket *pkt)
 546 {
 547     InterplayACMContext *s = avctx->priv_data;
 548     GetBitContext *gb = &s->gb;
 549     AVFrame *frame = data;
 550     const uint8_t *buf;
 551     int16_t *samples;
 552     int ret, n, buf_size, input_buf_size;
 553
 554     if (!pkt->size && !s->bitstream_size) {
 555         *got_frame_ptr = 0;
 556         return 0;
 557     }
 558
 559     buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
 560     input_buf_size = buf_size;
 561     if (s->bitstream_index + s->bitstream_size + buf_size > s->max_framesize) {
 562         memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
 563         s->bitstream_index = 0;
 564     }
 565     if (pkt->data)
 566         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
 567     buf                = &s->bitstream[s->bitstream_index];
 568     buf_size          += s->bitstream_size;
 569     s->bitstream_size  = buf_size;
 570     if (buf_size < s->max_framesize && pkt->data) {
 571         *got_frame_ptr = 0;
 572         return input_buf_size;
 573     }
 574
 575     if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
 576         return ret;
 577
 578     frame->nb_samples = s->block_len / avctx->channels;
 579     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 580         return ret;
 581
 582     skip_bits(gb, s->skip);
 583     ret = decode_block(s);
 584     if (ret < 0)
 585         return ret;
 586
 587     samples = (int16_t *)frame->data[0];
 588     for (n = 0; n < frame->nb_samples * avctx->channels; n++) {
 589         int val = s->block[n] >> s->level;
 590         *samples++ = val;
 591     }
 592
 593     *got_frame_ptr = 1;
 594     s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
 595     n = get_bits_count(gb) / 8;
 596
 597     if (n > buf_size && pkt->data) {
 598         s->bitstream_size = 0;
 599         s->bitstream_index = 0;
 600         return AVERROR_INVALIDDATA;
 601     }
 602
 603     if (s->bitstream_size) {
 604         s->bitstream_index += n;
 605         s->bitstream_size  -= n;
 606         return input_buf_size;
 607     }
 608     return n;
 609 }
 610
 611 static av_cold int decode_close(AVCodecContext *avctx)
 612 {
 613     InterplayACMContext *s = avctx->priv_data;
 614
 615     av_freep(&s->block);
 616     av_freep(&s->wrapbuf);
 617     av_freep(&s->ampbuf);
 618     av_freep(&s->bitstream);
 619     s->bitstream_size = 0;
 620
 621     return 0;
 622 }
 623
 624 const AVCodec ff_interplay_acm_decoder = {
 625     .name           = "interplayacm",
 626     .long_name      = NULL_IF_CONFIG_SMALL("Interplay ACM"),
 627     .type           = AVMEDIA_TYPE_AUDIO,
 628     .id             = AV_CODEC_ID_INTERPLAY_ACM,
 629     .init           = decode_init,
 630     .close          = decode_close,
 631     .decode         = decode_frame,
 632     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
 633     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 634     .priv_data_size = sizeof(InterplayACMContext),
 635 };