ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavcodec/wavpack.c

 /*
  * WavPack lossless audio decoder
  * Copyright (c) 2006 Konstantin Shishkov
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
@@ skipping 49 matching lines @@
     WP_ID_HYBRID,
     WP_ID_SHAPING,
     WP_ID_FLOATINFO,
     WP_ID_INT32INFO,
     WP_ID_DATA,
     WP_ID_CORR,
     WP_ID_EXTRABITS,
     WP_ID_CHANINFO
 };
 
+typedef struct SavedContext {
+    int offset;
+    int size;
+    int bits_used;
+    uint32_t crc;
+} SavedContext;
+
 #define MAX_TERMS 16
 
 typedef struct Decorr {
     int delta;
     int value;
     int weightA;
     int weightB;
     int samplesA[8];
     int samplesB[8];
 } Decorr;
@@ skipping 20 matching lines @@
     Decorr decorr[MAX_TERMS];
     int zero, one, zeroes;
     int extra_bits;
     int and, or, shift;
     int post_shift;
     int hybrid, hybrid_bitrate;
     int float_flag;
     int float_shift;
     int float_max_exp;
     WvChannel ch[2];
+    int samples_left;
+    int max_samples;
+    int pos;
+    SavedContext sc, extra_sc;
 } WavpackContext;
 
 // exponent table copied from WavPack source
 static const uint8_t wp_exp2_table [256] = {
     0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
     0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
     0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
     0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
     0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
@@ skipping 312 matching lines @@
             }
         }
     }
 
     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
 
     value.u = (sign << 31) | (exp << 23) | S;
     return value.f;
 }
 
+static void wv_reset_saved_context(WavpackContext *s)
+{
+    s->pos = 0;
+    s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
+}
+
 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 {
     int i, j, count = 0;
     int last, t;
     int A, B, L, L2, R, R2;
-    int pos = 0;
-    uint32_t crc = 0xFFFFFFFF;
-    uint32_t crc_extra_bits = 0xFFFFFFFF;
+    int pos = s->pos;
+    uint32_t crc = s->sc.crc;
+    uint32_t crc_extra_bits = s->extra_sc.crc;
     int16_t *dst16 = dst;
     int32_t *dst32 = dst;
     float   *dstfl = dst;
 
-    s->one = s->zero = s->zeroes = 0;
+    if(s->samples_left == s->samples)
+        s->one = s->zero = s->zeroes = 0;
     do{
         L = wv_get_value(s, gb, 0, &last);
         if(last) break;
         R = wv_get_value(s, gb, 1, &last);
         if(last) break;
         for(i = 0; i < s->terms; i++){
             t = s->decorr[i].value;
             if(t > 0){
                 if(t > 8){
                     if(t & 1){
@@ skipping 67 matching lines @@
             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
         } else if(type == SAMPLE_FMT_S32){
             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
         } else {
             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
         }
         count++;
-    }while(!last && count < s->samples);
+    }while(!last && count < s->max_samples);
 
-    if(crc != s->CRC){
-        av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
-        return -1;
-    }
-    if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
-        av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
-        return -1;
+    s->samples_left -= count;
+    if(!s->samples_left){
+        if(crc != s->CRC){
+            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
+            return -1;
+        }
+        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
+            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
+            return -1;
+        }
+        wv_reset_saved_context(s);
+    }else{
+        s->pos = pos;
+        s->sc.crc = crc;
+        s->sc.bits_used = get_bits_count(&s->gb);
+        if(s->got_extra_bits){
+            s->extra_sc.crc = crc_extra_bits;
+            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
+        }
     }
     return count * 2;
 }
 
 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
 {
     int i, j, count = 0;
     int last, t;
     int A, S, T;
-    int pos = 0;
-    uint32_t crc = 0xFFFFFFFF;
-    uint32_t crc_extra_bits = 0xFFFFFFFF;
+    int pos = s->pos;
+    uint32_t crc = s->sc.crc;
+    uint32_t crc_extra_bits = s->extra_sc.crc;
     int16_t *dst16 = dst;
     int32_t *dst32 = dst;
     float   *dstfl = dst;
 
-    s->one = s->zero = s->zeroes = 0;
+    if(s->samples_left == s->samples)
+        s->one = s->zero = s->zeroes = 0;
     do{
         T = wv_get_value(s, gb, 0, &last);
         S = 0;
         if(last) break;
         for(i = 0; i < s->terms; i++){
             t = s->decorr[i].value;
             if(t > 8){
                 if(t & 1)
                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
                 else
@@ skipping 16 matching lines @@
 
         if(type == SAMPLE_FMT_FLT)
             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
         else if(type == SAMPLE_FMT_S32)
             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
         else
             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
         count++;
     }while(!last && count < s->samples);
 
-    if(crc != s->CRC){
-        av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
-        return -1;
-    }
-    if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
-        av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
-        return -1;
+    s->samples_left -= count;
+    if(!s->samples_left){
+        if(crc != s->CRC){
+            av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
+            return -1;
+        }
+        if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
+            av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
+            return -1;
+        }
+        wv_reset_saved_context(s);
+    }else{
+        s->pos = pos;
+        s->sc.crc = crc;
+        s->sc.bits_used = get_bits_count(&s->gb);
+        if(s->got_extra_bits){
+            s->extra_sc.crc = crc_extra_bits;
+            s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
+        }
     }
     return count;
 }
 
 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
 {
     WavpackContext *s = avctx->priv_data;
 
     s->avctx = avctx;
     s->stereo = (avctx->channels == 2);
     if(avctx->bits_per_coded_sample <= 16)
         avctx->sample_fmt = SAMPLE_FMT_S16;
     else
         avctx->sample_fmt = SAMPLE_FMT_S32;
     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
 
+    wv_reset_saved_context(s);
+
     return 0;
 }
 
 static int wavpack_decode_frame(AVCodecContext *avctx,
                             void *data, int *data_size,
                             AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     WavpackContext *s = avctx->priv_data;
     void *samples = data;
     int samplecount;
     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
     int got_hybrid = 0;
     const uint8_t* buf_end = buf + buf_size;
     int i, j, id, size, ssize, weights, t;
     int bpp;
 
     if (buf_size == 0){
         *data_size = 0;
         return 0;
     }
 
-    memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
-    memset(s->ch, 0, sizeof(s->ch));
-    s->extra_bits = 0;
-    s->and = s->or = s->shift = 0;
-    s->got_extra_bits = 0;
+    if(!s->samples_left){
+        memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
+        memset(s->ch, 0, sizeof(s->ch));
+        s->extra_bits = 0;
+        s->and = s->or = s->shift = 0;
+        s->got_extra_bits = 0;
+    }
 
     s->samples = AV_RL32(buf); buf += 4;
     if(!s->samples){
         *data_size = 0;
         return buf_size;
     }
     s->frame_flags = AV_RL32(buf); buf += 4;
     if(s->frame_flags&0x80){
         bpp = sizeof(float);
         avctx->sample_fmt = SAMPLE_FMT_FLT;
     } else if((s->frame_flags&0x03) <= 1){
         bpp = 2;
         avctx->sample_fmt = SAMPLE_FMT_S16;
     } else {
         bpp = 4;
         avctx->sample_fmt = SAMPLE_FMT_S32;
     }
     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
     s->joint = s->frame_flags & WV_JOINT_STEREO;
     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
     s->CRC = AV_RL32(buf); buf += 4;
 
-    /* should not happen but who knows */
-    if(s->samples * bpp * avctx->channels > *data_size){
-        av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n");
-        return -1;
+    s->max_samples = *data_size / (bpp * avctx->channels);
+    s->max_samples = FFMIN(s->max_samples, s->samples);
+    if(s->samples_left > 0){
+        s->max_samples = FFMIN(s->max_samples, s->samples_left);
+        buf = buf_end;
     }
 
     // parse metadata blocks
     while(buf < buf_end){
         id = *buf++;
         size = *buf++;
         if(id & WP_IDF_LONG) {
             size |= (*buf++) << 8;
             size |= (*buf++) << 16;
         }
@@ skipping 147 matching lines @@
                 buf += ssize;
                 continue;
             }
             s->float_flag = buf[0];
             s->float_shift = buf[1];
             s->float_max_exp = buf[2];
             buf += 4;
             got_float = 1;
             break;
         case WP_ID_DATA:
+            s->sc.offset = buf - avpkt->data;
+            s->sc.size   = size * 8;
             init_get_bits(&s->gb, buf, size * 8);
             s->data_size = size * 8;
             buf += size;
             got_bs = 1;
             break;
         case WP_ID_EXTRABITS:
             if(size <= 4){
                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
                 buf += size;
                 continue;
             }
+            s->extra_sc.offset = buf - avpkt->data;
+            s->extra_sc.size   = size * 8;
             init_get_bits(&s->gb_extra_bits, buf, size * 8);
             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
             buf += size;
             s->got_extra_bits = 1;
             break;
         default:
             buf += size;
         }
         if(id & WP_IDF_ODD) buf++;
     }
-    if(!got_terms){
-        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
-        return -1;
-    }
-    if(!got_weights){
-        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
-        return -1;
-    }
-    if(!got_samples){
-        av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
-        return -1;
-    }
-    if(!got_entropy){
-        av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
-        return -1;
-    }
-    if(s->hybrid && !got_hybrid){
-        av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
-        return -1;
-    }
-    if(!got_bs){
-        av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
-        return -1;
-    }
-    if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
-        av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
-        return -1;
-    }
-    if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
-        const int size = get_bits_left(&s->gb_extra_bits);
-        const int wanted = s->samples * s->extra_bits << s->stereo_in;
-        if(size < wanted){
-            av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
-            s->got_extra_bits = 0;
+    if(!s->samples_left){
+        if(!got_terms){
+            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
+            return -1;
+        }
+        if(!got_weights){
+            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
+            return -1;
+        }
+        if(!got_samples){
+            av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
+            return -1;
+        }
+        if(!got_entropy){
+            av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
+            return -1;
+        }
+        if(s->hybrid && !got_hybrid){
+            av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
+            return -1;
+        }
+        if(!got_bs){
+            av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
+            return -1;
+        }
+        if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
+            av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
+            return -1;
+        }
+        if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
+            const int size = get_bits_left(&s->gb_extra_bits);
+            const int wanted = s->samples * s->extra_bits << s->stereo_in;
+            if(size < wanted){
+                av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
+                s->got_extra_bits = 0;
+            }
+        }
+        s->samples_left = s->samples;
+    }else{
+        init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
+        skip_bits_long(&s->gb, s->sc.bits_used);
+        if(s->got_extra_bits){
+            init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
+                          s->extra_sc.size);
+            skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
         }
     }
 
     if(s->stereo_in){
         if(avctx->sample_fmt == SAMPLE_FMT_S16)
             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
         else if(avctx->sample_fmt == SAMPLE_FMT_S32)
             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
         else
             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
@@ skipping 30 matching lines @@
             int cnt = samplecount;
             while(cnt--){
                 *--dst = *--src;
                 *--dst = *src;
             }
             samplecount *= 2;
         }
     }
     *data_size = samplecount * bpp;
 
-    return buf_size;
+    return s->samples_left > 0 ? 0 : buf_size;
 }
 
 AVCodec wavpack_decoder = {
     "wavpack",
     CODEC_TYPE_AUDIO,
     CODEC_ID_WAVPACK,
     sizeof(WavpackContext),
     wavpack_decode_init,
     NULL,
     NULL,
     wavpack_decode_frame,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
 };