@@ -51,7 +51,7 @@ doc/%.1: TAG = MAN

 doc/%.1: doc/%.pod $(GENTEXI)

 	$(M)pod2man --section=1 --center=" " --release=" " $< > $@

-$(DOCS): | doc

+$(DOCS): | doc/

 install-progs-$(CONFIG_DOC): install-man

@@ -1416,7 +1416,7 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts1, int64_

     /* if the frame is not skipped, then display it */

     if (vp->bmp) {

-        AVPicture pict;

+        AVPicture pict = { { 0 } };

 #if CONFIG_AVFILTER

         if (vp->picref)

             avfilter_unref_buffer(vp->picref);

@@ -1426,7 +1426,6 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts1, int64_

         /* get a pointer on the bitmap */

         SDL_LockYUVOverlay (vp->bmp);

-        memset(&pict, 0, sizeof(AVPicture));

         pict.data[0] = vp->bmp->pixels[0];

         pict.data[1] = vp->bmp->pixels[2];

         pict.data[2] = vp->bmp->pixels[1];

@@ -339,8 +339,7 @@ static int resolve_host(struct in_addr *sin_addr, const char *hostname)

     if (!ff_inet_aton(hostname, sin_addr)) {

 #if HAVE_GETADDRINFO

         struct addrinfo *ai, *cur;

-        struct addrinfo hints;

-        memset(&hints, 0, sizeof(hints));

+        struct addrinfo hints = { 0 };

         hints.ai_family = AF_INET;

         if (getaddrinfo(hostname, NULL, &hints, &ai))

             return -1;

@@ -2835,7 +2834,7 @@ static int rtsp_parse_request(HTTPContext *c)

     char protocol[32];

     char line[1024];

     int len;

-    RTSPMessageHeader header1, *header = &header1;

+    RTSPMessageHeader header1 = { 0 }, *header = &header1;

     c->buffer_ptr[0] = '\0';

     p = c->buffer;

@@ -2861,7 +2860,6 @@ static int rtsp_parse_request(HTTPContext *c)

     }

     /* parse each header line */

-    memset(header, 0, sizeof(*header));

     /* skip to next line */

     while (*p != '\n' && *p != '\0')

         p++;

@@ -4664,7 +4662,7 @@ static const OptionDef options[] = {

 int main(int argc, char **argv)

 {

-    struct sigaction sigact;

+    struct sigaction sigact = { { 0 } };

     parse_loglevel(argc, argv, options);

     av_register_all();

@@ -4682,7 +4680,6 @@ int main(int argc, char **argv)

     av_lfg_init(&random_state, av_get_random_seed());

-    memset(&sigact, 0, sizeof(sigact));

     sigact.sa_handler = handle_child_exit;

     sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;

     sigaction(SIGCHLD, &sigact, 0);

@@ -578,7 +578,7 @@ static int decode_i_mb(FourXContext *f)

 static const uint8_t *read_huffman_tables(FourXContext *f,

                                           const uint8_t * const buf, int buf_size)

 {

-    int frequency[512];

+    int frequency[512] = { 0 };

     uint8_t flag[512];

     int up[512];

     uint8_t len_tab[257];

@@ -588,7 +588,6 @@ static const uint8_t *read_huffman_tables(FourXContext *f,

     const uint8_t *ptr_end = buf + buf_size;

     int j;

-    memset(frequency, 0, sizeof(frequency));

     memset(up, -1, sizeof(up));

     start = *ptr++;

@@ -691,10 +690,9 @@ static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)

     for (y = 0; y < height; y += 16) {

         for (x = 0; x < width; x += 16) {

-            unsigned int color[4], bits;

+            unsigned int color[4] = { 0 }, bits;

             if (buf_end - buf < 8)

                 return -1;

-            memset(color, 0, sizeof(color));

             // warning following is purely guessed ...

             color[0] = bytestream2_get_le16u(&g3);

             color[1] = bytestream2_get_le16u(&g3);

@@ -714,7 +714,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,

 {

     int start = 0, i, w, w2, g;

     int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels;

-    float dists[128], uplims[128];

+    float dists[128] = { 0 }, uplims[128];

     float maxvals[128];

     int fflag, minscaler;

     int its  = 0;

@@ -722,7 +722,6 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,

     float minthr = INFINITY;

     //XXX: some heuristic to determine initial quantizers will reduce search time

-    memset(dists, 0, sizeof(dists));

     //determine zero bands and upper limits

     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

         for (g = 0;  g < sce->ics.num_swb; g++) {

@@ -389,9 +389,8 @@ static av_unused FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx,

     AacPsyChannel *pch  = &pctx->ch[channel];

     uint8_t grouping     = 0;

     int next_type        = pch->next_window_seq;

-    FFPsyWindowInfo wi;

+    FFPsyWindowInfo wi  = { { 0 } };

-    memset(&wi, 0, sizeof(wi));

     if (la) {

         float s[8], v;

         int switch_to_eight = 0;

@@ -785,9 +784,8 @@ static FFPsyWindowInfo psy_lame_window(FFPsyContext *ctx, const float *audio,

     int uselongblock = 1;

     int attacks[AAC_NUM_BLOCKS_SHORT + 1] = { 0 };

     int i;

-    FFPsyWindowInfo wi;

+    FFPsyWindowInfo wi = { { 0 } };

-    memset(&wi, 0, sizeof(wi));

     if (la) {

         float hpfsmpl[AAC_BLOCK_SIZE_LONG];

         float const *pf = hpfsmpl;

@@ -753,9 +753,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)

     int downmix_output;

     int cpl_in_use;

     GetBitContext *gbc = &s->gbc;

-    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];

-

-    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

+    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };

     /* block switch flags */

     different_transforms = 0;

@@ -1035,9 +1035,7 @@ static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,

                              unsigned int *js_blocks)

 {

     unsigned int b;

-    ALSBlockData bd;

-

-    memset(&bd, 0, sizeof(ALSBlockData));

+    ALSBlockData bd = { 0 };

     bd.ra_block         = ra_frame;

     bd.const_block      = ctx->const_block;

@@ -1078,9 +1076,7 @@ static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,

     ALSSpecificConfig *sconf = &ctx->sconf;

     unsigned int offset = 0;

     unsigned int b;

-    ALSBlockData bd[2];

-

-    memset(bd, 0, 2 * sizeof(ALSBlockData));

+    ALSBlockData bd[2] = { { 0 } };

     bd[0].ra_block         = ra_frame;

     bd[0].const_block      = ctx->const_block;

@@ -1346,7 +1342,7 @@ static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)

                     sizeof(*ctx->raw_samples[c]) * sconf->max_order);

         }

     } else { // multi-channel coding

-        ALSBlockData   bd;

+        ALSBlockData   bd = { 0 };

         int            b;

         int            *reverted_channels = ctx->reverted_channels;

         unsigned int   offset             = 0;

@@ -1357,7 +1353,6 @@ static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)

                 return -1;

             }

-        memset(&bd,               0, sizeof(ALSBlockData));

         memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);

         bd.ra_block         = ra_frame;

@@ -233,7 +233,7 @@ static void merge(GetBitContext *gb, uint8_t *dst, uint8_t *src, int size)

  */

 static void read_tree(GetBitContext *gb, Tree *tree)

 {

-    uint8_t tmp1[16], tmp2[16], *in = tmp1, *out = tmp2;

+    uint8_t tmp1[16] = { 0 }, tmp2[16], *in = tmp1, *out = tmp2;

     int i, t, len;

     tree->vlc_num = get_bits(gb, 4);

@@ -244,7 +244,6 @@ static void read_tree(GetBitContext *gb, Tree *tree)

     }

     if (get_bits1(gb)) {

         len = get_bits(gb, 3);

-        memset(tmp1, 0, sizeof(tmp1));

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

             tree->syms[i] = get_bits(gb, 4);

             tmp1[tree->syms[i]] = 1;

@@ -47,7 +47,7 @@ static void refill(CABACContext *c){

         c->low+= c->bytestream[0]<<1;

 #endif

     c->low -= CABAC_MASK;

-    c->bytestream+= CABAC_BITS/8;

+    c->bytestream += CABAC_BITS / 8;

 }

 static inline void renorm_cabac_decoder_once(CABACContext *c){

@@ -74,7 +74,7 @@ static void refill2(CABACContext *c){

 #endif

     c->low += x<<i;

-    c->bytestream+= CABAC_BITS/8;

+    c->bytestream += CABAC_BITS/8;

 }

 static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){

@@ -411,10 +411,10 @@ static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_

                        int *category, int *category_index)

 {

     int exp_idx, bias, tmpbias1, tmpbias2, bits_left, num_bits, index, v, i, j;

-    int exp_index2[102];

-    int exp_index1[102];

+    int exp_index2[102] = { 0 };

+    int exp_index1[102] = { 0 };

-    int tmp_categorize_array[128 * 2];

+    int tmp_categorize_array[128 * 2] = { 0 };

     int tmp_categorize_array1_idx = p->numvector_size;

     int tmp_categorize_array2_idx = p->numvector_size;

@@ -426,10 +426,6 @@ static void categorize(COOKContext *q, COOKSubpacket *p, const int *quant_index_

         //av_log(q->avctx, AV_LOG_ERROR, "bits_left = %d\n",bits_left);

     }

-    memset(&exp_index1,           0, sizeof(exp_index1));

-    memset(&exp_index2,           0, sizeof(exp_index2));

-    memset(&tmp_categorize_array, 0, sizeof(tmp_categorize_array));

-

     bias = -32;

     /* Estimate bias. */

@@ -649,14 +645,11 @@ static void decode_vectors(COOKContext *q, COOKSubpacket *p, int *category,

  */

 static int mono_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer)

 {

-    int category_index[128];

+    int category_index[128] = { 0 };

+    int category[128]       = { 0 };

     int quant_index_table[102];

-    int category[128];

     int res, i;

-    memset(&category,       0, sizeof(category));

-    memset(&category_index, 0, sizeof(category_index));

-

     if ((res = decode_envelope(q, p, quant_index_table)) < 0)

         return res;

     q->num_vectors = get_bits(&q->gb, p->log2_numvector_size);

@@ -829,13 +822,12 @@ static int joint_decode(COOKContext *q, COOKSubpacket *p, float *mlt_buffer1,

                         float *mlt_buffer2)

 {

     int i, j, res;

-    int decouple_tab[SUBBAND_SIZE];

+    int decouple_tab[SUBBAND_SIZE] = { 0 };

     float *decode_buffer = q->decode_buffer_0;

     int idx, cpl_tmp;

     float f1, f2;

     const float *cplscale;

-    memset(decouple_tab, 0, sizeof(decouple_tab));

     memset(decode_buffer, 0, sizeof(q->decode_buffer_0));

     /* Make sure the buffers are zeroed out. */

@@ -74,17 +74,11 @@ struct algo {

     int nonspec;

 };

-#ifndef FAAN_POSTSCALE

-#define FAAN_SCALE SCALE_PERM

-#else

-#define FAAN_SCALE NO_PERM

-#endif

-

 static int cpu_flags;

 static const struct algo fdct_tab[] = {

     { "REF-DBL",        ff_ref_fdct,           NO_PERM    },

-    { "FAAN",           ff_faandct,            FAAN_SCALE },

+    { "FAAN",           ff_faandct,            NO_PERM    },

     { "IJG-AAN-INT",    ff_fdct_ifast,         SCALE_PERM },

     { "IJG-LLM-INT",    ff_jpeg_fdct_islow_8,  NO_PERM    },

@@ -323,9 +323,11 @@ av_cold int ff_dvvideo_init(AVCodecContext *avctx)

 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)

 {

     if (!avpriv_dv_codec_profile(avctx)) {

-        av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",

+        av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "

+               "Valid DV profiles are:\n",

                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));

-        return -1;

+        ff_dv_print_profiles(avctx, AV_LOG_ERROR);

+        return AVERROR(EINVAL);

     }

     return ff_dvvideo_init(avctx);

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

 #include "libavutil/rational.h"

 #include "libavutil/intreadwrite.h"

+#include "libavutil/pixdesc.h"

 #include "avcodec.h"

 #include "dvdata.h"

@@ -345,3 +346,14 @@ const DVprofile* avpriv_dv_codec_profile(AVCodecContext* codec)

     return NULL;

 }

+

+void ff_dv_print_profiles(void *logctx, int loglevel)

+{

+    int i;

+    for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++) {

+        const DVprofile *p = &dv_profiles[i];

+        av_log(logctx, loglevel, "Frame size: %dx%d; pixel format: %s, "

+               "framerate: %d/%d\n", p->width, p->height, av_get_pix_fmt_name(p->pix_fmt),

+               p->time_base.den, p->time_base.num);

+    }

+}

@@ -156,4 +156,9 @@ static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chun

      }

 }

+/**

+ *  Print all allowed DV profiles into logctx at specified logging level.

+ */

+void ff_dv_print_profiles(void *logctx, int loglevel);

+

 #endif /* AVCODEC_DVDATA_H */

@@ -43,7 +43,6 @@

 #include "simple_idct.h"

 #include "dvdata.h"

 #include "dvquant.h"

-#include "dv_tablegen.h"

 typedef struct BlockInfo {

     const uint32_t *factor_table;

@@ -135,7 +135,7 @@ static void guess_palette(uint32_t *rgba_palette,

         {0x00, 0x80, 0xff},

         {0x00, 0x55, 0xaa, 0xff},

     };

-    uint8_t color_used[16];

+    uint8_t color_used[16] = { 0 };

     int nb_opaque_colors, i, level, j, r, g, b;

     uint8_t *colormap = ctx->colormap, *alpha = ctx->alpha;

@@ -149,7 +149,6 @@ static void guess_palette(uint32_t *rgba_palette,

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

         rgba_palette[i] = 0;

-    memset(color_used, 0, 16);

     nb_opaque_colors = 0;

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

         if (alpha[i] != 0 && !color_used[colormap[i]]) {

@@ -397,14 +396,13 @@ static int is_transp(const uint8_t *buf, int pitch, int n,

 /* return 0 if empty rectangle, 1 if non empty */

 static int find_smallest_bounding_rectangle(AVSubtitle *s)

 {

-    uint8_t transp_color[256];

+    uint8_t transp_color[256] = { 0 };

     int y1, y2, x1, x2, y, w, h, i;

     uint8_t *bitmap;

     if (s->num_rects == 0 || s->rects == NULL || s->rects[0]->w <= 0 || s->rects[0]->h <= 0)

         return 0;

-    memset(transp_color, 0, 256);

     for(i = 0; i < s->rects[0]->nb_colors; i++) {

         if ((((uint32_t*)s->rects[0]->pict.data[1])[i] >> 24) == 0)

             transp_color[i] = 1;

@@ -86,7 +86,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, MpegEncContext *s,

     struct dxva_context *ctx = avctx->hwaccel_context;

     unsigned               buffer_count = 0;

     DXVA2_DecodeBufferDesc buffer[4];

-    DXVA2_DecodeExecuteParams exec;

+    DXVA2_DecodeExecuteParams exec = { 0 };

     int      result;

     if (FAILED(IDirectXVideoDecoder_BeginFrame(ctx->decoder,

@@ -132,7 +132,6 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, MpegEncContext *s,

     assert(buffer_count == 1 + (qm_size > 0) + 2);

-    memset(&exec, 0, sizeof(exec));

     exec.NumCompBuffers      = buffer_count;

     exec.pCompressedBuffers  = buffer;

     exec.pExtensionData      = NULL;

@@ -29,11 +29,6 @@

 #include "faandct.h"

 #define FLOAT float

-#ifdef FAAN_POSTSCALE

-#    define SCALE(x) postscale[x]

-#else

-#    define SCALE(x) 1

-#endif

 //numbers generated by simple c code (not as accurate as they could be)

 /*

@@ -150,13 +145,13 @@ void ff_faandct(DCTELEM * data)

         tmp11= tmp1 + tmp2;

         tmp12= tmp1 - tmp2;

-        data[8*0 + i]= lrintf(SCALE(8*0 + i) * (tmp10 + tmp11));

-        data[8*4 + i]= lrintf(SCALE(8*4 + i) * (tmp10 - tmp11));

+        data[8*0 + i]= lrintf(postscale[8*0 + i] * (tmp10 + tmp11));

+        data[8*4 + i]= lrintf(postscale[8*4 + i] * (tmp10 - tmp11));

         tmp12 += tmp13;

         tmp12 *= A1;

-        data[8*2 + i]= lrintf(SCALE(8*2 + i) * (tmp13 + tmp12));

-        data[8*6 + i]= lrintf(SCALE(8*6 + i) * (tmp13 - tmp12));

+        data[8*2 + i]= lrintf(postscale[8*2 + i] * (tmp13 + tmp12));

+        data[8*6 + i]= lrintf(postscale[8*6 + i] * (tmp13 - tmp12));

         tmp4 += tmp5;

         tmp5 += tmp6;

@@ -175,10 +170,10 @@ void ff_faandct(DCTELEM * data)

         z11= tmp7 + tmp5;

         z13= tmp7 - tmp5;

-        data[8*5 + i]= lrintf(SCALE(8*5 + i) * (z13 + z2));

-        data[8*3 + i]= lrintf(SCALE(8*3 + i) * (z13 - z2));

-        data[8*1 + i]= lrintf(SCALE(8*1 + i) * (z11 + z4));

-        data[8*7 + i]= lrintf(SCALE(8*7 + i) * (z11 - z4));

+        data[8*5 + i]= lrintf(postscale[8*5 + i] * (z13 + z2));

+        data[8*3 + i]= lrintf(postscale[8*3 + i] * (z13 - z2));

+        data[8*1 + i]= lrintf(postscale[8*1 + i] * (z11 + z4));

+        data[8*7 + i]= lrintf(postscale[8*7 + i] * (z11 - z4));

     }

 }

@@ -208,25 +203,25 @@ void ff_faandct248(DCTELEM * data)

         tmp12 = tmp1 - tmp2;

         tmp13 = tmp0 - tmp3;

-        data[8*0 + i] = lrintf(SCALE(8*0 + i) * (tmp10 + tmp11));

-        data[8*4 + i] = lrintf(SCALE(8*4 + i) * (tmp10 - tmp11));

+        data[8*0 + i] = lrintf(postscale[8*0 + i] * (tmp10 + tmp11));

+        data[8*4 + i] = lrintf(postscale[8*4 + i] * (tmp10 - tmp11));

         tmp12 += tmp13;

         tmp12 *= A1;

-        data[8*2 + i] = lrintf(SCALE(8*2 + i) * (tmp13 + tmp12));

-        data[8*6 + i] = lrintf(SCALE(8*6 + i) * (tmp13 - tmp12));

+        data[8*2 + i] = lrintf(postscale[8*2 + i] * (tmp13 + tmp12));

+        data[8*6 + i] = lrintf(postscale[8*6 + i] * (tmp13 - tmp12));

         tmp10 = tmp4 + tmp7;

         tmp11 = tmp5 + tmp6;

         tmp12 = tmp5 - tmp6;

         tmp13 = tmp4 - tmp7;

-        data[8*1 + i] = lrintf(SCALE(8*0 + i) * (tmp10 + tmp11));

-        data[8*5 + i] = lrintf(SCALE(8*4 + i) * (tmp10 - tmp11));

+        data[8*1 + i] = lrintf(postscale[8*0 + i] * (tmp10 + tmp11));

+        data[8*5 + i] = lrintf(postscale[8*4 + i] * (tmp10 - tmp11));

         tmp12 += tmp13;

         tmp12 *= A1;

-        data[8*3 + i] = lrintf(SCALE(8*2 + i) * (tmp13 + tmp12));

-        data[8*7 + i] = lrintf(SCALE(8*6 + i) * (tmp13 - tmp12));

+        data[8*3 + i] = lrintf(postscale[8*2 + i] * (tmp13 + tmp12));

+        data[8*7 + i] = lrintf(postscale[8*6 + i] * (tmp13 - tmp12));

     }

 }

@@ -31,8 +31,6 @@

 #include "dsputil.h"

-#define FAAN_POSTSCALE

-

 void ff_faandct(DCTELEM * data);

 void ff_faandct248(DCTELEM * data);

@@ -573,8 +573,7 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,

             av_fifo_generic_write(fpc->fifo_buf, (void*) read_start,

                                   read_end - read_start, NULL);

         } else {

-            int8_t pad[MAX_FRAME_HEADER_SIZE];

-            memset(pad, 0, sizeof(pad));

+            int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };

             av_fifo_generic_write(fpc->fifo_buf, (void*) pad, sizeof(pad), NULL);

         }

@@ -152,10 +152,8 @@ static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){

     int x,y;

     unsigned int p;//power divided by 2

     int a;

-    uint16_t left_sum[2][8];

-    uint16_t  top_sum[2][8];

-    memset(left_sum,0,2*8*sizeof(uint16_t));

-    memset( top_sum,0,2*8*sizeof(uint16_t));

+    uint16_t left_sum[2][8] = { { 0 } };

+    uint16_t  top_sum[2][8] = { { 0 } };

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

         a=src[area2+7-i]<<4;

@@ -210,8 +210,7 @@ static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last

 static void ls_store_lse(JLSState *state, PutBitContext *pb){

     /* Test if we have default params and don't need to store LSE */

-    JLSState state2;

-    memset(&state2, 0, sizeof(JLSState));

+    JLSState state2 = { 0 };

     state2.bpp = state->bpp;

     state2.near = state->near;

     ff_jpegls_reset_coding_parameters(&state2, 1);

@@ -251,21 +251,22 @@ static void lag_pred_line(LagarithContext *l, uint8_t *buf,

         /* Left prediction only for first line */

         L = l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1,

                                             width - 1, buf[0]);

-        return;

-    }

-    /* Left pixel is actually prev_row[width] */

-    L = buf[width - stride - 1];

-    if (line == 1) {

-        /* Second line, left predict first pixel, the rest of the line is median predicted

-         * NOTE: In the case of RGB this pixel is top predicted */

-        TL = l->avctx->pix_fmt == PIX_FMT_YUV420P ? buf[-stride] : L;

     } else {

-        /* Top left is 2 rows back, last pixel */

-        TL = buf[width - (2 * stride) - 1];

-    }

+        /* Left pixel is actually prev_row[width] */

+        L = buf[width - stride - 1];

+

+        if (line == 1) {

+            /* Second line, left predict first pixel, the rest of the line is median predicted

+             * NOTE: In the case of RGB this pixel is top predicted */

+            TL = l->avctx->pix_fmt == PIX_FMT_YUV420P ? buf[-stride] : L;

+        } else {

+            /* Top left is 2 rows back, last pixel */

+            TL = buf[width - (2 * stride) - 1];

+        }

-    add_lag_median_prediction(buf, buf - stride, buf,

-                              width, &L, &TL);

+        add_lag_median_prediction(buf, buf - stride, buf,

+                                  width, &L, &TL);

+    }

 }

 static int lag_decode_line(LagarithContext *l, lag_rac *rac,

@@ -311,13 +312,13 @@ handle_zeros:

 }

 static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst,

-                                    const uint8_t *src, const uint8_t *srcend, int width,

-                                    int esc_count)

+                                    const uint8_t *src, const uint8_t *src_end,

+                                    int width, int esc_count)

 {

     int i = 0;

     int count;

     uint8_t zero_run = 0;

-    const uint8_t *start = src;

+    const uint8_t *src_start = src;

     uint8_t mask1 = -(esc_count < 2);

     uint8_t mask2 = -(esc_count < 3);

     uint8_t *end = dst + (width - 2);

@@ -334,8 +335,8 @@ output_zeros:

         i = 0;

         while (!zero_run && dst + i < end) {

             i++;

-            if (i+2 >= srcend - src)

-                return src - start;

+            if (i+2 >= src_end - src)

+                return AVERROR_INVALIDDATA;

             zero_run =

                 !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));

         }

@@ -351,9 +352,10 @@ output_zeros:

         } else {

             memcpy(dst, src, i);

             src += i;

+            dst += i;

         }

     }

-    return  src - start;

+    return  src - src_start;

 }

@@ -369,7 +371,7 @@ static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,

     int esc_count;

     GetBitContext gb;

     lag_rac rac;

-    const uint8_t *srcend = src + src_size;

+    const uint8_t *src_end = src + src_size;

     rac.avctx = l->avctx;

     l->zeros = 0;

@@ -406,12 +408,16 @@ static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,

         esc_count -= 4;

         if (esc_count > 0) {

             /* Zero run coding only, no range coding. */

-            for (i = 0; i < height; i++)

-                src += lag_decode_zero_run_line(l, dst + (i * stride), src, srcend,

-                                                width, esc_count);

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

+                int res = lag_decode_zero_run_line(l, dst + (i * stride), src,

+                                                   src_end, width, esc_count);

+                if (res < 0)

+                    return res;

+                src += res;

+            }

         } else {

-            if (src_size < height * width)

-                return -1;

+            if (src_size < width * height)

+                return AVERROR_INVALIDDATA; // buffer not big enough

             /* Plane is stored uncompressed */

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

                 memcpy(dst + (i * stride), src, width);

@@ -518,15 +524,18 @@ static int lag_decode_frame(AVCodecContext *avctx,

         }

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

             srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;

-        for (i = 0; i < planes; i++) {

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

             if (buf_size <= offs[i]) {

+                av_log(avctx, AV_LOG_ERROR,

+                        "Invalid frame offsets\n");

                 return AVERROR_INVALIDDATA;

             }

+

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

             lag_decode_arith_plane(l, srcs[i],

                                    avctx->width, avctx->height,

                                    -l->rgb_stride, buf + offs[i],

                                    buf_size - offs[i]);

-        }

         dst = p->data[0];

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

             srcs[i] = l->rgb_planes + i * l->rgb_stride * avctx->height;

@@ -563,6 +572,14 @@ static int lag_decode_frame(AVCodecContext *avctx,

             return AVERROR_INVALIDDATA;

         }

+        if (offset_ry >= buf_size ||

+            offset_gu >= buf_size ||

+            offset_bv >= buf_size) {

+            av_log(avctx, AV_LOG_ERROR,

+                   "Invalid frame offsets\n");

+            return AVERROR_INVALIDDATA;

+        }

+

         lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,

                                p->linesize[0], buf + offset_ry,

                                buf_size - offset_ry);

@@ -32,15 +32,17 @@

 void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)

 {

-    int i, j;

+    int i, j, left;

     /* According to reference decoder "1st byte is garbage",

      * however, it gets skipped by the call to align_get_bits()

      */

     align_get_bits(gb);

+    left                = get_bits_left(gb) >> 3;

     l->bytestream_start =

     l->bytestream       = gb->buffer + get_bits_count(gb) / 8;

-    l->bytestream_end   = l->bytestream_start + get_bits_left(gb) / 8;

+    l->bytestream_end   = l->bytestream_start + left;

+

     l->range        = 0x80;

     l->low          = *l->bytestream >> 1;

     l->hash_shift   = FFMAX(l->scale - 8, 0);

@@ -36,8 +36,8 @@ extern unsigned int xvid_debug;

 int ff_xvid_rate_control_init(MpegEncContext *s){

     char *tmp_name;

     int fd, i;

-    xvid_plg_create_t xvid_plg_create;

-    xvid_plugin_2pass2_t xvid_2pass2;

+    xvid_plg_create_t xvid_plg_create = { 0 };

+    xvid_plugin_2pass2_t xvid_2pass2  = { 0 };

 //xvid_debug=-1;

@@ -67,7 +67,6 @@ int ff_xvid_rate_control_init(MpegEncContext *s){

     close(fd);

-    memset(&xvid_2pass2, 0, sizeof(xvid_2pass2));

     xvid_2pass2.version= XVID_MAKE_VERSION(1,1,0);

     xvid_2pass2.filename= tmp_name;

     xvid_2pass2.bitrate= s->avctx->bit_rate;

@@ -75,7 +74,6 @@ int ff_xvid_rate_control_init(MpegEncContext *s){

     xvid_2pass2.vbv_maxrate= s->avctx->rc_max_rate;

     xvid_2pass2.vbv_initial= s->avctx->rc_initial_buffer_occupancy;

-    memset(&xvid_plg_create, 0, sizeof(xvid_plg_create));

     xvid_plg_create.version= XVID_MAKE_VERSION(1,1,0);

     xvid_plg_create.fbase= s->avctx->time_base.den;

     xvid_plg_create.fincr= s->avctx->time_base.num;

@@ -89,9 +87,8 @@ int ff_xvid_rate_control_init(MpegEncContext *s){

 }

 float ff_xvid_rate_estimate_qscale(MpegEncContext *s, int dry_run){

-    xvid_plg_data_t xvid_plg_data;

+    xvid_plg_data_t xvid_plg_data = { 0 };

-    memset(&xvid_plg_data, 0, sizeof(xvid_plg_data));

     xvid_plg_data.version= XVID_MAKE_VERSION(1,1,0);

     xvid_plg_data.width = s->width;

     xvid_plg_data.height= s->height;

@@ -94,11 +94,11 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

     uint16_t *intra, *inter;

     int fd;

-    xvid_plugin_single_t single;

-    struct xvid_ff_pass1 rc2pass1;

-    xvid_plugin_2pass2_t rc2pass2;

-    xvid_gbl_init_t xvid_gbl_init;

-    xvid_enc_create_t xvid_enc_create;

+    xvid_plugin_single_t single       = { 0 };

+    struct xvid_ff_pass1 rc2pass1     = { 0 };

+    xvid_plugin_2pass2_t rc2pass2     = { 0 };

+    xvid_gbl_init_t xvid_gbl_init     = { 0 };

+    xvid_enc_create_t xvid_enc_create = { 0 };

     xvid_enc_plugin_t plugins[7];

     /* Bring in VOP flags from ffmpeg command-line */

@@ -168,7 +168,6 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

             x->me_flags |= XVID_ME_QUARTERPELREFINE8;

     }

-    memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));

     xvid_gbl_init.version = XVID_VERSION;

     xvid_gbl_init.debug = 0;

@@ -189,7 +188,6 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

     xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);

     /* Create the encoder reference */

-    memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));

     xvid_enc_create.version = XVID_VERSION;

     /* Store the desired frame size */

@@ -214,7 +212,6 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

     x->twopassfile = NULL;

     if( xvid_flags & CODEC_FLAG_PASS1 ) {

-        memset(&rc2pass1, 0, sizeof(struct xvid_ff_pass1));

         rc2pass1.version = XVID_VERSION;

         rc2pass1.context = x;

         x->twopassbuffer = av_malloc(BUFFER_SIZE);

@@ -230,7 +227,6 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

         plugins[xvid_enc_create.num_plugins].param = &rc2pass1;

         xvid_enc_create.num_plugins++;

     } else if( xvid_flags & CODEC_FLAG_PASS2 ) {

-        memset(&rc2pass2, 0, sizeof(xvid_plugin_2pass2_t));

         rc2pass2.version = XVID_VERSION;

         rc2pass2.bitrate = avctx->bit_rate;

@@ -262,7 +258,6 @@ static av_cold int xvid_encode_init(AVCodecContext *avctx)  {

         xvid_enc_create.num_plugins++;

     } else if( !(xvid_flags & CODEC_FLAG_QSCALE) ) {

         /* Single Pass Bitrate Control! */

-        memset(&single, 0, sizeof(xvid_plugin_single_t));

         single.version = XVID_VERSION;

         single.bitrate = avctx->bit_rate;

@@ -382,16 +377,14 @@ static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     int mb_width   = (avctx->width  + 15) / 16;

     int mb_height  = (avctx->height + 15) / 16;

-    xvid_enc_frame_t xvid_enc_frame;

-    xvid_enc_stats_t xvid_enc_stats;

+    xvid_enc_frame_t xvid_enc_frame = { 0 };

+    xvid_enc_stats_t xvid_enc_stats = { 0 };

     if ((ret = ff_alloc_packet2(avctx, pkt, mb_width*mb_height*MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0)

         return ret;

     /* Start setting up the frame */

-    memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));

     xvid_enc_frame.version = XVID_VERSION;

-    memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));

     xvid_enc_stats.version = XVID_VERSION;

     *p = *picture;

@@ -47,14 +47,13 @@ static int build_vlc(VLC *vlc, const uint8_t *bits_table,

                      const uint8_t *val_table, int nb_codes,

                      int use_static, int is_ac)

 {

-    uint8_t huff_size[256];

+    uint8_t huff_size[256] = { 0 };

     uint16_t huff_code[256];

     uint16_t huff_sym[256];

     int i;

     assert(nb_codes <= 256);

-    memset(huff_size, 0, sizeof(huff_size));

     ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);

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

@@ -1435,9 +1435,8 @@ static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y)

 #define HASH(fx,fy,bx,by) ((fx)+17*(fy)+63*(bx)+117*(by))

 #define HASH8(fx,fy,bx,by) ((uint8_t)HASH(fx,fy,bx,by))

     int hashidx= HASH(motion_fx,motion_fy, motion_bx, motion_by);

-    uint8_t map[256];

+    uint8_t map[256] = { 0 };

-    memset(map,0,sizeof(map));

     map[hashidx&255] = 1;

     fbmin= check_bidir_mv(s, motion_fx, motion_fy,

@@ -304,11 +304,8 @@ static av_cold void decode_init_static(void)

     for (i = 1; i < 16; i++) {

         const HuffTable *h = &mpa_huff_tables[i];

         int xsize, x, y;

-        uint8_t  tmp_bits [512];

-        uint16_t tmp_codes[512];

-

-        memset(tmp_bits , 0, sizeof(tmp_bits ));

-        memset(tmp_codes, 0, sizeof(tmp_codes));

+        uint8_t  tmp_bits [512] = { 0 };