Merge commit '5074f454'

* commit '5074f454':
  wavpack demuxer: export full wavpack blocks.

Conflicts:
	libavformat/wv.c
Merged-by: Michael Niedermayer <michaelni@gmx.at>

libavcodec/wavpack.c

@@ -33,6 +33,8 @@
  * WavPack lossless audio decoder
  */
 
+#define WV_HEADER_SIZE    32
+
 #define WV_MONO           0x00000004
 #define WV_JOINT_STEREO   0x00000010
 #define WV_FALSE_STEREO   0x40000000
@@ -1156,7 +1158,7 @@ static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
     AVFrame *frame     = data;
     int frame_size, ret, frame_flags;
 
-    if (avpkt->size < 12 + s->multichannel * 4)
+    if (avpkt->size <= WV_HEADER_SIZE)
         return AVERROR_INVALIDDATA;
 
     s->block     = 0;
@@ -1168,13 +1170,8 @@ static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
         buf        += 4;
         frame_flags = AV_RL32(buf);
     } else {
-        if (s->multichannel) {
-            s->samples  = AV_RL32(buf + 4);
-            frame_flags = AV_RL32(buf + 8);
-        } else {
-            s->samples  = AV_RL32(buf);
-            frame_flags = AV_RL32(buf + 4);
-        }
+        s->samples  = AV_RL32(buf + 20);
+        frame_flags = AV_RL32(buf + 24);
     }
     if (s->samples <= 0 || s->samples > WV_MAX_SAMPLES) {
         av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
@@ -1198,19 +1195,17 @@ static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
     frame->nb_samples = s->samples;
 
     while (buf_size > 0) {
-        if (!s->multichannel) {
-            frame_size = buf_size;
-        } else {
         if (!s->mkv_mode) {
-                frame_size = AV_RL32(buf) - 12;
-                buf       += 4;
-                buf_size  -= 4;
+            if (buf_size <= WV_HEADER_SIZE)
+                break;
+            frame_size = AV_RL32(buf + 4) - 12;
+            buf       += 20;
+            buf_size  -= 20;
         } else {
             if (buf_size < 12) // MKV files can have zero flags after last block
                 break;
             frame_size = AV_RL32(buf + 8) + 12;
         }
-        }
         if (frame_size <= 0 || frame_size > buf_size) {
             av_log(avctx, AV_LOG_ERROR,
                    "Block %d has invalid size (size %d vs. %d bytes left)\n",

libavformat/wv.c

@@ -30,7 +30,7 @@
 // specs say that maximum block size is 1Mb
 #define WV_BLOCK_LIMIT 1047576
 
-#define WV_EXTRA_SIZE 12
+#define WV_HEADER_SIZE 32
 
 #define WV_START_BLOCK  0x0800
 #define WV_END_BLOCK    0x1000
@@ -56,13 +56,13 @@ static const int wv_rates[16] = {
 };
 
 typedef struct {
+    uint8_t block_header[WV_HEADER_SIZE];
     uint32_t blksize, flags;
     int rate, chan, bpp;
     uint32_t chmask;
     uint32_t samples, soff;
     int multichannel;
     int block_parsed;
-    uint8_t extra[WV_EXTRA_SIZE];
     int64_t pos;
 
     int64_t apetag_start;
@@ -83,12 +83,11 @@ static int wv_probe(AVProbeData *p)
         return 0;
 }
 
-static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb,
-                                int append)
+static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
 {
     WVContext *wc = ctx->priv_data;
-    uint32_t tag, ver;
-    int size;
+    uint32_t ver;
+    int size, ret;
     int rate, bpp, chan;
     uint32_t chmask;
 
@@ -98,33 +97,30 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb,
     if (wc->apetag_start && wc->pos >= wc->apetag_start)
         return AVERROR_EOF;
 
-    if (!append) {
-        tag = avio_rl32(pb);
-        if (tag != MKTAG('w', 'v', 'p', 'k'))
+    ret = avio_read(pb, wc->block_header, WV_HEADER_SIZE);
+    if (ret != WV_HEADER_SIZE)
+        return (ret < 0) ? ret : AVERROR_EOF;
+
+    if (AV_RL32(wc->block_header) != MKTAG('w', 'v', 'p', 'k'))
         return AVERROR_INVALIDDATA;
-        size = avio_rl32(pb);
+
+    size = AV_RL32(wc->block_header + 4);
     if (size < 24 || size > WV_BLOCK_LIMIT) {
         av_log(ctx, AV_LOG_ERROR, "Incorrect block size %i\n", size);
         return AVERROR_INVALIDDATA;
     }
     wc->blksize = size;
-        ver = avio_rl16(pb);
+    ver = AV_RL32(wc->block_header + 8);
     if (ver < 0x402 || ver > 0x410) {
         av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", ver);
         return AVERROR_PATCHWELCOME;
     }
-        avio_r8(pb); // track no
-        avio_r8(pb); // track sub index
-        wc->samples = avio_rl32(pb); // total samples in file
-        wc->soff    = avio_rl32(pb); // offset in samples of current block
-        avio_read(pb, wc->extra, WV_EXTRA_SIZE);
-    } else {
-        size = wc->blksize;
-    }
-    wc->flags = AV_RL32(wc->extra + 4);
+    wc->samples = AV_RL32(wc->block_header + 12); // total samples in file
+    wc->soff    = AV_RL32(wc->block_header + 16); // offset in samples of current block
+    wc->flags   = AV_RL32(wc->block_header + 24);
     /* Blocks with zero samples don't contain actual audio information
      * and should be ignored */
-    if (!AV_RN32(wc->extra))
+    if (!AV_RN32(wc->block_header + 20))
         return 0;
     // parse flags
     bpp    = ((wc->flags & 3) + 1) << 3;
@@ -238,9 +234,9 @@ static int wv_read_header(AVFormatContext *s)
 
     wc->block_parsed = 0;
     for (;;) {
-        if ((ret = wv_read_block_header(s, pb, 0)) < 0)
+        if ((ret = wv_read_block_header(s, pb)) < 0)
             return ret;
-        if (!AV_RN32(wc->extra))
+        if (!AV_RL32(wc->block_header + 20))
             avio_skip(pb, wc->blksize - 24);
         else
             break;
@@ -276,75 +272,49 @@ static int wv_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     WVContext *wc = s->priv_data;
     int ret;
-    int size, ver, off;
+    int off;
     int64_t pos;
     uint32_t block_samples;
 
     if (url_feof(s->pb))
         return AVERROR_EOF;
     if (wc->block_parsed) {
-        if ((ret = wv_read_block_header(s, s->pb, 0)) < 0)
+        if ((ret = wv_read_block_header(s, s->pb)) < 0)
             return ret;
     }
 
     pos = wc->pos;
-    off = wc->multichannel ? 4 : 0;
-    if (av_new_packet(pkt, wc->blksize + WV_EXTRA_SIZE + off) < 0)
+    if (av_new_packet(pkt, wc->blksize + WV_HEADER_SIZE) < 0)
         return AVERROR(ENOMEM);
-    if (wc->multichannel)
-        AV_WL32(pkt->data, wc->blksize + WV_EXTRA_SIZE + 12);
-    memcpy(pkt->data + off, wc->extra, WV_EXTRA_SIZE);
-    ret = avio_read(s->pb, pkt->data + WV_EXTRA_SIZE + off, wc->blksize);
+    memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE);
+    ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->blksize);
     if (ret != wc->blksize) {
         av_free_packet(pkt);
         return AVERROR(EIO);
     }
     while (!(wc->flags & WV_END_BLOCK)) {
-        if (avio_rl32(s->pb) != MKTAG('w', 'v', 'p', 'k')) {
-            av_free_packet(pkt);
-            return AVERROR_INVALIDDATA;
-        }
-        if ((ret = av_append_packet(s->pb, pkt, 4)) < 0) {
-            av_free_packet(pkt);
-            return ret;
-        }
-        size = AV_RL32(pkt->data + pkt->size - 4);
-        if (size < 24 || size > WV_BLOCK_LIMIT) {
-            av_free_packet(pkt);
-            av_log(s, AV_LOG_ERROR, "Incorrect block size %d\n", size);
-            return AVERROR_INVALIDDATA;
-        }
-        wc->blksize = size;
-        ver         = avio_rl16(s->pb);
-        if (ver < 0x402 || ver > 0x410) {
-            av_free_packet(pkt);
-            av_log(s, AV_LOG_ERROR, "Unsupported version %03X\n", ver);
-            return AVERROR_PATCHWELCOME;
-        }
-        avio_r8(s->pb); // track no
-        avio_r8(s->pb); // track sub index
-        wc->samples = avio_rl32(s->pb); // total samples in file
-        wc->soff    = avio_rl32(s->pb); // offset in samples of current block
-        if ((ret = av_append_packet(s->pb, pkt, WV_EXTRA_SIZE)) < 0) {
+        if ((ret = wv_read_block_header(s, s->pb)) < 0) {
             av_free_packet(pkt);
             return ret;
         }
-        memcpy(wc->extra, pkt->data + pkt->size - WV_EXTRA_SIZE, WV_EXTRA_SIZE);
 
-        if ((ret = wv_read_block_header(s, s->pb, 1)) < 0) {
+        off = pkt->size;
+        if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->blksize)) < 0) {
             av_free_packet(pkt);
             return ret;
         }
-        ret = av_append_packet(s->pb, pkt, wc->blksize);
-        if (ret < 0) {
+        memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE);
+
+        ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->blksize);
+        if (ret != wc->blksize) {
             av_free_packet(pkt);
-            return ret;
+            return (ret < 0) ? ret : AVERROR_EOF;
         }
     }
     pkt->stream_index = 0;
     wc->block_parsed  = 1;
     pkt->pts          = wc->soff;
-    block_samples     = AV_RL32(wc->extra);
+    block_samples     = AV_RL32(wc->block_header + 20);
     if (block_samples > INT32_MAX)
         av_log(s, AV_LOG_WARNING,
                "Too many samples in block: %"PRIu32"\n", block_samples);