Unified · Split
| @@ -30,6 +30,8 @@ · 29 unmodified lines | |||
| 30 | #include "unary.h" | 30 | #include "unary.h" |
| 31 | 31 | ||
| 32 | typedef struct WavArcContext { | 32 | typedef struct WavArcContext { |
| 33 | AVClass *av_class; | ||
| 34 | |||
| 33 | GetBitContext gb; | 35 | GetBitContext gb; |
| 34 | 36 | ||
| 35 | int shift; | 37 | int shift; |
| @@ -47,6 +49,16 @@ typedef struct WavArcContext { · 11 unmodified lines | |||
| 47 | int pred[2][70]; | 49 | int pred[2][70]; |
| 48 | int filter[2][70]; | 50 | int filter[2][70]; |
| 49 | int samples[2][640]; | 51 | int samples[2][640]; |
| 52 | uint8_t model[256]; | ||
| 53 | uint16_t freqs[257]; | ||
| 54 | uint16_t ac_value; | ||
| 55 | uint16_t ac_low; | ||
| 56 | uint16_t ac_high; | ||
| 57 | uint16_t range_high; | ||
| 58 | uint16_t range_low; | ||
| 59 | uint16_t freq_range; | ||
| 60 | int ac_pred[70]; | ||
| 61 | int ac_out[570]; | ||
| 50 | } WavArcContext; | 62 | } WavArcContext; |
| 51 | 63 | ||
| 52 | static av_cold int wavarc_init(AVCodecContext *avctx) | 64 | static av_cold int wavarc_init(AVCodecContext *avctx) |
| @@ -90,6 +102,7 @@ static av_cold int wavarc_init(AVCodecContext *avctx) · 37 unmodified lines | |||
| 90 | case MKTAG('2','S','L','P'): | 102 | case MKTAG('2','S','L','P'): |
| 91 | case MKTAG('3','N','L','P'): | 103 | case MKTAG('3','N','L','P'): |
| 92 | case MKTAG('4','A','L','P'): | 104 | case MKTAG('4','A','L','P'): |
| 105 | case MKTAG('5','E','L','P'): | ||
| 93 | s->nb_samples = 570; | 106 | s->nb_samples = 570; |
| 94 | s->offset = 70; | 107 | s->offset = 70; |
| 95 | break; | 108 | break; |
| @@ -343,7 +356,7 @@ static int decode_2slp(AVCodecContext *avctx, · 247 unmodified lines | |||
| 343 | break; | 356 | break; |
| 344 | case 0: | 357 | case 0: |
| 345 | order = get_urice(gb, 2); | 358 | order = get_urice(gb, 2); |
| 346 | if ((unsigned)order >= FF_ARRAY_ELEMS(s->filter[ch])) | 359 | if ((unsigned)order > FF_ARRAY_ELEMS(s->filter[ch])) |
| 347 | return AVERROR_INVALIDDATA; | 360 | return AVERROR_INVALIDDATA; |
| 348 | for (int o = 0; o < order; o++) | 361 | for (int o = 0; o < order; o++) |
| 349 | s->filter[ch][o] = get_srice(gb, 2); | 362 | s->filter[ch][o] = get_srice(gb, 2); |
| @@ -378,6 +391,337 @@ static int decode_2slp(AVCodecContext *avctx, · 28 unmodified lines | |||
| 378 | return 0; | 391 | return 0; |
| 379 | } | 392 | } |
| 380 | 393 | ||
| 394 | static int ac_init(AVCodecContext *avctx, | ||
| 395 | WavArcContext *s, GetBitContext *gb) | ||
| 396 | { | ||
| 397 | s->ac_low = 0; | ||
| 398 | s->ac_high = 0xffffu; | ||
| 399 | s->ac_value = get_bits(gb, 16); | ||
| 400 | |||
| 401 | s->freq_range = s->freqs[256]; | ||
| 402 | if (!s->freq_range) | ||
| 403 | return AVERROR_INVALIDDATA; | ||
| 404 | return 0; | ||
| 405 | } | ||
| 406 | |||
| 407 | static unsigned ac_get_prob(WavArcContext *s) | ||
| 408 | { | ||
| 409 | return ((s->freq_range - 1) + ((unsigned)s->ac_value - (unsigned)s->ac_low) * | ||
| 410 | (unsigned)s->freq_range) / (((unsigned)s->ac_high - (unsigned)s->ac_low) + 1) & 0xffffu; | ||
| 411 | } | ||
| 412 | |||
| 413 | static unsigned ac_map_symbol(WavArcContext *s, unsigned prob) | ||
| 414 | { | ||
| 415 | int idx = 255; | ||
| 416 | |||
| 417 | while (prob < s->freqs[idx]) | ||
| 418 | idx--; | ||
| 419 | |||
| 420 | s->range_high = s->freqs[idx + 1]; | ||
| 421 | s->range_low = s->freqs[idx]; | ||
| 422 | |||
| 423 | return idx; | ||
| 424 | } | ||
| 425 | |||
| 426 | static int ac_normalize(AVCodecContext *avctx, WavArcContext *s, GetBitContext *gb) | ||
| 427 | { | ||
| 428 | int range; | ||
| 429 | |||
| 430 | range = (unsigned)s->ac_high - (unsigned)s->ac_low + 1; | ||
| 431 | s->ac_high = (int16_t)((range * (unsigned)s->range_high) / (unsigned)s->freq_range) + -1 + s->ac_low; | ||
| 432 | s->ac_low += (int16_t)((range * (unsigned)s->range_low) / (unsigned)s->freq_range); | ||
| 433 | |||
| 434 | for (;;) { | ||
| 435 | if ((s->ac_high & 0x8000) != (s->ac_low & 0x8000)) { | ||
| 436 | if ((s->ac_low & 0x4000) == 0 || (s->ac_high & 0x4000) != 0) | ||
| 437 | return 0; | ||
| 438 | s->ac_value ^= 0x4000; | ||
| 439 | s->ac_low &= 0x3fff; | ||
| 440 | s->ac_high |= 0x4000; | ||
| 441 | } | ||
| 442 | |||
| 443 | s->ac_low = s->ac_low << 1; | ||
| 444 | s->ac_high = s->ac_high * 2 + 1; | ||
| 445 | if (s->ac_high < s->ac_low) { | ||
| 446 | av_log(avctx, AV_LOG_ERROR, "invalid state\n"); | ||
| 447 | return AVERROR_INVALIDDATA; | ||
| 448 | } | ||
| 449 | |||
| 450 | if (get_bits_left(gb) <= 0) { | ||
| 451 | av_log(avctx, AV_LOG_ERROR, "overread in arithmetic coder\n"); | ||
| 452 | return AVERROR_INVALIDDATA; | ||
| 453 | } | ||
| 454 | |||
| 455 | s->ac_value = s->ac_value * 2 + get_bits1(gb); | ||
| 456 | } | ||
| 457 | } | ||
| 458 | |||
| 459 | static void ac_init_model(WavArcContext *s) | ||
| 460 | { | ||
| 461 | memset(s->freqs, 0, sizeof(s->freqs)); | ||
| 462 | |||
| 463 | for (int n = 0; n < 256; n++) | ||
| 464 | s->freqs[n+1] = s->model[n] + s->freqs[n]; | ||
| 465 | } | ||
| 466 | |||
| 467 | static int ac_read_model(AVCodecContext *avctx, | ||
| 468 | WavArcContext *s, | ||
| 469 | GetBitContext *gb) | ||
| 470 | { | ||
| 471 | unsigned start, end; | ||
| 472 | |||
| 473 | memset(s->model, 0, sizeof(s->model)); | ||
| 474 | |||
| 475 | start = get_bits(gb, 8); | ||
| 476 | end = get_bits(gb, 8); | ||
| 477 | |||
| 478 | for (;;) { | ||
| 479 | while (start <= end) | ||
| 480 | s->model[start++] = get_bits(gb, 8); | ||
| 481 | |||
| 482 | if (get_bits_left(gb) < 8) | ||
| 483 | return AVERROR_INVALIDDATA; | ||
| 484 | |||
| 485 | if (get_bits_left(gb) < 8) | ||
| 486 | return AVERROR_INVALIDDATA; | ||
| 487 | |||
| 488 | start = get_bits(gb, 8); | ||
| 489 | if (!start) | ||
| 490 | break; | ||
| 491 | |||
| 492 | end = get_bits(gb, 8); | ||
| 493 | } | ||
| 494 | |||
| 495 | ac_init_model(s); | ||
| 496 | |||
| 497 | return 0; | ||
| 498 | } | ||
| 499 | |||
| 500 | static int decode_5elp(AVCodecContext *avctx, | ||
| 501 | WavArcContext *s, GetBitContext *gb) | ||
| 502 | { | ||
| 503 | int ch, finished, fill, correlated, order = 0; | ||
| 504 | |||
| 505 | ch = 0; | ||
| 506 | finished = 0; | ||
| 507 | while (!finished) { | ||
| 508 | int *samples = s->samples[ch]; | ||
| 509 | int *ac_pred = s->ac_pred; | ||
| 510 | int *ac_out = s->ac_out; | ||
| 511 | int k, block_type; | ||
| 512 | |||
| 513 | if (get_bits_left(gb) <= 0) | ||
| 514 | return AVERROR_INVALIDDATA; | ||
| 515 | |||
| 516 | memset(s->ac_out, 0, sizeof(s->ac_out)); | ||
| 517 | |||
| 518 | block_type = get_urice(gb, 1); | ||
| 519 | av_log(avctx, AV_LOG_DEBUG, "block_type : %d\n", block_type); | ||
| 520 | |||
| 521 | if (block_type >= 0 && block_type <= 7) { | ||
| 522 | k = 1 + (avctx->sample_fmt == AV_SAMPLE_FMT_S16P); | ||
| 523 | k = get_urice(gb, k) + 1; | ||
| 524 | } | ||
| 525 | |||
| 526 | if (block_type <= 2 || block_type == 6 || block_type == 13 || | ||
| 527 | block_type == 14 || block_type == 15 || block_type == 19) { | ||
| 528 | order = get_urice(gb, 2); | ||
| 529 | if ((unsigned)order > FF_ARRAY_ELEMS(s->filter[ch])) | ||
| 530 | return AVERROR_INVALIDDATA; | ||
| 531 | for (int o = 0; o < order; o++) | ||
| 532 | s->filter[ch][o] = get_srice(gb, 2); | ||
| 533 | } | ||
| 534 | |||
| 535 | if (block_type >= 0 && block_type <= 7) { | ||
| 536 | for (int n = 0; n < s->nb_samples; n++) | ||
| 537 | samples[n + 70] = get_srice(gb, k); | ||
| 538 | } else { | ||
| 539 | for (int n = 0; n < s->nb_samples; n++) | ||
| 540 | samples[n + 70] = 0; | ||
| 541 | } | ||
| 542 | |||
| 543 | if (block_type >= 13 && block_type <= 20) { | ||
| 544 | const int ac_size = get_bits(gb, 12); | ||
| 545 | const int ac_pos = get_bits_count(gb); | ||
| 546 | GetBitContext ac_gb = *gb; | ||
| 547 | int ret; | ||
| 548 | |||
| 549 | skip_bits_long(gb, ac_size); | ||
| 550 | ret = ac_read_model(avctx, s, &ac_gb); | ||
| 551 | if (ret < 0) { | ||
| 552 | av_log(avctx, AV_LOG_ERROR, "bad arithmetic model\n"); | ||
| 553 | return ret; | ||
| 554 | } | ||
| 555 | |||
| 556 | ret = ac_init(avctx, s, &ac_gb); | ||
| 557 | if (ret < 0) { | ||
| 558 | av_log(avctx, AV_LOG_ERROR, "cannot init arithmetic decoder\n"); | ||
| 559 | return ret; | ||
| 560 | } | ||
| 561 | |||
| 562 | for (int n = 0; n < s->nb_samples; n++) { | ||
| 563 | unsigned prob = ac_get_prob(s); | ||
| 564 | prob = ac_map_symbol(s, prob); | ||
| 565 | ac_out[n] = prob - 0x80; | ||
| 566 | if ((ret = ac_normalize(avctx, s, &ac_gb)) < 0) | ||
| 567 | return ret; | ||
| 568 | } | ||
| 569 | |||
| 570 | if (get_bits_count(&ac_gb) != ac_pos + ac_size) { | ||
| 571 | av_log(avctx, AV_LOG_DEBUG, "over/under-read in arithmetic coder: %d\n", | ||
| 572 | ac_pos + ac_size - get_bits_count(&ac_gb)); | ||
| 573 | } | ||
| 574 | } | ||
| 575 | |||
| 576 | switch (block_type) { | ||
| 577 | case 12: | ||
| 578 | s->eof = 1; | ||
| 579 | return AVERROR_EOF; | ||
| 580 | case 11: | ||
| 581 | s->nb_samples = get_urice(gb, 8); | ||
| 582 | if (s->nb_samples > 570) { | ||
| 583 | s->nb_samples = 570; | ||
| 584 | return AVERROR_INVALIDDATA; | ||
| 585 | } | ||
| 586 | continue; | ||
| 587 | case 10: | ||
| 588 | s->shift = get_urice(gb, 2); | ||
| 589 | continue; | ||
| 590 | case 9: | ||
| 591 | if (avctx->sample_fmt == AV_SAMPLE_FMT_U8P) { | ||
| 592 | fill = (int8_t)get_bits(gb, 8); | ||
| 593 | fill -= 0x80; | ||
| 594 | } else { | ||
| 595 | fill = (int16_t)get_bits(gb, 16); | ||
| 596 | fill -= 0x8000; | ||
| 597 | } | ||
| 598 | |||
| 599 | for (int n = 0; n < s->nb_samples; n++) | ||
| 600 | samples[n + 70] = fill; | ||
| 601 | finished = 1; | ||
| 602 | break; | ||
| 603 | case 8: | ||
| 604 | for (int n = 0; n < s->nb_samples; n++) | ||
| 605 | samples[n + 70] = 0; | ||
| 606 | finished = 1; | ||
| 607 | break; | ||
| 608 | case 20: | ||
| 609 | case 7: | ||
| 610 | for (int n = 0; n < s->nb_samples; n++) | ||
| 611 | samples[n + 70] = ac_out[n] + samples[n + 69] * 3 - samples[n + 68] * 3 + samples[n + 67]; | ||
| 612 | finished = 1; | ||
| 613 | break; | ||
| 614 | case 19: | ||
| 615 | case 6: | ||
| 616 | for (int n = 0; n < s->nb_samples; n++) { | ||
| 617 | int sum = 15; | ||
| 618 | |||
| 619 | for (int o = 0; o < order; o++) | ||
| 620 | sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1]; | ||
| 621 | |||
| 622 | samples[n + 70] += ac_out[n] + (sum >> 4); | ||
| 623 | } | ||
| 624 | finished = 1; | ||
| 625 | break; | ||
| 626 | case 18: | ||
| 627 | case 5: | ||
| 628 | for (int n = 0; n < s->nb_samples; n++) | ||
| 629 | samples[n + 70] = ac_out[n] + samples[n + 69] * 2 - samples[n + 68]; | ||
| 630 | finished = 1; | ||
| 631 | break; | ||
| 632 | case 17: | ||
| 633 | case 4: | ||
| 634 | for (int n = 0; n < s->nb_samples; n++) | ||
| 635 | samples[n + 70] = ac_out[n]; | ||
| 636 | finished = 1; | ||
| 637 | break; | ||
| 638 | case 16: | ||
| 639 | case 3: | ||
| 640 | for (int n = 0; n < s->nb_samples; n++) | ||
| 641 | samples[n + 70] = ac_out[n] + samples[n + 69]; | ||
| 642 | finished = 1; | ||
| 643 | break; | ||
| 644 | case 15: | ||
| 645 | case 2: | ||
| 646 | for (int n = 0; n < 70; n++) { | ||
| 647 | ac_pred[n] = samples[n]; | ||
| 648 | samples[n] = 0; | ||
| 649 | } | ||
| 650 | |||
| 651 | for (int n = 0; n < s->nb_samples; n++) { | ||
| 652 | int sum = 15; | ||
| 653 | |||
| 654 | for (int o = 0; o < order; o++) | ||
| 655 | sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1]; | ||
| 656 | |||
| 657 | samples[n + 70] += ac_out[n] + (sum >> 4); | ||
| 658 | } | ||
| 659 | |||
| 660 | for (int n = 0; n < 70; n++) | ||
| 661 | samples[n] = ac_pred[n]; | ||
| 662 | |||
| 663 | for (int n = 0; n < s->nb_samples; n++) | ||
| 664 | samples[n + 70] += samples[n + 69] * 2 - samples[n + 68]; | ||
| 665 | |||
| 666 | finished = 1; | ||
| 667 | break; | ||
| 668 | case 14: | ||
| 669 | case 1: | ||
| 670 | for (int n = 0; n < 70; n++) { | ||
| 671 | ac_pred[n] = samples[n]; | ||
| 672 | samples[n] = 0; | ||
| 673 | } | ||
| 674 | |||
| 675 | for (int n = 0; n < s->nb_samples; n++) { | ||
| 676 | int sum = 15; | ||
| 677 | |||
| 678 | for (int o = 0; o < order; o++) | ||
| 679 | sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1]; | ||
| 680 | |||
| 681 | samples[n + 70] += ac_out[n] + (sum >> 4); | ||
| 682 | } | ||
| 683 | |||
| 684 | for (int n = 0; n < 70; n++) | ||
| 685 | samples[n] = ac_pred[n]; | ||
| 686 | |||
| 687 | for (int n = 0; n < s->nb_samples; n++) | ||
| 688 | samples[n + 70] += samples[n + 69]; | ||
| 689 | |||
| 690 | finished = 1; | ||
| 691 | break; | ||
| 692 | case 13: | ||
| 693 | case 0: | ||
| 694 | for (int n = 0; n < s->nb_samples; n++) { | ||
| 695 | int sum = 15; | ||
| 696 | |||
| 697 | for (int o = 0; o < order; o++) | ||
| 698 | sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1]; | ||
| 699 | |||
| 700 | samples[n + 70] += ac_out[n] + (sum >> 4); | ||
| 701 | } | ||
| 702 | finished = 1; | ||
| 703 | break; | ||
| 704 | default: | ||
| 705 | return AVERROR_INVALIDDATA; | ||
| 706 | } | ||
| 707 | |||
| 708 | if (finished == 1 && avctx->ch_layout.nb_channels == 2) { | ||
| 709 | if (ch == 0) | ||
| 710 | correlated = get_bits1(gb); | ||
| 711 | finished = ch != 0; | ||
| 712 | do_stereo(s, ch, correlated, 70); | ||
| 713 | ch = 1; | ||
| 714 | } | ||
| 715 | } | ||
| 716 | |||
| 717 | if (avctx->ch_layout.nb_channels == 1) { | ||
| 718 | for (int n = 0; n < 70; n++) | ||
| 719 | s->samples[0][n] = s->samples[0][s->nb_samples + n]; | ||
| 720 | } | ||
| 721 | |||
| 722 | return 0; | ||
| 723 | } | ||
| 724 | |||
| 381 | static int wavarc_decode(AVCodecContext *avctx, AVFrame *frame, | 725 | static int wavarc_decode(AVCodecContext *avctx, AVFrame *frame, |
| 382 | int *got_frame_ptr, AVPacket *pkt) | 726 | int *got_frame_ptr, AVPacket *pkt) |
| 383 | { | 727 | { |
| @@ -424,6 +768,9 @@ static int wavarc_decode(AVCodecContext *avctx, AVFrame *frame, · 40 unmodified lines | |||
| 424 | case MKTAG('4','A','L','P'): | 768 | case MKTAG('4','A','L','P'): |
| 425 | ret = decode_2slp(avctx, s, gb); | 769 | ret = decode_2slp(avctx, s, gb); |
| 426 | break; | 770 | break; |
| 771 | case MKTAG('5','E','L','P'): | ||
| 772 | ret = decode_5elp(avctx, s, gb); | ||
| 773 | break; | ||
| 427 | default: | 774 | default: |
| 428 | ret = AVERROR_INVALIDDATA; | 775 | ret = AVERROR_INVALIDDATA; |
| 429 | } | 776 | } |