Packman Build Service PMBS

ffmpeg-3.changes Changed

ffmpeg-3.spec Changed

_service Changed

ffmpeg-3-3.4.12.tar.xz/CREDITS -> ffmpeg-3-3.4.13.tar.xz/CREDITS Changed

ffmpeg-3-3.4.12.tar.xz/Changelog -> ffmpeg-3-3.4.13.tar.xz/Changelog Changed

@@ -1,6 +1,60 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.
 
+version 3.4.13:
+ avcodec/noise_bsf: Check for wrapped frames
+ avcodec/pngdec: Do not pass AVFrame into global header decode
+ avformat/wavdec: Check that smv block fits in available space
+ avcodec/tak: Check remaining bits in ff_tak_decode_frame_header()
+ avcodec/utils: the IFF_ILBM implementation assumes that there are a multiple of 16 allocated
+ avcodec/vorbisdec: Check codebook float values to be finite
+ avcodec/g2meet: Replace fake allocation avoidance for framebuf
+ avcodec/lcldec: More space for rgb24
+ avcodec/lcldec: Support 4:1:1 and 4:2:2 with odd width
+ libavcodec/lcldec: width and height should not be unsigned
+ avcodec/escape124: Check that blocks are allocated before use
+ avcodec/huffyuvdec: Fix undefined behavior with shift
+ avcodec/j2kenc: fix 5/3 DWT identifer
+ avcodec/vp3: Check width to avoid assertion failure
+ avcodec/g729postfilter: Limit shift in long term filter
+ configure: update copyright year
+ avcodec/tests/snowenc: Fix 2nd test
+ avcodec/tests/snowenc: return a failure if DWT/IDWT mismatches
+ avcodec/snowenc: Fix visual weight calculation
+ avcodec/tests/snowenc: unbreak DWT tests
+ avcodec/vp3: Add missing check for av_malloc
+ avcodec/escape124: Fix some return codes
+ avcodec/escape124: fix signdness of end of input check
+ Use https for repository links
+ avcodec/motionpixels: Mask pixels to valid values
+ avcodec/xpmdec: Check size before allocation to avoid truncation
+ avcodec/bink: Avoid undefined out of array end pointers in binkb_decode_plane()
+ avcodec/bink: Fix off by 1 error in ref end
+ avcodec/utils: Ensure linesize for SVQ3
+ avcodec/utils: allocate a line more for VC1 and WMV3
+ avcodec/videodsp_template: Adjust pointers to avoid undefined pointer things
+ avcodec/pngdec: Check deloco index more exactly
+ avcodec/ffv1dec: Check that num h/v slices is supported
+ avformat/mov: Check samplesize and offset to avoid integer overflow
+ avcodec/pictordec: Remove mid exit branch
+ avcodec/eac3dec: avoid float noise in fixed mode addition to overflow
+ avcodec/utils: use 32pixel alignment for bink
+ avcodec/012v: Order operations for odd size handling
+ avcodec/eatgq: : Check index increments in tgq_decode_block()
+ avcodec/scpr: Test bx before use
+ avcodec/sunrast: Fix maplength check
+ avcodec/wavpack: Avoid undefined shift in get_tail()
+ avformat/id3v2: Check taglen in read_uslt()
+ avcodec/ffv1dec: restructure slice coordinate reading a bit
+ avcodec/mlpdec: Check max matrix instead of max channel in noise check
+ swscale/input: Use more unsigned intermediates
+ avcodec/alsdec: The minimal block is at least 7 bits
+ avformat/replaygain: avoid undefined / negative abs
+ swscale/output: Bias 16bps output calculations to improve non overflowing range
+ avcodec/speedhq: Check buf_size to be big enough for DC
+ avcodec/ffv1dec: Fail earlier if prior context is corrupted
+ swscale: aarch64: Fix yuv2rgb with negative strides
+
 version 3.4.12:
  avcodec/dstdec: Check for overflow in build_filter()
  avformat/spdifdec: Use 64bit to compute bit rate

ffmpeg-3-3.4.12.tar.xz/RELEASE -> ffmpeg-3-3.4.13.tar.xz/RELEASE Changed

ffmpeg-3-3.4.12.tar.xz/configure -> ffmpeg-3-3.4.13.tar.xz/configure Changed

ffmpeg-3-3.4.12.tar.xz/doc/Doxyfile -> ffmpeg-3-3.4.13.tar.xz/doc/Doxyfile Changed

ffmpeg-3-3.4.12.tar.xz/doc/authors.texi -> ffmpeg-3-3.4.13.tar.xz/doc/authors.texi Changed

ffmpeg-3-3.4.12.tar.xz/doc/git-howto.texi -> ffmpeg-3-3.4.13.tar.xz/doc/git-howto.texi Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/012v.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/012v.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/ac3.h -> ffmpeg-3-3.4.13.tar.xz/libavcodec/ac3.h Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/alsdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/alsdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/bink.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/bink.c Changed

@@ -825,7 +825,7 @@
 
     binkb_init_bundles(c);
     ref_start = frame->dataplane_idx;
-    ref_end   = frame->dataplane_idx + (bh * frame->linesizeplane_idx + bw) * 8;
+    ref_end   = frame->dataplane_idx + ((bh - 1) * frame->linesizeplane_idx + bw - 1) * 8;
 
     for (i = 0; i < 64; i++)
         coordmapi = (i & 7) + (i >> 3) * stride;
@@ -879,7 +879,7 @@
                 xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
                 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
                 ref = dst + xoff + yoff * stride;
-                if (ref < ref_start || ref + 8*stride > ref_end) {
+                if (ref < ref_start || ref > ref_end) {
                     av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
                 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
                     c->hdsp.put_pixels_tab10(dst, ref, stride, 8);
@@ -895,7 +895,7 @@
                 xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
                 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
                 ref = dst + xoff + yoff * stride;
-                if (ref < ref_start || ref + 8 * stride > ref_end) {
+                if (ref < ref_start || ref > ref_end) {
                     av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
                 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
                     c->hdsp.put_pixels_tab10(dst, ref, stride, 8);
@@ -925,7 +925,7 @@
                 xoff = binkb_get_value(c, BINKB_SRC_X_OFF);
                 yoff = binkb_get_value(c, BINKB_SRC_Y_OFF) + ybias;
                 ref = dst + xoff + yoff * stride;
-                if (ref < ref_start || ref + 8 * stride > ref_end) {
+                if (ref < ref_start || ref > ref_end) {
                     av_log(c->avctx, AV_LOG_WARNING, "Reference block is out of bounds\n");
                 } else if (ref + 8*stride < dst || ref >= dst + 8*stride) {
                     c->hdsp.put_pixels_tab10(dst, ref, stride, 8);

ffmpeg-3-3.4.12.tar.xz/libavcodec/eac3dec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/eac3dec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/eatgq.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/eatgq.c Changed

@@ -58,7 +58,7 @@
     return 0;
 }
 
-static void tgq_decode_block(TgqContext *s, int16_t block64, GetBitContext *gb)
+static int tgq_decode_block(TgqContext *s, int16_t block64, GetBitContext *gb)
 {
     uint8_t *perm = s->scantable.permutated;
     int i, j, value;
@@ -66,6 +66,8 @@
     for (i = 1; i < 64;) {
         switch (show_bits(gb, 3)) {
         case 4:
+            if (i >= 63)
+                return AVERROR_INVALIDDATA;
             blockpermi++ = 0;
         case 0:
             blockpermi++ = 0;
@@ -75,6 +77,8 @@
         case 1:
             skip_bits(gb, 2);
             value = get_bits(gb, 6);
+            if (value > 64 - i)
+                return AVERROR_INVALIDDATA;
             for (j = 0; j < value; j++)
                 blockpermi++ = 0;
             break;
@@ -102,6 +106,7 @@
         }
     }
     block0 += 128 << 4;
+    return 0;
 }
 
 static void tgq_idct_put_mb(TgqContext *s, int16_t (*block)64, AVFrame *frame,
@@ -161,8 +166,11 @@
         if (ret < 0)
             return ret;
 
-        for (i = 0; i < 6; i++)
-            tgq_decode_block(s, s->blocki, &gb);
+        for (i = 0; i < 6; i++) {
+            int ret = tgq_decode_block(s, s->blocki, &gb);
+            if (ret < 0)
+                return ret;
+        }
         tgq_idct_put_mb(s, s->block, frame, mb_x, mb_y);
         bytestream2_skip(&s->gb, mode);
     } else {

ffmpeg-3-3.4.12.tar.xz/libavcodec/escape124.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/escape124.c Changed

@@ -88,11 +88,6 @@
     unsigned i, j;
     CodeBook cb = { 0 };
 
-    if (size >= INT_MAX / 34 || get_bits_left(gb) < size * 34)
-        return cb;
-
-    if (size >= INT_MAX / sizeof(MacroBlock))
-        return cb;
     cb.blocks = av_malloc(size ? size * sizeof(MacroBlock) : 1);
     if (!cb.blocks)
         return cb;
@@ -162,7 +157,7 @@
 
     // This condition can occur with invalid bitstreams and
     // *codebook_index == 2
-    if (block_index >= s->codebooks*codebook_index.size)
+    if (block_index >= s->codebooks*codebook_index.size || !s->codebooks*codebook_index.blocks)
         return (MacroBlock) { { 0 } };
 
     return s->codebooks*codebook_index.blocksblock_index;
@@ -226,7 +221,7 @@
     // represent a lower bound of the space needed for skipped superblocks. Non
     // skipped SBs need more space.
     if (get_bits_left(&gb) < 64 + s->num_superblocks * 23LL / 4320)
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     frame_flags = get_bits_long(&gb, 32);
     frame_size  = get_bits_long(&gb, 32);
@@ -277,9 +272,14 @@
             }
 
             av_freep(&s->codebooksi.blocks);
+            if (cb_size >= INT_MAX / 34 || get_bits_left(&gb) < (int)cb_size * 34)
+                return AVERROR_INVALIDDATA;
+
+            if (cb_size >= INT_MAX / sizeof(MacroBlock))
+                return AVERROR_INVALIDDATA;
             s->codebooksi = unpack_codebook(&gb, cb_depth, cb_size);
             if (!s->codebooksi.blocks)
-                return -1;
+                return AVERROR(ENOMEM);
         }
     }

ffmpeg-3-3.4.12.tar.xz/libavcodec/ffv1dec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/ffv1dec.c Changed

@@ -169,24 +169,31 @@
     RangeCoder *c = &fs->c;
     uint8_t stateCONTEXT_SIZE;
     unsigned ps, i, context_count;
+    int sx, sy, sw, sh;
+
     memset(state, 128, sizeof(state));
+    sx = get_symbol(c, state, 0);
+    sy = get_symbol(c, state, 0);
+    sw = get_symbol(c, state, 0) + 1U;
+    sh = get_symbol(c, state, 0) + 1U;
 
     av_assert0(f->version > 2);
 
-    fs->slice_x      =  get_symbol(c, state, 0)      * f->width ;
-    fs->slice_y      =  get_symbol(c, state, 0)      * f->height;
-    fs->slice_width  = (get_symbol(c, state, 0) + 1) * f->width  + fs->slice_x;
-    fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
-
-    fs->slice_x /= f->num_h_slices;
-    fs->slice_y /= f->num_v_slices;
-    fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
-    fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
-    if ((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
-        return -1;
-    if (    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
-         || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
-        return -1;
+
+    if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
+        return AVERROR_INVALIDDATA;
+    if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
+        return AVERROR_INVALIDDATA;
+
+    fs->slice_x      =  sx       * (int64_t)f->width  / f->num_h_slices;
+    fs->slice_y      =  sy       * (int64_t)f->height / f->num_v_slices;
+    fs->slice_width  = (sx + sw) * (int64_t)f->width  / f->num_h_slices - fs->slice_x;
+    fs->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - fs->slice_y;
+
+    av_assert0((unsigned)fs->slice_width  <= f->width &&
+                (unsigned)fs->slice_height <= f->height);
+    av_assert0 (   (unsigned)fs->slice_x + (uint64_t)fs->slice_width  <= f->width
+                && (unsigned)fs->slice_y + (uint64_t)fs->slice_height <= f->height);
 
     if (fs->ac == AC_GOLOMB_RICE && fs->slice_width >= (1<<23))
         return AVERROR_INVALIDDATA;
@@ -304,8 +311,11 @@
     }
     if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
         return ret;
-    if (f->cur->key_frame || fs->slice_reset_contexts)
+    if (f->cur->key_frame || fs->slice_reset_contexts) {
         ff_ffv1_clear_slice_state(f, fs);
+    } else if (fs->slice_damaged) {
+        return AVERROR_INVALIDDATA;
+    }
 
     width  = fs->slice_width;
     height = fs->slice_height;
@@ -466,6 +476,11 @@
         return AVERROR_INVALIDDATA;
     }
 
+    if (f->num_h_slices > MAX_SLICES / f->num_v_slices) {
+        av_log(f->avctx, AV_LOG_ERROR, "slice count unsupported\n");
+        return AVERROR_PATCHWELCOME;
+    }
+
     f->quant_table_count = get_symbol(c, state, 0);
     if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
         av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
@@ -742,21 +757,25 @@
         fs->slice_damaged = 0;
 
         if (f->version == 2) {
-            fs->slice_x      =  get_symbol(c, state, 0)      * f->width ;
-            fs->slice_y      =  get_symbol(c, state, 0)      * f->height;
-            fs->slice_width  = (get_symbol(c, state, 0) + 1) * f->width  + fs->slice_x;
-            fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
-
-            fs->slice_x     /= f->num_h_slices;
-            fs->slice_y     /= f->num_v_slices;
-            fs->slice_width  = fs->slice_width  / f->num_h_slices - fs->slice_x;
-            fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
-            if ((unsigned)fs->slice_width  > f->width ||
-                (unsigned)fs->slice_height > f->height)
+            int sx = get_symbol(c, state, 0);
+            int sy = get_symbol(c, state, 0);
+            int sw = get_symbol(c, state, 0) + 1U;
+            int sh = get_symbol(c, state, 0) + 1U;
+
+            if (sx < 0 || sy < 0 || sw <= 0 || sh <= 0)
                 return AVERROR_INVALIDDATA;
-            if (   (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
-                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
+            if (sx > f->num_h_slices - sw || sy > f->num_v_slices - sh)
                 return AVERROR_INVALIDDATA;
+
+            fs->slice_x      =  sx       * (int64_t)f->width  / f->num_h_slices;
+            fs->slice_y      =  sy       * (int64_t)f->height / f->num_v_slices;
+            fs->slice_width  = (sx + sw) * (int64_t)f->width  / f->num_h_slices - fs->slice_x;
+            fs->slice_height = (sy + sh) * (int64_t)f->height / f->num_v_slices - fs->slice_y;
+
+            av_assert0((unsigned)fs->slice_width  <= f->width &&
+                       (unsigned)fs->slice_height <= f->height);
+            av_assert0 (   (unsigned)fs->slice_x + (uint64_t)fs->slice_width  <= f->width
+                        && (unsigned)fs->slice_y + (uint64_t)fs->slice_height <= f->height);
         }
 
         for (i = 0; i < f->plane_count; i++) {

ffmpeg-3-3.4.12.tar.xz/libavcodec/g2meet.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/g2meet.c Changed

@@ -143,7 +143,8 @@
     int        got_header;
 
     uint8_t    *framebuf;
-    int        framebuf_stride, old_width, old_height;
+    int        framebuf_stride;
+    unsigned int framebuf_allocated;
 
     uint8_t    *synth_tile, *jpeg_tile, *epic_buf, *epic_buf_base;
     int        tile_stride, epic_buf_stride, old_tile_w, old_tile_h;
@@ -1179,14 +1180,13 @@
 {
     int aligned_height;
 
-    if (!c->framebuf || c->old_width < c->width || c->old_height < c->height) {
-        c->framebuf_stride = FFALIGN(c->width + 15, 16) * 3;
-        aligned_height     = c->height + 15;
-        av_free(c->framebuf);
-        c->framebuf = av_mallocz_array(c->framebuf_stride, aligned_height);
-        if (!c->framebuf)
-            return AVERROR(ENOMEM);
-    }
+    c->framebuf_stride = FFALIGN(c->width + 15, 16) * 3;
+    aligned_height = c->height + 15;
+
+    av_fast_mallocz(&c->framebuf, &c->framebuf_allocated, c->framebuf_stride * aligned_height);
+    if (!c->framebuf)
+        return AVERROR(ENOMEM);
+
     if (!c->synth_tile || !c->jpeg_tile ||
         (c->compression == 2 && !c->epic_buf_base) ||
         c->old_tile_w < c->tile_width ||
@@ -1638,6 +1638,7 @@
     av_freep(&c->jpeg_tile);
     av_freep(&c->cursor);
     av_freep(&c->framebuf);
+    c->framebuf_allocated = 0;
 
     return 0;
 }

ffmpeg-3-3.4.12.tar.xz/libavcodec/g729postfilter.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/g729postfilter.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/huffyuvdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/huffyuvdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/j2kenc.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/j2kenc.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/lcldec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/lcldec.c Changed

@@ -148,6 +148,8 @@
     if (expected != (unsigned int)c->zstream.total_out) {
         av_log(avctx, AV_LOG_ERROR, "Decoded size differs (%d != %lu)\n",
                expected, c->zstream.total_out);
+        if (expected > (unsigned int)c->zstream.total_out)
+            return (unsigned int)c->zstream.total_out;
         return AVERROR_UNKNOWN;
     }
     return c->zstream.total_out;
@@ -166,8 +168,8 @@
     int row, col;
     unsigned char *encoded = avpkt->data, *outptr;
     uint8_t *y_out, *u_out, *v_out;
-    unsigned int width = avctx->width; // Real image width
-    unsigned int height = avctx->height; // Real image height
+    int width = avctx->width; // Real image width
+    int height = avctx->height; // Real image height
     unsigned int mszh_dlen;
     unsigned char yq, y1q, uq, vq;
     int uqvq, ret;
@@ -274,12 +276,13 @@
             ret = zlib_decomp(avctx, buf + 8 + mthread_inlen, len - 8 - mthread_inlen,
                               mthread_outlen, mthread_outlen);
             if (ret < 0) return ret;
+            len = c->decomp_size;
         } else {
             int ret = zlib_decomp(avctx, buf, len, 0, c->decomp_size);
             if (ret < 0) return ret;
+            len = ret;
         }
         encoded = c->decomp_buf;
-        len = c->decomp_size;
         break;
 #endif
     default:
@@ -399,6 +402,11 @@
                 v_out col >> 1      = *encoded++ + 128;
                 v_out(col >> 1) + 1 = *encoded++ + 128;
             }
+            if (col && col < width) {
+                u_out col >> 1      = u_out(col>>1) - 1;
+                v_out col >> 1      = v_out(col>>1) - 1;
+            }
+
             y_out -= frame->linesize0;
             u_out -= frame->linesize1;
             v_out -= frame->linesize2;
@@ -420,6 +428,10 @@
                 u_outcol >> 2 = *encoded++ + 128;
                 v_outcol >> 2 = *encoded++ + 128;
             }
+            if (col && col < width) {
+                u_outcol >> 2 = u_out(col>>2) - 1;
+                v_outcol >> 2 = v_out(col>>2) - 1;
+            }
             y_out -= frame->linesize0;
             u_out -= frame->linesize1;
             v_out -= frame->linesize2;
@@ -477,6 +489,7 @@
                                 FFALIGN(avctx->height, 4);
     unsigned int max_decomp_size;
     int subsample_h, subsample_v;
+    int partial_h_supported = 0;
 
     if (avctx->extradata_size < 8) {
         av_log(avctx, AV_LOG_ERROR, "Extradata size too small.\n");
@@ -498,26 +511,24 @@
         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 1:1:1.\n");
         break;
     case IMGTYPE_YUV422:
-        c->decomp_size = basesize * 2;
+        c->decomp_size = (avctx->width & ~3) * avctx->height * 2;
         max_decomp_size = max_basesize * 2;
         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 4:2:2.\n");
-        if (avctx->width % 4) {
-            avpriv_request_sample(avctx, "Unsupported dimensions");
-            return AVERROR_INVALIDDATA;
-        }
+        partial_h_supported = 1;
         break;
     case IMGTYPE_RGB24:
-        c->decomp_size = basesize * 3;
+        c->decomp_size = FFALIGN(avctx->width*3, 4) * avctx->height;
         max_decomp_size = max_basesize * 3;
         avctx->pix_fmt = AV_PIX_FMT_BGR24;
         av_log(avctx, AV_LOG_DEBUG, "Image type is RGB 24.\n");
         break;
     case IMGTYPE_YUV411:
-        c->decomp_size = basesize / 2 * 3;
+        c->decomp_size = (avctx->width & ~3) * avctx->height / 2 * 3;
         max_decomp_size = max_basesize / 2 * 3;
         avctx->pix_fmt = AV_PIX_FMT_YUV411P;
         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 4:1:1.\n");
+        partial_h_supported = 1;
         break;
     case IMGTYPE_YUV211:
         c->decomp_size = basesize * 2;
@@ -537,7 +548,7 @@
     }
 
     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &subsample_h, &subsample_v);
-    if (avctx->width % (1<<subsample_h) || avctx->height % (1<<subsample_v)) {
+    if ((avctx->width % (1<<subsample_h) && !partial_h_supported) || avctx->height % (1<<subsample_v)) {
         avpriv_request_sample(avctx, "Unsupported dimensions");
         return AVERROR_INVALIDDATA;
     }

ffmpeg-3-3.4.12.tar.xz/libavcodec/mlpdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/mlpdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/motionpixels.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/motionpixels.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/noise_bsf.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/noise_bsf.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/pictordec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/pictordec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/pngdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/pngdec.c Changed

@@ -308,7 +308,7 @@
 static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \
 { \
     int i; \
-    for (i = 0; i < size; i += 3 + alpha) { \
+    for (i = 0; i < size - 2; i += 3 + alpha) { \
         int g = dst i + 1; \
         dsti + 0 += g; \
         dsti + 2 += g; \
@@ -620,6 +620,8 @@
     int ret;
     size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
 
+    if (!p)
+        return AVERROR_INVALIDDATA;
     if (!(s->hdr_state & PNG_IHDR)) {
         av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
         return AVERROR_INVALIDDATA;
@@ -1292,6 +1294,8 @@
             break;
         }
         case MKTAG('i', 'C', 'C', 'P'): {
+            if (!p)
+                return AVERROR_INVALIDDATA;
             if ((ret = decode_iccp_chunk(s, length, p)) < 0)
                 goto fail;
             break;
@@ -1314,6 +1318,9 @@
     }
 exit_loop:
 
+    if (!p)
+        return AVERROR_INVALIDDATA;
+
     if (avctx->codec_id == AV_CODEC_ID_PNG &&
         avctx->skip_frame == AVDISCARD_ALL) {
         return 0;
@@ -1460,7 +1467,7 @@
         s->zstream.zfree  = ff_png_zfree;
 
         bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
-        if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
+        if ((ret = decode_frame_common(avctx, s, NULL, avpkt)) < 0)
             goto end;
     }

ffmpeg-3-3.4.12.tar.xz/libavcodec/scpr.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/scpr.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/snowenc.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/snowenc.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/speedhq.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/speedhq.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/sunrast.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/sunrast.c Changed

@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/avassert.h"
 #include "libavutil/common.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/imgutils.h"
@@ -75,6 +76,12 @@
         return AVERROR_PATCHWELCOME;
     }
 
+    if (maplength > 768) {
+        av_log(avctx, AV_LOG_WARNING, "invalid colormap length\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    // This also checks depth to be valid
     switch (depth) {
         case 1:
             avctx->pix_fmt = maplength ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_MONOWHITE;
@@ -96,15 +103,23 @@
             return AVERROR_INVALIDDATA;
     }
 
+    // This checks w and h to be valid in the sense that bytes of a padded bitmap are addressable with 32bit int
     ret = ff_set_dimensions(avctx, w, h);
     if (ret < 0)
         return ret;
 
+    // ensured by ff_set_dimensions()
+    av_assert0(w <= (INT32_MAX - 7) / depth);
+
     /* scanlines are aligned on 16 bit boundaries */
     len  = (depth * w + 7) >> 3;
     alen = len + (len & 1);
 
-    if (buf_end - buf < maplength + (len * h) * 3 / 256)
+    // ensured by ff_set_dimensions()
+    av_assert0(h  <= INT32_MAX / (3 * len));
+
+    // maplength is limited to 768 and the right term is limited to INT32_MAX / 256 so the add needs no check
+    if (buf_end - buf < (uint64_t)maplength + (len * h) * 3 / 256)
         return AVERROR_INVALIDDATA;
 
     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
@@ -118,7 +133,7 @@
     } else if (maplength) {
         unsigned int len = maplength / 3;
 
-        if (maplength % 3 || maplength > 768) {
+        if (maplength % 3) {
             av_log(avctx, AV_LOG_WARNING, "invalid colormap length\n");
             return AVERROR_INVALIDDATA;
         }

ffmpeg-3-3.4.12.tar.xz/libavcodec/tak.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/tak.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/tests/snowenc.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/tests/snowenc.c Changed

@@ -31,11 +31,13 @@
 #define width  256
 #define height 256
     int buffer2width*height;
+    short obufferwidth*height;
     SnowContext s;
     int i;
     AVLFG prng;
     s.spatial_decomposition_count=6;
     s.spatial_decomposition_type=1;
+    int ret = 0;
 
     s.temp_dwt_buffer  = av_mallocz_array(width, sizeof(DWTELEM));
     s.temp_idwt_buffer = av_mallocz_array(width, sizeof(IDWTELEM));
@@ -49,24 +51,34 @@
 
     printf("testing 5/3 DWT\n");
     for(i=0; i<width*height; i++)
-        buffer0i = buffer1i = av_lfg_get(&prng) % 54321 - 12345;
+        buffer0i = buffer1i = av_lfg_get(&prng) % 19000 - 9000;
 
     ff_spatial_dwt(buffer0, s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
-    ff_spatial_idwt((IDWTELEM*)buffer0, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+    for(i=0; i<width*height; i++)
+        obufferi = buffer0i;
+    ff_spatial_idwt(obuffer, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 
     for(i=0; i<width*height; i++)
-        if(buffer0i!= buffer1i) printf("fsck: %6d %12d %7d\n",i, buffer0i, buffer1i);
+        if(buffer1i!= obufferi) {
+            printf("fsck: %4dx%4dx %12d %7d\n",i%width, i/width, buffer1i, obufferi);
+            ret = 1;
+        }
 
     printf("testing 9/7 DWT\n");
     s.spatial_decomposition_type=0;
     for(i=0; i<width*height; i++)
-        buffer0i = buffer1i = av_lfg_get(&prng) % 54321 - 12345;
+        buffer0i = buffer1i = av_lfg_get(&prng) % 11000 - 5000;
 
     ff_spatial_dwt(buffer0, s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
-    ff_spatial_idwt((IDWTELEM*)buffer0, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+    for(i=0; i<width*height; i++)
+        obufferi = buffer0i;
+    ff_spatial_idwt(obuffer, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 
     for(i=0; i<width*height; i++)
-        if(FFABS(buffer0i - buffer1i)>20) printf("fsck: %6d %12d %7d\n",i, buffer0i, buffer1i);
+        if(FFABS(buffer1i - obufferi)>20) {
+            printf("fsck: %4dx%4d %12d %7d\n",i%width, i/width, buffer1i, obufferi);
+            ret = 1;
+        }
 
     {
     int level, orientation, x, y;
@@ -81,18 +93,18 @@
                 int w= width  >> (s.spatial_decomposition_count-level);
                 int h= height >> (s.spatial_decomposition_count-level);
                 int stride= width  << (s.spatial_decomposition_count-level);
-                DWTELEM *buf= buffer0;
+                IDWTELEM *buf= obuffer;
                 int64_t error=0;
 
                 if(orientation&1) buf+=w;
                 if(orientation>1) buf+=stride>>1;
 
-                memset(buffer0, 0, sizeof(int)*width*height);
-                bufw/2 + h/2*stride= 256*256;
-                ff_spatial_idwt((IDWTELEM*)buffer0, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
+                memset(obuffer, 0, sizeof(short)*width*height);
+                bufw/2 + h/2*stride= 8*256;
+                ff_spatial_idwt(obuffer, s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
                 for(y=0; y<height; y++){
                     for(x=0; x<width; x++){
-                        int64_t d= buffer0x + y*width;
+                        int64_t d= obufferx + y*width;
                         error += d*d;
                         if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
                     }
@@ -143,5 +155,5 @@
         }
 
     }
-    return 0;
+    return ret;
 }

ffmpeg-3-3.4.12.tar.xz/libavcodec/utils.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/utils.c Changed

@@ -359,6 +359,8 @@
     case AV_PIX_FMT_GBRAP16BE:
         w_align = 16; //FIXME assume 16 pixel per macroblock
         h_align = 16 * 2; // interlaced needs 2 macroblocks height
+        if (s->codec_id == AV_CODEC_ID_BINKVIDEO)
+            w_align = 16*2;
         break;
     case AV_PIX_FMT_YUV411P:
     case AV_PIX_FMT_YUVJ411P:
@@ -424,12 +426,13 @@
     }
 
     if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
-        w_align = FFMAX(w_align, 8);
+        w_align = FFMAX(w_align, 16);
     }
 
     *width  = FFALIGN(*width, w_align);
     *height = FFALIGN(*height, h_align);
     if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
+        s->codec_id == AV_CODEC_ID_VC1  || s->codec_id == AV_CODEC_ID_WMV3 ||
         s->codec_id == AV_CODEC_ID_VP5  || s->codec_id == AV_CODEC_ID_VP6 ||
         s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
     ) {
@@ -443,6 +446,9 @@
         // the next rounded up width is 32
         *width = FFMAX(*width, 32);
     }
+    if (s->codec_id == AV_CODEC_ID_SVQ3) {
+        *width = FFMAX(*width, 32);
+    }
 
     for (i = 0; i < 4; i++)
         linesize_aligni = STRIDE_ALIGN;

ffmpeg-3-3.4.12.tar.xz/libavcodec/videodsp_template.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/videodsp_template.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/vorbisdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/vorbisdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/vp3.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/vp3.c Changed

@@ -1747,6 +1747,8 @@
     s->avctx  = avctx;
     s->width  = FFALIGN(avctx->coded_width, 16);
     s->height = FFALIGN(avctx->coded_height, 16);
+    if (s->width < 18)
+        return AVERROR_PATCHWELCOME;
     if (avctx->codec_id != AV_CODEC_ID_THEORA)
         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
@@ -2099,8 +2101,13 @@
     if (ff_thread_get_buffer(avctx, &s->current_frame, AV_GET_BUFFER_FLAG_REF) < 0)
         goto error;
 
-    if (!s->edge_emu_buffer)
+    if (!s->edge_emu_buffer) {
         s->edge_emu_buffer = av_malloc(9 * FFABS(s->current_frame.f->linesize0));
+        if (!s->edge_emu_buffer) {
+            ret = AVERROR(ENOMEM);
+            goto error;
+        }
+    }
 
     if (s->keyframe) {
         if (!s->theora) {
@@ -2308,7 +2315,9 @@
     /* sanity check */
     if (av_image_check_size(visible_width, visible_height, 0, avctx) < 0 ||
         visible_width  + offset_x > s->width ||
-        visible_height + offset_y > s->height) {
+        visible_height + offset_y > s->height ||
+        visible_width < 18
+    ) {
         av_log(avctx, AV_LOG_ERROR,
                "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
                visible_width, visible_height, offset_x, offset_y,
@@ -2354,6 +2363,8 @@
     } else
         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 
+    if (s->width < 18)
+        return AVERROR_PATCHWELCOME;
     ret = ff_set_dimensions(avctx, s->width, s->height);
     if (ret < 0)
         return ret;

ffmpeg-3-3.4.12.tar.xz/libavcodec/wavpack.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/wavpack.c Changed

ffmpeg-3-3.4.12.tar.xz/libavcodec/xpmdec.c -> ffmpeg-3-3.4.13.tar.xz/libavcodec/xpmdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libavformat/id3v2.c -> ffmpeg-3-3.4.13.tar.xz/libavformat/id3v2.c Changed

ffmpeg-3-3.4.12.tar.xz/libavformat/mov.c -> ffmpeg-3-3.4.13.tar.xz/libavformat/mov.c Changed

ffmpeg-3-3.4.12.tar.xz/libavformat/replaygain.c -> ffmpeg-3-3.4.13.tar.xz/libavformat/replaygain.c Changed

ffmpeg-3-3.4.12.tar.xz/libavformat/wavdec.c -> ffmpeg-3-3.4.13.tar.xz/libavformat/wavdec.c Changed

ffmpeg-3-3.4.12.tar.xz/libswscale/aarch64/yuv2rgb_neon.S -> ffmpeg-3-3.4.13.tar.xz/libswscale/aarch64/yuv2rgb_neon.S Changed

@@ -118,8 +118,8 @@
 .endm
 
 .macro increment_yuv422p
-    add                 x6,  x6,  w7, UXTW                              // srcU += incU
-    add                 x13, x13, w14, UXTW                             // srcV += incV
+    add                 x6,  x6,  w7, SXTW                              // srcU += incU
+    add                 x13, x13, w14, SXTW                             // srcV += incV
 .endm
 
 .macro compute_rgba r1 g1 b1 a1 r2 g2 b2 a2
@@ -188,8 +188,8 @@
     st4                 {v16.8B,v17.8B,v18.8B,v19.8B}, x2, #32
     subs                w8, w8, #16                                     // width -= 16
     b.gt                2b
-    add                 x2, x2, w3, UXTW                                // dst  += padding
-    add                 x4, x4, w5, UXTW                                // srcY += paddingY
+    add                 x2, x2, w3, SXTW                                // dst  += padding
+    add                 x4, x4, w5, SXTW                                // srcY += paddingY
     increment_\ifmt
     subs                w1, w1, #1                                      // height -= 1
     b.gt                1b

ffmpeg-3-3.4.12.tar.xz/libswscale/input.c -> ffmpeg-3-3.4.13.tar.xz/libswscale/input.c Changed

@@ -84,9 +84,9 @@
     int32_t rv = rgb2yuvRV_IDX, gv = rgb2yuvGV_IDX, bv = rgb2yuvBV_IDX;
     av_assert1(src1==src2);
     for (i = 0; i < width; i++) {
-        int r_b = (input_pixel(&src18 * i + 0) + input_pixel(&src18 * i + 4) + 1) >> 1;
-        int   g = (input_pixel(&src18 * i + 1) + input_pixel(&src18 * i + 5) + 1) >> 1;
-        int b_r = (input_pixel(&src18 * i + 2) + input_pixel(&src18 * i + 6) + 1) >> 1;
+        unsigned r_b = (input_pixel(&src18 * i + 0) + input_pixel(&src18 * i + 4) + 1) >> 1;
+        unsigned   g = (input_pixel(&src18 * i + 1) + input_pixel(&src18 * i + 5) + 1) >> 1;
+        unsigned b_r = (input_pixel(&src18 * i + 2) + input_pixel(&src18 * i + 6) + 1) >> 1;
 
         dstUi= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
         dstVi= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
@@ -156,9 +156,9 @@
     int32_t rv = rgb2yuvRV_IDX, gv = rgb2yuvGV_IDX, bv = rgb2yuvBV_IDX;
     av_assert1(src1 == src2);
     for (i = 0; i < width; i++) {
-        int r_b = input_pixel(&src1i * 3 + 0);
-        int g   = input_pixel(&src1i * 3 + 1);
-        int b_r = input_pixel(&src1i * 3 + 2);
+        unsigned r_b = input_pixel(&src1i * 3 + 0);
+        unsigned g   = input_pixel(&src1i * 3 + 1);
+        unsigned b_r = input_pixel(&src1i * 3 + 2);
 
         dstUi = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
         dstVi = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
@@ -178,12 +178,12 @@
     int32_t rv = rgb2yuvRV_IDX, gv = rgb2yuvGV_IDX, bv = rgb2yuvBV_IDX;
     av_assert1(src1 == src2);
     for (i = 0; i < width; i++) {
-        int r_b = (input_pixel(&src16 * i + 0) +
-                   input_pixel(&src16 * i + 3) + 1) >> 1;
-        int g   = (input_pixel(&src16 * i + 1) +
-                   input_pixel(&src16 * i + 4) + 1) >> 1;
-        int b_r = (input_pixel(&src16 * i + 2) +
-                   input_pixel(&src16 * i + 5) + 1) >> 1;
+        unsigned r_b = (input_pixel(&src16 * i + 0) +
+                        input_pixel(&src16 * i + 3) + 1) >> 1;
+        unsigned g   = (input_pixel(&src16 * i + 1) +
+                        input_pixel(&src16 * i + 4) + 1) >> 1;
+        unsigned b_r = (input_pixel(&src16 * i + 2) +
+                        input_pixel(&src16 * i + 5) + 1) >> 1;
 
         dstUi = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
         dstVi = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;

ffmpeg-3-3.4.12.tar.xz/libswscale/output.c -> ffmpeg-3-3.4.13.tar.xz/libswscale/output.c Changed

@@ -827,8 +827,8 @@
         Y2 -= c->yuv2rgb_y_offset;
         Y1 *= c->yuv2rgb_y_coeff;
         Y2 *= c->yuv2rgb_y_coeff;
-        Y1 += 1 << 13; // 21
-        Y2 += 1 << 13;
+        Y1 += (1 << 13) - (1 << 29); // 21
+        Y2 += (1 << 13) - (1 << 29);
         // 8 bits: 17 + 13 bits = 30 bits, 16 bits: 17 + 13 bits = 30 bits
 
         R = V * c->yuv2rgb_v2r_coeff;
@@ -836,20 +836,20 @@
         B =                            U * c->yuv2rgb_u2b_coeff;
 
         // 8 bits: 30 - 22 = 8 bits, 16 bits: 30 bits - 14 = 16 bits
-        output_pixel(&dest0, av_clip_uintp2(R_B + Y1, 30) >> 14);
-        output_pixel(&dest1, av_clip_uintp2(  G + Y1, 30) >> 14);
-        output_pixel(&dest2, av_clip_uintp2(B_R + Y1, 30) >> 14);
+        output_pixel(&dest0, av_clip_uintp2(((R_B + Y1) >> 14) + (1<<15), 16));
+        output_pixel(&dest1, av_clip_uintp2(((  G + Y1) >> 14) + (1<<15), 16));
+        output_pixel(&dest2, av_clip_uintp2(((B_R + Y1) >> 14) + (1<<15), 16));
         if (eightbytes) {
             output_pixel(&dest3, av_clip_uintp2(A1      , 30) >> 14);
-            output_pixel(&dest4, av_clip_uintp2(R_B + Y2, 30) >> 14);
-            output_pixel(&dest5, av_clip_uintp2(  G + Y2, 30) >> 14);
-            output_pixel(&dest6, av_clip_uintp2(B_R + Y2, 30) >> 14);
+            output_pixel(&dest4, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest5, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest6, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
             output_pixel(&dest7, av_clip_uintp2(A2      , 30) >> 14);
             dest += 8;
         } else {
-            output_pixel(&dest3, av_clip_uintp2(R_B + Y2, 30) >> 14);
-            output_pixel(&dest4, av_clip_uintp2(  G + Y2, 30) >> 14);
-            output_pixel(&dest5, av_clip_uintp2(B_R + Y2, 30) >> 14);
+            output_pixel(&dest3, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest4, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest5, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
             dest += 6;
         }
     }
@@ -886,8 +886,8 @@
         Y2 -= c->yuv2rgb_y_offset;
         Y1 *= c->yuv2rgb_y_coeff;
         Y2 *= c->yuv2rgb_y_coeff;
-        Y1 += 1 << 13;
-        Y2 += 1 << 13;
+        Y1 += (1 << 13) - (1 << 29);
+        Y2 += (1 << 13) - (1 << 29);
 
         R = V * c->yuv2rgb_v2r_coeff;
         G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
@@ -901,20 +901,20 @@
             A2 += 1 << 13;
         }
 
-        output_pixel(&dest0, av_clip_uintp2(R_B + Y1, 30) >> 14);
-        output_pixel(&dest1, av_clip_uintp2(  G + Y1, 30) >> 14);
-        output_pixel(&dest2, av_clip_uintp2(B_R + Y1, 30) >> 14);
+        output_pixel(&dest0, av_clip_uintp2(((R_B + Y1) >> 14) + (1<<15), 16));
+        output_pixel(&dest1, av_clip_uintp2(((  G + Y1) >> 14) + (1<<15), 16));
+        output_pixel(&dest2, av_clip_uintp2(((B_R + Y1) >> 14) + (1<<15), 16));
         if (eightbytes) {
             output_pixel(&dest3, av_clip_uintp2(A1      , 30) >> 14);
-            output_pixel(&dest4, av_clip_uintp2(R_B + Y2, 30) >> 14);
-            output_pixel(&dest5, av_clip_uintp2(  G + Y2, 30) >> 14);
-            output_pixel(&dest6, av_clip_uintp2(B_R + Y2, 30) >> 14);
+            output_pixel(&dest4, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest5, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest6, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
             output_pixel(&dest7, av_clip_uintp2(A2      , 30) >> 14);
             dest += 8;
         } else {
-            output_pixel(&dest3, av_clip_uintp2(R_B + Y2, 30) >> 14);
-            output_pixel(&dest4, av_clip_uintp2(  G + Y2, 30) >> 14);
-            output_pixel(&dest5, av_clip_uintp2(B_R + Y2, 30) >> 14);
+            output_pixel(&dest3, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest4, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+            output_pixel(&dest5, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
             dest += 6;
         }
     }
@@ -942,8 +942,8 @@
             Y2 -= c->yuv2rgb_y_offset;
             Y1 *= c->yuv2rgb_y_coeff;
             Y2 *= c->yuv2rgb_y_coeff;
-            Y1 += 1 << 13;
-            Y2 += 1 << 13;
+            Y1 += (1 << 13) - (1 << 29);
+            Y2 += (1 << 13) - (1 << 29);
 
             if (hasAlpha) {
                 A1 = abuf0i * 2     << 11;
@@ -957,20 +957,20 @@
             G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
             B =                            U * c->yuv2rgb_u2b_coeff;
 
-            output_pixel(&dest0, av_clip_uintp2(R_B + Y1, 30) >> 14);
-            output_pixel(&dest1, av_clip_uintp2(  G + Y1, 30) >> 14);
-            output_pixel(&dest2, av_clip_uintp2(B_R + Y1, 30) >> 14);
+            output_pixel(&dest0, av_clip_uintp2(((R_B + Y1) >> 14) + (1<<15), 16));
+            output_pixel(&dest1, av_clip_uintp2(((  G + Y1) >> 14) + (1<<15), 16));
+            output_pixel(&dest2, av_clip_uintp2(((B_R + Y1) >> 14) + (1<<15), 16));
             if (eightbytes) {
                 output_pixel(&dest3, av_clip_uintp2(A1      , 30) >> 14);
-                output_pixel(&dest4, av_clip_uintp2(R_B + Y2, 30) >> 14);
-                output_pixel(&dest5, av_clip_uintp2(  G + Y2, 30) >> 14);
-                output_pixel(&dest6, av_clip_uintp2(B_R + Y2, 30) >> 14);
+                output_pixel(&dest4, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest5, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest6, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
                 output_pixel(&dest7, av_clip_uintp2(A2      , 30) >> 14);
                 dest += 8;
             } else {
-                output_pixel(&dest3, av_clip_uintp2(R_B + Y2, 30) >> 14);
-                output_pixel(&dest4, av_clip_uintp2(  G + Y2, 30) >> 14);
-                output_pixel(&dest5, av_clip_uintp2(B_R + Y2, 30) >> 14);
+                output_pixel(&dest3, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest4, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest5, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
                 dest += 6;
             }
         }
@@ -988,8 +988,8 @@
             Y2 -= c->yuv2rgb_y_offset;
             Y1 *= c->yuv2rgb_y_coeff;
             Y2 *= c->yuv2rgb_y_coeff;
-            Y1 += 1 << 13;
-            Y2 += 1 << 13;
+            Y1 += (1 << 13) - (1 << 29);
+            Y2 += (1 << 13) - (1 << 29);
 
             if (hasAlpha) {
                 A1 = abuf0i * 2     << 11;
@@ -1003,20 +1003,20 @@
             G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
             B =                            U * c->yuv2rgb_u2b_coeff;
 
-            output_pixel(&dest0, av_clip_uintp2(R_B + Y1, 30) >> 14);
-            output_pixel(&dest1, av_clip_uintp2(  G + Y1, 30) >> 14);
-            output_pixel(&dest2, av_clip_uintp2(B_R + Y1, 30) >> 14);
+            output_pixel(&dest0, av_clip_uintp2(((R_B + Y1) >> 14) + (1<<15), 16));
+            output_pixel(&dest1, av_clip_uintp2(((  G + Y1) >> 14) + (1<<15), 16));
+            output_pixel(&dest2, av_clip_uintp2(((B_R + Y1) >> 14) + (1<<15), 16));
             if (eightbytes) {
                 output_pixel(&dest3, av_clip_uintp2(A1      , 30) >> 14);
-                output_pixel(&dest4, av_clip_uintp2(R_B + Y2, 30) >> 14);
-                output_pixel(&dest5, av_clip_uintp2(  G + Y2, 30) >> 14);
-                output_pixel(&dest6, av_clip_uintp2(B_R + Y2, 30) >> 14);
+                output_pixel(&dest4, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest5, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest6, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
                 output_pixel(&dest7, av_clip_uintp2(A2      , 30) >> 14);
                 dest += 8;
             } else {
-                output_pixel(&dest3, av_clip_uintp2(R_B + Y2, 30) >> 14);
-                output_pixel(&dest4, av_clip_uintp2(  G + Y2, 30) >> 14);
-                output_pixel(&dest5, av_clip_uintp2(B_R + Y2, 30) >> 14);
+                output_pixel(&dest3, av_clip_uintp2(((R_B + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest4, av_clip_uintp2(((  G + Y2) >> 14) + (1<<15), 16));
+                output_pixel(&dest5, av_clip_uintp2(((B_R + Y2) >> 14) + (1<<15), 16));
                 dest += 6;
             }
         }
@@ -1067,7 +1067,7 @@
         // 8bit: 27 -> 17bit, 16bit: 31 - 14 = 17bit
         Y -= c->yuv2rgb_y_offset;
         Y *= c->yuv2rgb_y_coeff;
-        Y += 1 << 13; // 21
+        Y += (1 << 13) - (1<<29); // 21
         // 8bit: 17 + 13bit = 30bit, 16bit: 17 + 13bit = 30bit
 
         R = V * c->yuv2rgb_v2r_coeff;
@@ -1075,9 +1075,9 @@
         B =                            U * c->yuv2rgb_u2b_coeff;
 
         // 8bit: 30 - 22 = 8bit, 16bit: 30bit - 14 = 16bit
-        output_pixel(&dest0, av_clip_uintp2(R_B + Y, 30) >> 14);
-        output_pixel(&dest1, av_clip_uintp2(  G + Y, 30) >> 14);
-        output_pixel(&dest2, av_clip_uintp2(B_R + Y, 30) >> 14);
+        output_pixel(&dest0, av_clip_uintp2(((R_B + Y)>>14) + (1<<15), 16));
+        output_pixel(&dest1, av_clip_uintp2(((  G + Y)>>14) + (1<<15), 16));
+        output_pixel(&dest2, av_clip_uintp2(((B_R + Y)>>14) + (1<<15), 16));
         if (eightbytes) {
             output_pixel(&dest3, av_clip_uintp2(A, 30) >> 14);
             dest += 4;
@@ -1115,7 +1115,7 @@
 
         Y -= c->yuv2rgb_y_offset;
         Y *= c->yuv2rgb_y_coeff;
-        Y += 1 << 13;
+        Y += (1 << 13) - (1 << 29);
 
         R = V * c->yuv2rgb_v2r_coeff;
         G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
@@ -1127,9 +1127,9 @@
             A += 1 << 13;
         }
 
-        output_pixel(&dest0, av_clip_uintp2(R_B + Y, 30) >> 14);

ffmpeg-3-3.4.12.tar.xz/tests/ref/seek/vsynth_lena-snow -> ffmpeg-3-3.4.13.tar.xz/tests/ref/seek/vsynth_lena-snow Changed

@@ -2,45 +2,45 @@
 ret: 0         st:-1 flags:0  ts:-1.000000
 ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size:  3035
 ret: 0         st:-1 flags:1  ts: 1.894167
-ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39806 size:  3640
+ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39690 size:  3640
 ret: 0         st: 0 flags:0  ts: 0.800000
-ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27442 size:  3494
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27382 size:  3493
 ret:-1         st: 0 flags:1  ts:-0.320000
 ret:-1         st:-1 flags:0  ts: 2.576668
 ret: 0         st:-1 flags:1  ts: 1.470835
-ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39806 size:  3640
+ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39690 size:  3640
 ret: 0         st: 0 flags:0  ts: 0.360000
-ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16134 size:  3244
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16074 size:  3245
 ret:-1         st: 0 flags:1  ts:-0.760000
 ret:-1         st:-1 flags:0  ts: 2.153336
 ret: 0         st:-1 flags:1  ts: 1.047503
-ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27442 size:  3494
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27382 size:  3493
 ret: 0         st: 0 flags:0  ts:-0.040000
 ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size:  3035
 ret: 0         st: 0 flags:1  ts: 2.840000
-ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52608 size:  3582
+ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52538 size:  3582
 ret: 0         st:-1 flags:0  ts: 1.730004
-ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52608 size:  3582
+ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52538 size:  3582
 ret: 0         st:-1 flags:1  ts: 0.624171
-ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16134 size:  3244
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16074 size:  3245
 ret: 0         st: 0 flags:0  ts:-0.480000
 ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size:  3035
 ret: 0         st: 0 flags:1  ts: 2.400000
-ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52608 size:  3582
+ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52538 size:  3582
 ret: 0         st:-1 flags:0  ts: 1.306672
-ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39806 size:  3640
+ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39690 size:  3640
 ret: 0         st:-1 flags:1  ts: 0.200839
 ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size:  3035
 ret: 0         st: 0 flags:0  ts:-0.920000
 ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size:  3035
 ret: 0         st: 0 flags:1  ts: 2.000000
-ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52608 size:  3582
+ret: 0         st: 0 flags:1 dts: 1.920000 pts: 1.920000 pos:  52538 size:  3582
 ret: 0         st:-1 flags:0  ts: 0.883340
-ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27442 size:  3494
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:  27382 size:  3493
 ret:-1         st:-1 flags:1  ts:-0.222493
 ret:-1         st: 0 flags:0  ts: 2.680000
 ret: 0         st: 0 flags:1  ts: 1.560000
-ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39806 size:  3640
+ret: 0         st: 0 flags:1 dts: 1.440000 pts: 1.440000 pos:  39690 size:  3640
 ret: 0         st:-1 flags:0  ts: 0.460008
-ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16134 size:  3244
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:  16074 size:  3245
 ret:-1         st:-1 flags:1  ts:-0.645825

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth1-snow -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth1-snow Changed

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth1-snow-hpel -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth1-snow-hpel Changed

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth2-snow -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth2-snow Changed

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth2-snow-hpel -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth2-snow-hpel Changed

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth_lena-snow -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth_lena-snow Changed

ffmpeg-3-3.4.12.tar.xz/tests/ref/vsynth/vsynth_lena-snow-hpel -> ffmpeg-3-3.4.13.tar.xz/tests/ref/vsynth/vsynth_lena-snow-hpel Changed

Changes of Revision 3