Mercurial > libavcodec.hg

comparison wavpack.c @ 11211:dfeaae916502 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to hold, decode it in several iterations outputting as many samples as possible.
author kostya
date Fri, 19 Feb 2010 14:05:41 +0000
parents 95f3daa991a2
children 4a0b77af9d9c
comparison
equal deleted inserted replaced
11210:0c0c6c954942 11211:dfeaae916502
65 WP_ID_CORR, 65 WP_ID_CORR,
66 WP_ID_EXTRABITS, 66 WP_ID_EXTRABITS,
67 WP_ID_CHANINFO 67 WP_ID_CHANINFO
68 }; 68 };
69 69
70 typedef struct SavedContext {
71 int offset;
72 int size;
73 int bits_used;
74 uint32_t crc;
75 } SavedContext;
76
70 #define MAX_TERMS 16 77 #define MAX_TERMS 16
71 78
72 typedef struct Decorr { 79 typedef struct Decorr {
73 int delta; 80 int delta;
74 int value; 81 int value;
105 int hybrid, hybrid_bitrate; 112 int hybrid, hybrid_bitrate;
106 int float_flag; 113 int float_flag;
107 int float_shift; 114 int float_shift;
108 int float_max_exp; 115 int float_max_exp;
109 WvChannel ch[2]; 116 WvChannel ch[2];
117 int samples_left;
118 int max_samples;
119 int pos;
120 SavedContext sc, extra_sc;
110 } WavpackContext; 121 } WavpackContext;
111 122
112 // exponent table copied from WavPack source 123 // exponent table copied from WavPack source
113 static const uint8_t wp_exp2_table [256] = { 124 static const uint8_t wp_exp2_table [256] = {
114 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 125 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
437 448
438 value.u = (sign << 31) | (exp << 23) | S; 449 value.u = (sign << 31) | (exp << 23) | S;
439 return value.f; 450 return value.f;
440 } 451 }
441 452
453 static void wv_reset_saved_context(WavpackContext *s)
454 {
455 s->pos = 0;
456 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
457 }
458
442 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 459 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
443 { 460 {
444 int i, j, count = 0; 461 int i, j, count = 0;
445 int last, t; 462 int last, t;
446 int A, B, L, L2, R, R2; 463 int A, B, L, L2, R, R2;
447 int pos = 0; 464 int pos = s->pos;
448 uint32_t crc = 0xFFFFFFFF; 465 uint32_t crc = s->sc.crc;
449 uint32_t crc_extra_bits = 0xFFFFFFFF; 466 uint32_t crc_extra_bits = s->extra_sc.crc;
450 int16_t *dst16 = dst; 467 int16_t *dst16 = dst;
451 int32_t *dst32 = dst; 468 int32_t *dst32 = dst;
452 float *dstfl = dst; 469 float *dstfl = dst;
453 470
471 if(s->samples_left == s->samples)
454 s->one = s->zero = s->zeroes = 0; 472 s->one = s->zero = s->zeroes = 0;
455 do{ 473 do{
456 L = wv_get_value(s, gb, 0, &last); 474 L = wv_get_value(s, gb, 0, &last);
457 if(last) break; 475 if(last) break;
458 R = wv_get_value(s, gb, 1, &last); 476 R = wv_get_value(s, gb, 1, &last);
537 } else { 555 } else {
538 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L); 556 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
539 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R); 557 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
540 } 558 }
541 count++; 559 count++;
542 }while(!last && count < s->samples); 560 }while(!last && count < s->max_samples);
543 561
562 s->samples_left -= count;
563 if(!s->samples_left){
544 if(crc != s->CRC){ 564 if(crc != s->CRC){
545 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 565 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
546 return -1; 566 return -1;
547 } 567 }
548 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){ 568 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
549 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n"); 569 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
550 return -1; 570 return -1;
551 } 571 }
572 wv_reset_saved_context(s);
573 }else{
574 s->pos = pos;
575 s->sc.crc = crc;
576 s->sc.bits_used = get_bits_count(&s->gb);
577 if(s->got_extra_bits){
578 s->extra_sc.crc = crc_extra_bits;
579 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
580 }
581 }
552 return count * 2; 582 return count * 2;
553 } 583 }
554 584
555 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 585 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
556 { 586 {
557 int i, j, count = 0; 587 int i, j, count = 0;
558 int last, t; 588 int last, t;
559 int A, S, T; 589 int A, S, T;
560 int pos = 0; 590 int pos = s->pos;
561 uint32_t crc = 0xFFFFFFFF; 591 uint32_t crc = s->sc.crc;
562 uint32_t crc_extra_bits = 0xFFFFFFFF; 592 uint32_t crc_extra_bits = s->extra_sc.crc;
563 int16_t *dst16 = dst; 593 int16_t *dst16 = dst;
564 int32_t *dst32 = dst; 594 int32_t *dst32 = dst;
565 float *dstfl = dst; 595 float *dstfl = dst;
566 596
597 if(s->samples_left == s->samples)
567 s->one = s->zero = s->zeroes = 0; 598 s->one = s->zero = s->zeroes = 0;
568 do{ 599 do{
569 T = wv_get_value(s, gb, 0, &last); 600 T = wv_get_value(s, gb, 0, &last);
570 S = 0; 601 S = 0;
571 if(last) break; 602 if(last) break;
599 else 630 else
600 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S); 631 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
601 count++; 632 count++;
602 }while(!last && count < s->samples); 633 }while(!last && count < s->samples);
603 634
635 s->samples_left -= count;
636 if(!s->samples_left){
604 if(crc != s->CRC){ 637 if(crc != s->CRC){
605 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 638 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
606 return -1; 639 return -1;
607 } 640 }
608 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){ 641 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
609 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n"); 642 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
610 return -1; 643 return -1;
644 }
645 wv_reset_saved_context(s);
646 }else{
647 s->pos = pos;
648 s->sc.crc = crc;
649 s->sc.bits_used = get_bits_count(&s->gb);
650 if(s->got_extra_bits){
651 s->extra_sc.crc = crc_extra_bits;
652 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
653 }
611 } 654 }
612 return count; 655 return count;
613 } 656 }
614 657
615 static av_cold int wavpack_decode_init(AVCodecContext *avctx) 658 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
621 if(avctx->bits_per_coded_sample <= 16) 664 if(avctx->bits_per_coded_sample <= 16)
622 avctx->sample_fmt = SAMPLE_FMT_S16; 665 avctx->sample_fmt = SAMPLE_FMT_S16;
623 else 666 else
624 avctx->sample_fmt = SAMPLE_FMT_S32; 667 avctx->sample_fmt = SAMPLE_FMT_S32;
625 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; 668 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
669
670 wv_reset_saved_context(s);
626 671
627 return 0; 672 return 0;
628 } 673 }
629 674
630 static int wavpack_decode_frame(AVCodecContext *avctx, 675 static int wavpack_decode_frame(AVCodecContext *avctx,
645 if (buf_size == 0){ 690 if (buf_size == 0){
646 *data_size = 0; 691 *data_size = 0;
647 return 0; 692 return 0;
648 } 693 }
649 694
695 if(!s->samples_left){
650 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr)); 696 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
651 memset(s->ch, 0, sizeof(s->ch)); 697 memset(s->ch, 0, sizeof(s->ch));
652 s->extra_bits = 0; 698 s->extra_bits = 0;
653 s->and = s->or = s->shift = 0; 699 s->and = s->or = s->shift = 0;
654 s->got_extra_bits = 0; 700 s->got_extra_bits = 0;
701 }
655 702
656 s->samples = AV_RL32(buf); buf += 4; 703 s->samples = AV_RL32(buf); buf += 4;
657 if(!s->samples){ 704 if(!s->samples){
658 *data_size = 0; 705 *data_size = 0;
659 return buf_size; 706 return buf_size;
674 s->hybrid = s->frame_flags & WV_HYBRID_MODE; 721 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
675 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE; 722 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
676 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f); 723 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
677 s->CRC = AV_RL32(buf); buf += 4; 724 s->CRC = AV_RL32(buf); buf += 4;
678 725
679 /* should not happen but who knows */ 726 s->max_samples = *data_size / (bpp * avctx->channels);
680 if(s->samples * bpp * avctx->channels > *data_size){ 727 s->max_samples = FFMIN(s->max_samples, s->samples);
681 av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n"); 728 if(s->samples_left > 0){
682 return -1; 729 s->max_samples = FFMIN(s->max_samples, s->samples_left);
730 buf = buf_end;
683 } 731 }
684 732
685 // parse metadata blocks 733 // parse metadata blocks
686 while(buf < buf_end){ 734 while(buf < buf_end){
687 id = *buf++; 735 id = *buf++;
845 s->float_max_exp = buf[2]; 893 s->float_max_exp = buf[2];
846 buf += 4; 894 buf += 4;
847 got_float = 1; 895 got_float = 1;
848 break; 896 break;
849 case WP_ID_DATA: 897 case WP_ID_DATA:
898 s->sc.offset = buf - avpkt->data;
899 s->sc.size = size * 8;
850 init_get_bits(&s->gb, buf, size * 8); 900 init_get_bits(&s->gb, buf, size * 8);
851 s->data_size = size * 8; 901 s->data_size = size * 8;
852 buf += size; 902 buf += size;
853 got_bs = 1; 903 got_bs = 1;
854 break; 904 break;
856 if(size <= 4){ 906 if(size <= 4){
857 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size); 907 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
858 buf += size; 908 buf += size;
859 continue; 909 continue;
860 } 910 }
911 s->extra_sc.offset = buf - avpkt->data;
912 s->extra_sc.size = size * 8;
861 init_get_bits(&s->gb_extra_bits, buf, size * 8); 913 init_get_bits(&s->gb_extra_bits, buf, size * 8);
862 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32); 914 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
863 buf += size; 915 buf += size;
864 s->got_extra_bits = 1; 916 s->got_extra_bits = 1;
865 break; 917 break;
866 default: 918 default:
867 buf += size; 919 buf += size;
868 } 920 }
869 if(id & WP_IDF_ODD) buf++; 921 if(id & WP_IDF_ODD) buf++;
870 } 922 }
923 if(!s->samples_left){
871 if(!got_terms){ 924 if(!got_terms){
872 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n"); 925 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
873 return -1; 926 return -1;
874 } 927 }
875 if(!got_weights){ 928 if(!got_weights){
900 const int size = get_bits_left(&s->gb_extra_bits); 953 const int size = get_bits_left(&s->gb_extra_bits);
901 const int wanted = s->samples * s->extra_bits << s->stereo_in; 954 const int wanted = s->samples * s->extra_bits << s->stereo_in;
902 if(size < wanted){ 955 if(size < wanted){
903 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n"); 956 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
904 s->got_extra_bits = 0; 957 s->got_extra_bits = 0;
958 }
959 }
960 s->samples_left = s->samples;
961 }else{
962 init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
963 skip_bits_long(&s->gb, s->sc.bits_used);
964 if(s->got_extra_bits){
965 init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
966 s->extra_sc.size);
967 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
905 } 968 }
906 } 969 }
907 970
908 if(s->stereo_in){ 971 if(s->stereo_in){
909 if(avctx->sample_fmt == SAMPLE_FMT_S16) 972 if(avctx->sample_fmt == SAMPLE_FMT_S16)
950 samplecount *= 2; 1013 samplecount *= 2;
951 } 1014 }
952 } 1015 }
953 *data_size = samplecount * bpp; 1016 *data_size = samplecount * bpp;
954 1017
955 return buf_size; 1018 return s->samples_left > 0 ? 0 : buf_size;
956 } 1019 }
957 1020
958 AVCodec wavpack_decoder = { 1021 AVCodec wavpack_decoder = {
959 "wavpack", 1022 "wavpack",
960 CODEC_TYPE_AUDIO, 1023 CODEC_TYPE_AUDIO,