@@ -1,4 +1,8 @@

 -------------------------------------------------------------------

+Tue Jun 24 2014 - joerg.lorenzen@ki.tng.de

+- update internal ffmpeg to version 1.2.7

+

+-------------------------------------------------------------------

 Fri Mar 14 2014 - joerg.lorenzen@ki.tng.de

 - Update to version 2.6.8

   * Image/export: Proper initialization of Qz for jpeg export

​

@@ -16,7 +16,7 @@

 #

-%define         ffmpeg_version 1.2.6

+%define         ffmpeg_version 1.2.7

 Name:           avidemux3

 Summary:        Graphical video editing and transcoding tool

​

@@ -1,1 +1,1 @@

-1.2.6

+1.2.7

​

@@ -1,1 +1,1 @@

-1.2.6

+1.2.7

​

@@ -3915,7 +3915,7 @@

 enabled libiec61883 && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883

 enabled libaacplus && require  "libaacplus >= 2.0.0" aacplus.h aacplusEncOpen -laacplus

 enabled libass     && require_pkg_config libass ass/ass.h ass_library_init

-enabled libbluray  && require libbluray libbluray/bluray.h bd_open -lbluray

+enabled libbluray  && require_pkg_config libbluray libbluray/bluray.h bd_open

 enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0 &&

                       { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||

                         die "ERROR: libcelt must be installed and version must be >= 0.11.0."; }

​

@@ -31,7 +31,7 @@

 # This could be handy for archiving the generated documentation or

 # if some version control system is used.

-PROJECT_NUMBER         = 1.2.6

+PROJECT_NUMBER         = 1.2.7

 # With the PROJECT_LOGO tag one can specify an logo or icon that is included

 # in the documentation. The maximum height of the logo should not exceed 55

​

@@ -43,12 +43,15 @@

         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(target);

         int has_alpha = desc ? desc->nb_components % 2 == 0 : 0;

         enum AVPixelFormat best= AV_PIX_FMT_NONE;

+        const enum AVPixelFormat mjpeg_formats[] = { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_NONE };

+        const enum AVPixelFormat ljpeg_formats[] = { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUV420P,

+                                                     AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };

+

         if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {

             if (st->codec->codec_id == AV_CODEC_ID_MJPEG) {

-                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_NONE };

+                p = mjpeg_formats;

             } else if (st->codec->codec_id == AV_CODEC_ID_LJPEG) {

-                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUV420P,

-                                                 AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };

+                p =ljpeg_formats;

             }

         }

         for (; *p != AV_PIX_FMT_NONE; p++) {

​

@@ -203,6 +203,7 @@

                 vald /= pow(10, index * 3);

                 prefix_string = decimal_unit_prefixes[index];

             }

+            vali = vald;

         }

         if (show_float || (use_value_prefix && vald != (long long int)vald))

​

@@ -81,7 +81,7 @@

     INTENSITY_BT   = 15,    ///< Scalefactor data are intensity stereo positions.

 };

-#define IS_CODEBOOK_UNSIGNED(x) ((x - 1) & 10)

+#define IS_CODEBOOK_UNSIGNED(x) (((x) - 1) & 10)

 enum ChannelPosition {

     AAC_CHANNEL_OFF   = 0,

​

@@ -449,9 +449,11 @@

  * @param[out] coded_samples set to the number of samples as coded in the

  *                           packet, or 0 if the codec does not encode the

  *                           number of samples in each frame.

+ * @param[out] approx_nb_samples set to non-zero if the number of samples

+ *                               returned is an approximation.

  */

 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,

-                          int buf_size, int *coded_samples)

+                          int buf_size, int *coded_samples, int *approx_nb_samples)

 {

     ADPCMDecodeContext *s = avctx->priv_data;

     int nb_samples        = 0;

@@ -460,6 +462,7 @@

     int header_size;

     *coded_samples = 0;

+    *approx_nb_samples = 0;

     if(ch <= 0)

         return 0;

@@ -530,10 +533,12 @@

         case AV_CODEC_ID_ADPCM_EA_R2:

             header_size    = 4 + 5 * ch;

             *coded_samples = bytestream2_get_le32(gb);

+            *approx_nb_samples = 1;

             break;

         case AV_CODEC_ID_ADPCM_EA_R3:

             header_size    = 4 + 5 * ch;

             *coded_samples = bytestream2_get_be32(gb);

+            *approx_nb_samples = 1;

             break;

         }

         *coded_samples -= *coded_samples % 28;

@@ -625,11 +630,11 @@

     int16_t **samples_p;

     int st; /* stereo */

     int count1, count2;

-    int nb_samples, coded_samples, ret;

+    int nb_samples, coded_samples, approx_nb_samples, ret;

     GetByteContext gb;

     bytestream2_init(&gb, buf, buf_size);

-    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);

+    nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);

     if (nb_samples <= 0) {

         av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");

         return AVERROR_INVALIDDATA;

@@ -647,7 +652,7 @@

     /* use coded_samples when applicable */

     /* it is always <= nb_samples, so the output buffer will be large enough */

     if (coded_samples) {

-        if (coded_samples != nb_samples)

+        if (!approx_nb_samples && coded_samples != nb_samples)

             av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");

         frame->nb_samples = nb_samples = coded_samples;

     }

@@ -863,6 +868,9 @@

             *samples++ = c->status[0].predictor + c->status[1].predictor;

             *samples++ = c->status[0].predictor - c->status[1].predictor;

         }

+

+        if ((bytestream2_tell(&gb) & 1))

+            bytestream2_skip(&gb, 1);

         break;

     }

     case AV_CODEC_ID_ADPCM_IMA_ISS:

​

@@ -557,10 +557,11 @@

             put_bits(&pb, 7,  status->step_index);

             if (avctx->trellis > 0) {

                 uint8_t buf[64];

-                adpcm_compress_trellis(avctx, &samples_p[ch][1], buf, status,

+                adpcm_compress_trellis(avctx, &samples_p[ch][0], buf, status,

                                        64, 1);

                 for (i = 0; i < 64; i++)

                     put_bits(&pb, 4, buf[i ^ 1]);

+                status->prev_sample = status->predictor;

             } else {

                 for (i = 0; i < 64; i += 2) {

                     int t1, t2;

​

@@ -284,7 +284,7 @@

     GetBitContext gb;

     uint64_t ht_size;

     int i, config_offset;

-    MPEG4AudioConfig m4ac;

+    MPEG4AudioConfig m4ac = {0};

     ALSSpecificConfig *sconf = &ctx->sconf;

     AVCodecContext *avctx    = ctx->avctx;

     uint32_t als_id, header_size, trailer_size;

​

@@ -28,6 +28,7 @@

 #ifndef AVCODEC_DIRAC_ARITH_H

 #define AVCODEC_DIRAC_ARITH_H

+#include "libavutil/x86/asm.h"

 #include "bytestream.h"

 #include "get_bits.h"

@@ -134,7 +135,7 @@

     range_times_prob = (c->range * prob_zero) >> 16;

-#if HAVE_FAST_CMOV && HAVE_INLINE_ASM

+#if HAVE_FAST_CMOV && HAVE_INLINE_ASM && HAVE_6REGS

     low   -= range_times_prob << 16;

     range -= range_times_prob;

     bit = 0;

​

@@ -201,6 +201,7 @@

     uint16_t *mctmp;            /* buffer holding the MC data multipled by OBMC weights */

     uint8_t *mcscratch;

+    int buffer_stride;

     DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];

@@ -343,19 +344,41 @@

             return AVERROR(ENOMEM);

     }

-    w = s->source.width;

-    h = s->source.height;

-

     /* fixme: allocate using real stride here */

-    s->sbsplit  = av_malloc(sbwidth * sbheight);

-    s->blmotion = av_malloc(sbwidth * sbheight * 16 * sizeof(*s->blmotion));

-    s->edge_emu_buffer_base = av_malloc((w+64)*MAX_BLOCKSIZE);

+    s->sbsplit  = av_malloc_array(sbwidth, sbheight);

+    s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));

+

+    if (!s->sbsplit || !s->blmotion)

+        return AVERROR(ENOMEM);

+    return 0;

+}

+

+static int alloc_buffers(DiracContext *s, int stride)

+{

+    int w = s->source.width;

+    int h = s->source.height;

+

+    av_assert0(stride >= w);

+    stride += 64;

+

+    if (s->buffer_stride >= stride)

+        return 0;

+    s->buffer_stride = 0;

+

+    av_freep(&s->edge_emu_buffer_base);

+    memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));

+    av_freep(&s->mctmp);

+    av_freep(&s->mcscratch);

-    s->mctmp     = av_malloc((w+64+MAX_BLOCKSIZE) * (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));

-    s->mcscratch = av_malloc((w+64)*MAX_BLOCKSIZE);

+    s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE);

-    if (!s->sbsplit || !s->blmotion || !s->mctmp || !s->mcscratch)

+    s->mctmp     = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));

+    s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE);

+

+    if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)

         return AVERROR(ENOMEM);

+

+    s->buffer_stride = stride;

     return 0;

 }

@@ -382,6 +405,7 @@

         av_freep(&s->plane[i].idwt_tmp);

     }

+    s->buffer_stride = 0;

     av_freep(&s->sbsplit);

     av_freep(&s->blmotion);

     av_freep(&s->edge_emu_buffer_base);

@@ -1343,8 +1367,8 @@

         motion_y >>= s->chroma_y_shift;

     }

-    mx         = motion_x & ~(-1 << s->mv_precision);

-    my         = motion_y & ~(-1 << s->mv_precision);

+    mx         = motion_x & ~(-1U << s->mv_precision);

+    my         = motion_y & ~(-1U << s->mv_precision);

     motion_x >>= s->mv_precision;

     motion_y >>= s->mv_precision;

     /* normalize subpel coordinates to epel */

@@ -1818,6 +1842,9 @@

         s->plane[1].stride = pic->avframe.linesize[1];

         s->plane[2].stride = pic->avframe.linesize[2];

+        if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)

+            return AVERROR(ENOMEM);

+

         /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */

         if (dirac_decode_picture_header(s))

             return -1;

​

@@ -2288,7 +2288,8 @@

     if (p->cur_rate == RATE_6300) {

         info_bits = 0;

         put_bits(&pb, 2, info_bits);

-    }

+    }else

+        av_assert0(0);

     put_bits(&pb, 8, p->lsp_index[2]);

     put_bits(&pb, 8, p->lsp_index[1]);

​

@@ -58,7 +58,7 @@

         }

     }

-#define EXTEND(i) (i << 3 | i & 7)

+#define EXTEND(i) ((i) << 3 | (i) & 7)

     init_put_bits(&pb, temp, SIZE);

     for (i = 0; i < COUNT; i++)

         set_ue_golomb(&pb, EXTEND(i));

​

@@ -721,10 +721,10 @@

         }

         if(startcode_found){

-            av_fast_malloc(

+            av_fast_padded_mallocz(

                 &s->bitstream_buffer,

                 &s->allocated_bitstream_buffer_size,

-                buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);

+                buf_size - current_pos);

             if (!s->bitstream_buffer)

                 return AVERROR(ENOMEM);

             memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);

​

@@ -3094,6 +3094,18 @@

     return 0;

 }

+static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)

+{

+    switch (a) {

+    case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;

+    case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;

+    case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;

+    default:

+        return a;

+    }

+}

+

+

 /**

  * Decode a slice header.

  * This will also call ff_MPV_common_init() and frame_start() as needed.

@@ -3212,7 +3224,7 @@

                      || h->mb_width  != h->sps.mb_width

                      || h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag)

                     ));

-    if (h0->avctx->pix_fmt != get_pixel_format(h0, 0))

+    if (non_j_pixfmt(h0->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h0, 0)))

         must_reinit = 1;

     h->mb_width  = h->sps.mb_width;

​

@@ -154,7 +154,7 @@

             goto fail;

         /* prepend only to the first type 5 NAL unit of an IDR picture */

-        if (ctx->first_idr && unit_type == 5) {

+        if (ctx->first_idr && (unit_type == 5 || unit_type == 7 || unit_type == 8)) {

             if ((ret=alloc_and_copy(poutbuf, poutbuf_size,

                                avctx->extradata, avctx->extradata_size,

                                buf, nal_size)) < 0)

​

@@ -362,7 +362,8 @@

             avctx->delay              = duration;

             av_assert0(!s->afq.remaining_delay);

             s->afq.frames->duration  += duration;

-            s->afq.frames->pts       -= duration;

+            if (s->afq.frames->pts != AV_NOPTS_VALUE)

+                s->afq.frames->pts       -= duration;

             s->afq.remaining_samples += duration;

         }

         ff_af_queue_remove(&s->afq, duration, &avpkt->pts, &avpkt->duration);

​

@@ -343,19 +343,6 @@

     OPT_STR("level", x4->level);

-    if(x4->x264opts){

-        const char *p= x4->x264opts;

-        while(p){

-            char param[256]={0}, val[256]={0};

-            if(sscanf(p, "%255[^:=]=%255[^:]", param, val) == 1){

-                OPT_STR(param, "1");

-            }else

-                OPT_STR(param, val);

-            p= strchr(p, ':');

-            p+=!!p;

-        }

-    }

-

     if (avctx->i_quant_factor > 0)

         x4->params.rc.f_ip_factor         = 1 / fabs(avctx->i_quant_factor);

@@ -525,6 +512,19 @@

     if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER)

         x4->params.b_repeat_headers = 0;

+    if(x4->x264opts){

+        const char *p= x4->x264opts;

+        while(p){

+            char param[256]={0}, val[256]={0};

+            if(sscanf(p, "%255[^:=]=%255[^:]", param, val) == 1){

+                OPT_STR(param, "1");

+            }else

+                OPT_STR(param, val);

+            p= strchr(p, ':');

+            p+=!!p;

+        }

+    }

+

     if (x4->x264_params) {

         AVDictionary *dict    = NULL;

         AVDictionaryEntry *en = NULL;

​

@@ -1144,7 +1144,7 @@

     }

     if (!Al) {

-        s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);

+        s->coefs_finished[c] |= (2LL << se) - (1LL << ss);

         last_scan = !~s->coefs_finished[c];

     }

​

@@ -454,7 +454,7 @@

         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);

 }

-void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64])

+void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])

 {

     int i;

     if (s->chroma_format == CHROMA_444) {

​

@@ -56,6 +56,6 @@

 void ff_mjpeg_encode_stuffing(MpegEncContext *s);

 void ff_mjpeg_encode_dc(MpegEncContext *s, int val,

                         uint8_t *huff_size, uint16_t *huff_code);

-void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64]);

+void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64]);

 #endif /* AVCODEC_MJPEGENC_H */

​

@@ -813,7 +813,7 @@

     return 0;

 }

-#define MSB_MASK(bits)  (-1u << bits)

+#define MSB_MASK(bits)  (-1u << (bits))

 /** Generate PCM samples using the prediction filters and residual values

  *  read from the data stream, and update the filter state. */

​

@@ -118,6 +118,9 @@

         uint8_t *buf = avpkt->data + (avctx->height-1)*istride;

         int i, j;

+        if (linesize < 0)

+            return linesize;

+

         for (i = 0; i < avctx->height; i++) {

             if (avctx->bits_per_coded_sample == 4) {

                 for (j = 0; j < avctx->width - 1; j += 2) {

​

@@ -84,8 +84,8 @@

     blk[6 * step] = (-(t3 + t7) + t8 + tA) >> shift;                \

     blk[7 * step] = (-(t1 + t6) + t9 + tB) >> shift;                \

-#define SOP_ROW(a) ((a) << 16) + 0x2000

-#define SOP_COL(a) ((a + 32) << 16)

+#define SOP_ROW(a) (((a) << 16) + 0x2000)

+#define SOP_COL(a) (((a) + 32) << 16)

 void ff_mss34_dct_put(uint8_t *dst, int stride, int *block)

 {

​

@@ -363,7 +363,7 @@

     return prev[component];

 }

-#define MKVAL(vals)  (vals[0] | (vals[1] << 3) | (vals[2] << 6))

+#define MKVAL(vals)  ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))

 /* Image mode - the hardest to comprehend MSS4 coding mode.

  *

​

@@ -70,7 +70,7 @@

         code += 0x80000000u >> (he[i].len - 1);

     }

-    return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 9), last + 1,

+    return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,

                               bits,  sizeof(*bits),  sizeof(*bits),

                               codes, sizeof(*codes), sizeof(*codes),

                               syms,  sizeof(*syms),  sizeof(*syms), 0);

​

@@ -1867,9 +1867,10 @@

     uvmx = (mx + ((mx & 3) == 3)) >> 1;

     uvmy = (my + ((my & 3) == 3)) >> 1;

     if (v->field_mode) {

-        if (v->cur_field_type != v->ref_field_type[1])

+        if (v->cur_field_type != v->ref_field_type[1]) {

             my   = my   - 2 + 4 * v->cur_field_type;

             uvmy = uvmy - 2 + 4 * v->cur_field_type;

+        }

     }

     if (v->fastuvmc) {

         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));

​

@@ -151,7 +151,7 @@

     uint8_t       mode_count;

     vorbis_mode  *modes;

     uint8_t       mode_number; // mode number for the current packet

-    uint8_t       previous_window;

+    int8_t       previous_window;

     float        *channel_residues;

     float        *saved;

 } vorbis_context;

@@ -701,8 +701,7 @@

         res_setup->partition_size = get_bits(gb, 24) + 1;

         /* Validations to prevent a buffer overflow later. */

         if (res_setup->begin>res_setup->end ||

-            res_setup->end > (res_setup->type == 2 ? vc->audio_channels : 1) * vc->blocksize[1] / 2 ||

-            (res_setup->end-res_setup->begin) / res_setup->partition_size > V_MAX_PARTITIONS) {

+            (res_setup->end-res_setup->begin) / res_setup->partition_size > FFMIN(V_MAX_PARTITIONS, 65535)) {

             av_log(vc->avctx, AV_LOG_ERROR,

                    "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",

                    res_setup->type, res_setup->begin, res_setup->end,

@@ -989,7 +988,7 @@

     if (!vc->channel_residues || !vc->saved)

         return AVERROR(ENOMEM);

-    vc->previous_window  = 0;

+    vc->previous_window  = -1;

     ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);

     ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);

@@ -1325,6 +1324,7 @@

     uint8_t *classifs = vr->classifs;

     unsigned pass, ch_used, i, j, k, l;

     unsigned max_output = (ch - 1) * vlen;

+    int libvorbis_bug = 0;

     if (vr_type == 2) {

         for (j = 1; j < ch; ++j)

@@ -1339,8 +1339,13 @@

     }

     if (max_output > ch_left * vlen) {

-        av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");

-        return -1;

+        if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {

+            ptns_to_read--;

+            libvorbis_bug = 1;

+        } else {

+            av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");

+            return AVERROR_INVALIDDATA;

+        }

     }

     av_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);

@@ -1466,6 +1471,14 @@

                 voffset += vr->partition_size;

             }

         }

+        if (libvorbis_bug && !pass) {

+            for (j = 0; j < ch_used; ++j) {

+                if (!do_not_decode[j]) {

+                    get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,

+                                vc->codebooks[vr->classbook].nb_bits, 3);

+                }

+            }

+        }

     }

     return 0;

 }

@@ -1518,7 +1531,7 @@

 {

     GetBitContext *gb = &vc->gb;

     FFTContext *mdct;

-    unsigned previous_window = vc->previous_window;

+    int previous_window = vc->previous_window;

     unsigned mode_number, blockflag, blocksize;

     int i, j;

     uint8_t no_residue[255];

@@ -1551,9 +1564,11 @@

     blocksize = vc->blocksize[blockflag];

     vlen = blocksize / 2;

     if (blockflag) {

-        previous_window = get_bits(gb, 1);

-        skip_bits1(gb); // next_window

-    }

+        int code = get_bits(gb, 2);

+        if (previous_window < 0)

+            previous_window = code>>1;

+    } else if (previous_window < 0)

+        previous_window = 0;

     memset(ch_res_ptr,   0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?

     for (i = 0; i < vc->audio_channels; ++i)

@@ -1783,7 +1798,7 @@

         memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *

                              sizeof(*vc->saved));

     }

-    vc->previous_window = 0;

+    vc->previous_window = -1;

 }

 AVCodec ff_vorbis_decoder = {

​

@@ -385,9 +385,9 @@

     }

     for (i = 0; i < 2; i++) {

         ff_free_vlc(&s->coef_vlc[i]);

-        av_free(s->run_table[i]);

-        av_free(s->level_table[i]);

-        av_free(s->int_table[i]);

+        av_freep(&s->run_table[i]);

+        av_freep(&s->level_table[i]);

+        av_freep(&s->int_table[i]);

     }

 #if FF_API_OLD_ENCODE_AUDIO

​

@@ -343,7 +343,7 @@

     "movdqa   %%xmm6, 4*16("dct")     \n\t" \

     "movdqa   "SREG2", 7*16("dct")    \n\t"

-inline void ff_idct_xvid_sse2(short *block)

+av_extern_inline void ff_idct_xvid_sse2(short *block)

 {

     __asm__ volatile(

     "movq     "MANGLE(m127)", %%mm0                              \n\t"

​

@@ -216,7 +216,7 @@

         "psubusw "MM"1, "MM"4               \n\t"

         "packuswb "MM"4, "MM"4              \n\t"

 #if COMPILE_TEMPLATE_SSE2

-        "packuswb "MM"4, "MM"4              \n\t"

+        "packsswb "MM"4, "MM"4              \n\t"

 #endif

         "movd "MM"4, %0                     \n\t" // *overflow

         : "=g" (*overflow)

​

@@ -38,7 +38,7 @@

             for (j = 0; j < fmts->format_count; j++)                    \

                 if(av_get_pix_fmt_name(fmts->formats[j]))               \

                 printf(#INOUT "PUT[%d] %s: fmt:%s\n",                   \

-                       i, filter_ctx->filter->inout##puts[i].name,      \

+                       i, filter_ctx->inout##put_pads[i].name,      \

                        av_get_pix_fmt_name(fmts->formats[j]));          \

         } else if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_AUDIO) { \

             AVFilterFormats *fmts;                                      \

@@ -47,7 +47,7 @@

             fmts = filter_ctx->inout##puts[i]->outin##_formats;         \

             for (j = 0; j < fmts->format_count; j++)                    \

                 printf(#INOUT "PUT[%d] %s: fmt:%s\n",                   \

-                       i, filter_ctx->filter->inout##puts[i].name,      \

+                       i, filter_ctx->inout##put_pads[i].name,      \

                        av_get_sample_fmt_name(fmts->formats[j]));       \

                                                                         \

             layouts = filter_ctx->inout##puts[i]->outin##_channel_layouts; \

@@ -56,7 +56,7 @@

                 av_get_channel_layout_string(buf, sizeof(buf), -1,      \

                                              layouts->channel_layouts[j]);         \

                 printf(#INOUT "PUT[%d] %s: chlayout:%s\n",              \

-                       i, filter_ctx->filter->inout##puts[i].name, buf); \

+                       i, filter_ctx->inout##put_pads[i].name, buf); \

             }                                                           \

         }                                                               \

     }                                                                   \

@@ -106,12 +106,12 @@

     /* create a link for each of the input pads */

     for (i = 0; i < filter_ctx->input_count; i++) {

         AVFilterLink *link = av_mallocz(sizeof(AVFilterLink));

-        link->type = filter_ctx->filter->inputs[i].type;

+        link->type = filter_ctx->input_pads[i].type;

         filter_ctx->inputs[i] = link;

     }

     for (i = 0; i < filter_ctx->output_count; i++) {

         AVFilterLink *link = av_mallocz(sizeof(AVFilterLink));

-        link->type = filter_ctx->filter->outputs[i].type;

+        link->type = filter_ctx->output_pads[i].type;

         filter_ctx->outputs[i] = link;

     }

​

@@ -31,9 +31,10 @@

 {

     char *format;

     char layout[64];

+    AVBPrint dummy_buffer = { 0 };

     if (!buf)

-        buf = &(AVBPrint){ 0 }; /* dummy buffer */

+        buf = &dummy_buffer;

     switch (link->type) {

         case AVMEDIA_TYPE_VIDEO:

             format = av_x_if_null(av_get_pix_fmt_name(link->format), "?");

​

@@ -346,8 +346,8 @@

         //av_log(NULL, AV_LOG_ERROR, "\n");

     }

-    p_x = (center_x - width / 2);

-    p_y = (center_y - height / 2);

+    p_x = (center_x - width / 2.0);

+    p_y = (center_y - height / 2.0);

     t->vector.x += (cos(t->angle)-1)*p_x  - sin(t->angle)*p_y;

     t->vector.y += sin(t->angle)*p_x  + (cos(t->angle)-1)*p_y;

​

@@ -378,7 +378,8 @@

     if (!(asf->hdr.flags & 0x01)) { // if we aren't streaming...

         int64_t fsize = avio_size(pb);

-        if (fsize <= 0 || (int64_t)asf->hdr.file_size <= 0 || FFABS(fsize - (int64_t)asf->hdr.file_size) < 10000)

+        if (fsize <= 0 || (int64_t)asf->hdr.file_size <= 0 ||

+            FFABS(fsize - (int64_t)asf->hdr.file_size) / (float)FFMIN(fsize, asf->hdr.file_size) < 0.05)

             st->duration = asf->hdr.play_time /

                        (10000000 / 1000) - start_time;

     }

​

@@ -1002,10 +1002,12 @@

                 }

             }

-

-            if(   (st->discard >= AVDISCARD_DEFAULT && size==0)

-               /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY))*/ //FIXME needs a little reordering

-               || st->discard >= AVDISCARD_ALL){

+            if (!avi->dv_demux &&

+                ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||

+                 // FIXME: needs a little reordering

+                 (st->discard >= AVDISCARD_NONKEY &&

+                 !(pkt->flags & AV_PKT_FLAG_KEY)) */

+                || st->discard >= AVDISCARD_ALL)) {

                 if (!exit_early) {

                     ast->frame_offset += get_duration(ast, size);

                     avio_skip(pb, size);

@@ -1196,7 +1198,7 @@

                 int index;

                 av_assert0(st->index_entries);

-                index= av_index_search_timestamp(st, ast->frame_offset, 0);

+                index= av_index_search_timestamp(st, ast->frame_offset, AVSEEK_FLAG_ANY);

                 e= &st->index_entries[index];

                 if(index >= 0 && e->timestamp == ast->frame_offset){

@@ -1518,7 +1520,7 @@

             continue;

 //        av_assert1(st2->codec->block_align);

-        av_assert0((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);

+        av_assert0(fabs(av_q2d(st2->time_base) - ast2->scale / (double)ast2->rate) < av_q2d(st2->time_base) * 0.00000001);

         index = av_index_search_timestamp(

                 st2,

                 av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),

​

@@ -815,6 +815,10 @@

             if (cts < 0) { // dts are wrong

                 flv->wrong_dts = 1;

                 av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n");

+            } else if (FFABS(dts - pts) > 1000*60*15) {

+                av_log(s, AV_LOG_WARNING,

+                       "invalid timestamps %"PRId64" %"PRId64"\n", dts, pts);

+                dts = pts = AV_NOPTS_VALUE;

             }

             if (flv->wrong_dts)

                 dts = AV_NOPTS_VALUE;

​

@@ -218,6 +218,18 @@

                        avcodec_get_name(enc->codec_id), i);

                 return AVERROR(EINVAL);

             }

+            if (enc->codec_id == AV_CODEC_ID_MPEG4 ||

+                enc->codec_id == AV_CODEC_ID_H263) {

+                int error = enc->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;

+                av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,

+                       "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(enc->codec_id));

+

+                if (error) {

+                    av_log(s, AV_LOG_ERROR,

+                           "use vstrict=-1 / -strict -1 to use it anyway.\n");

+                    return AVERROR(EINVAL);

+                }

+            }

             break;

         case AVMEDIA_TYPE_AUDIO:

             audio_enc = enc;

​

@@ -35,7 +35,7 @@

     for(i=0; i<p->buf_size; i++){

         code = (code<<8) + p->buf[i];

         if ((code & 0xfffffc0000) == 0x800000) {

-            src_fmt= (code>>2)&3;

+            src_fmt= (code>>2)&7;

             if(   src_fmt != last_src_fmt

                && last_src_fmt>0 && last_src_fmt<6

                && src_fmt<6)

​

@@ -1634,8 +1634,12 @@

         } else if (!strcmp(track->codec_id, "V_QUICKTIME")

                    && (track->codec_priv.size >= 86)

                    && (track->codec_priv.data != NULL)) {

-            fourcc = AV_RL32(track->codec_priv.data);

+            fourcc = AV_RL32(track->codec_priv.data + 4);

             codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);

+            if (ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(track->codec_priv.data))) {

+                fourcc = AV_RL32(track->codec_priv.data);

+                codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);

+            }

         } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX-12) {

             /* Only ALAC's magic cookie is stored in Matroska's track headers.

                Create the "atom size", "tag", and "tag version" fields the

​

@@ -501,8 +501,18 @@

         if (qt_id) {

             if (!codec->codec_tag)

                 codec->codec_tag = ff_codec_get_tag(ff_codec_movvideo_tags, codec->codec_id);

-            if (codec->extradata_size)

+            if (codec->extradata_size) {

+                if (   ff_codec_get_id(ff_codec_movvideo_tags, codec->codec_tag) == codec->codec_id

+                    && ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(codec->extradata+4)) != codec->codec_id

+                ) {

+                    int i;

+                    avio_wb32(dyn_cp, 0x5a + codec->extradata_size);

+                    avio_wl32(dyn_cp, codec->codec_tag);

+                    for(i=0; i<0x5a-8; i++)

+                        avio_w8(dyn_cp, 0);

+                }

                 avio_write(dyn_cp, codec->extradata, codec->extradata_size);

+            }

         } else {

             if (!codec->codec_tag)

                 codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id);

​

@@ -1679,7 +1679,7 @@

     if (!entries)

     {

         sc->keyframe_absent = 1;

-        if (!st->need_parsing)

+        if (!st->need_parsing && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)

             st->need_parsing = AVSTREAM_PARSE_HEADERS;

         return 0;

     }

@@ -2017,6 +2017,11 @@

                         rap_group_index++;

                     }

                 }

+                if (sc->keyframe_absent

+                    && !sc->stps_count

+                    && !rap_group_present

+                    && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)

+                     keyframe = 1;

                 if (keyframe)

                     distance = 0;

                 sample_size = sc->alt_sample_size > 0 ? sc->alt_sample_size : sc->sample_sizes[current_sample];

​

@@ -153,7 +153,7 @@

     }

     c->curbits = (curbits + size2) & 0x1F;

-    if ((ret = av_new_packet(pkt, size)) < 0)

+    if ((ret = av_new_packet(pkt, size + 4)) < 0)

         return ret;

     pkt->data[0] = curbits;

​

@@ -1265,7 +1265,7 @@

             AVStream *st;

             if (ts->pids[pid]->es_id != mp4_descr[i].es_id)

                 continue;

-            if (!(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES)) {

+            if (ts->pids[pid]->type != MPEGTS_PES) {

                 av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);

                 continue;

             }

​

@@ -410,6 +410,12 @@

     av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",

             av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);

+    if (pkt->duration < 0 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {

+        av_log(s, AV_LOG_WARNING, "Packet with invalid duration %d in stream %d\n",

+               pkt->duration, pkt->stream_index);

+        pkt->duration = 0;

+    }

+

     /* duration field */

     if (pkt->duration == 0) {

         ff_compute_frame_duration(&num, &den, st, NULL, pkt);

​

@@ -23,6 +23,24 @@

 static int flags, checked;

 void av_force_cpu_flags(int arg){

+    if (   (arg & ( AV_CPU_FLAG_3DNOW    |

+                    AV_CPU_FLAG_3DNOWEXT |

+                    AV_CPU_FLAG_SSE      |

+                    AV_CPU_FLAG_SSE2     |

+                    AV_CPU_FLAG_SSE2SLOW |

+                    AV_CPU_FLAG_SSE3     |

+                    AV_CPU_FLAG_SSE3SLOW |

+                    AV_CPU_FLAG_SSSE3    |

+                    AV_CPU_FLAG_SSE4     |

+                    AV_CPU_FLAG_SSE42    |

+                    AV_CPU_FLAG_AVX      |

+                    AV_CPU_FLAG_XOP      |

+                    AV_CPU_FLAG_FMA4     ))

+        && !(arg & AV_CPU_FLAG_MMX)) {

+        av_log(NULL, AV_LOG_WARNING, "MMX implied by specified flags\n");

+        arg |= AV_CPU_FLAG_MMX;

+    }

+

     flags   = arg;

     checked = arg != -1;

 }

​

@@ -22,6 +22,7 @@

 #include <string.h>

 #include "avutil.h"

+#include "avassert.h"

 #include "common.h"

 #include "intreadwrite.h"

 #include "lzo.h"

@@ -65,8 +66,13 @@

 {

     int cnt = x & mask;

     if (!cnt) {

-        while (!(x = get_byte(c)))

+        while (!(x = get_byte(c))) {

+            if (cnt >= INT_MAX - 1000) {

+                c->error |= AV_LZO_ERROR;

+                break;

+            }

             cnt += 255;

+        }

         cnt += mask + x;

     }

     return cnt;

@@ -80,6 +86,7 @@

 {

     register const uint8_t *src = c->in;

     register uint8_t *dst       = c->out;

+    av_assert0(cnt >= 0);

     if (cnt > c->in_end - src) {

         cnt       = FFMAX(c->in_end - src, 0);

         c->error |= AV_LZO_INPUT_DEPLETED;

@@ -110,9 +117,9 @@

  */

 static inline void copy_backptr(LZOContext *c, int back, int cnt)

 {

-    register const uint8_t *src = &c->out[-back];

     register uint8_t *dst       = c->out;

-    if (src < c->out_start || src > dst) {

+    av_assert0(cnt > 0);

+    if (dst - c->out_start < back) {

         c->error |= AV_LZO_INVALID_BACKPTR;

         return;

     }

​

@@ -1291,8 +1291,10 @@

     for (i = 0; i < ranges->nb_ranges; i++) {

         AVOptionRange *range = ranges->range[i];

-        av_freep(&range->str);

-        av_freep(&ranges->range[i]);

+        if (range) {

+            av_freep(&range->str);

+            av_freep(&ranges->range[i]);

+        }

     }

     av_freep(&ranges->range);

     av_freep(rangesp);

​

@@ -26,6 +26,10 @@

 #include "common.h"

+#if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS) && !defined(PRId64)

+#error missing -D__STDC_FORMAT_MACROS / #define __STDC_FORMAT_MACROS

+#endif

+

 #define AV_TS_MAX_STRING_SIZE 32

 /**

​

@@ -26,7 +26,7 @@

 void swri_get_dither(SwrContext *s, void *dst, int len, unsigned seed, enum AVSampleFormat noise_fmt) {

     double scale = s->dither.noise_scale;

 #define TMP_EXTRA 2

-    double *tmp = av_malloc((len + TMP_EXTRA) * sizeof(double));

+    double *tmp = av_malloc_array(len + TMP_EXTRA, sizeof(double));

     int i;

     for(i=0; i<len + TMP_EXTRA; i++){

​

@@ -122,6 +122,11 @@

     )

         out_ch_layout = AV_CH_LAYOUT_STEREO;

+    if(    in_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX

+       && (out_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0

+    )

+        in_ch_layout = AV_CH_LAYOUT_STEREO;

+

     if(!sane_layout(in_ch_layout)){

         av_get_channel_layout_string(buf, sizeof(buf), -1, s->in_ch_layout);

         av_log(s, AV_LOG_ERROR, "Input channel layout '%s' is not supported\n", buf);

​