@@ -9,6 +9,7 @@ version next:

 - ffprobe -count_packets and -count_frames options

 - Sun Rasterfile Encoder

 - ID3v2 attached pictures reading and writing

+- WMA Lossless decoder

 version 0.10:

@@ -811,6 +811,7 @@ following image formats are supported:

 @item Westwood Audio (SND1)  @tab     @tab  X

 @item Windows Media Audio 1  @tab  X  @tab  X

 @item Windows Media Audio 2  @tab  X  @tab  X

+@item Windows Media Audio Lossless @tab  @tab  X

 @item Windows Media Audio Pro @tab    @tab  X

 @item Windows Media Audio Voice @tab  @tab  X

 @end multitable

@@ -299,12 +299,14 @@ OBJS-$(CONFIG_MPEG4_VAAPI_HWACCEL)     += vaapi_mpeg4.o

 OBJS-$(CONFIG_MSMPEG4V1_DECODER)       += msmpeg4.o msmpeg4data.o

 OBJS-$(CONFIG_MSMPEG4V2_DECODER)       += msmpeg4.o msmpeg4data.o h263dec.o \

                                           h263.o ituh263dec.o mpeg4videodec.o

-OBJS-$(CONFIG_MSMPEG4V2_ENCODER)       += msmpeg4.o msmpeg4data.o h263dec.o \

-                                          h263.o ituh263dec.o mpeg4videodec.o

+OBJS-$(CONFIG_MSMPEG4V2_ENCODER)       += msmpeg4.o msmpeg4enc.o msmpeg4data.o \

+                                          h263dec.o h263.o ituh263dec.o        \

+                                          mpeg4videodec.o

 OBJS-$(CONFIG_MSMPEG4V3_DECODER)       += msmpeg4.o msmpeg4data.o h263dec.o \

                                           h263.o ituh263dec.o mpeg4videodec.o

-OBJS-$(CONFIG_MSMPEG4V3_ENCODER)       += msmpeg4.o msmpeg4data.o h263dec.o \

-                                          h263.o ituh263dec.o mpeg4videodec.o

+OBJS-$(CONFIG_MSMPEG4V3_ENCODER)       += msmpeg4.o msmpeg4enc.o msmpeg4data.o \

+                                          h263dec.o h263.o ituh263dec.o        \

+                                          mpeg4videodec.o

 OBJS-$(CONFIG_MSRLE_DECODER)           += msrle.o msrledec.o

 OBJS-$(CONFIG_MSVIDEO1_DECODER)        += msvideo1.o

 OBJS-$(CONFIG_MSVIDEO1_ENCODER)        += msvideo1enc.o elbg.o

@@ -471,7 +473,7 @@ OBJS-$(CONFIG_WMV2_DECODER)            += wmv2dec.o wmv2.o        \

                                           msmpeg4.o msmpeg4data.o \

                                           intrax8.o intrax8dsp.o

 OBJS-$(CONFIG_WMV2_ENCODER)            += wmv2enc.o wmv2.o \

-                                          msmpeg4.o msmpeg4data.o \

+                                          msmpeg4.o msmpeg4enc.o msmpeg4data.o \

                                           mpeg4videodec.o ituh263dec.o h263dec.o

 OBJS-$(CONFIG_WNV1_DECODER)            += wnv1.o

 OBJS-$(CONFIG_WS_SND1_DECODER)         += ws-snd1.o

@@ -246,7 +246,7 @@ static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                                  const AVFrame *pict, int *got_packet)

 {

     A64Context *c = avctx->priv_data;

-    AVFrame *const p = (AVFrame *) & c->picture;

+    AVFrame *const p = &c->picture;

     int frame;

     int x, y;

@@ -898,10 +898,10 @@ static float auto_correlation(float *diff_isf, float mean, int lag)

  * Extrapolate a ISF vector to the 16kHz range (20th order LP)

  * used at mode 6k60 LP filter for the high frequency band.

  *

- * @param[out] out                 Buffer for extrapolated isf

- * @param[in]  isf                 Input isf vector

+ * @param[out] isf Buffer for extrapolated isf; contains LP_ORDER

+ *                 values on input

  */

-static void extrapolate_isf(float out[LP_ORDER_16k], float isf[LP_ORDER])

+static void extrapolate_isf(float isf[LP_ORDER_16k])

 {

     float diff_isf[LP_ORDER - 2], diff_mean;

     float *diff_hi = diff_isf - LP_ORDER + 1; // diff array for extrapolated indexes

@@ -909,8 +909,7 @@ static void extrapolate_isf(float out[LP_ORDER_16k], float isf[LP_ORDER])

     float est, scale;

     int i, i_max_corr;

-    memcpy(out, isf, (LP_ORDER - 1) * sizeof(float));

-    out[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];

+    isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];

     /* Calculate the difference vector */

     for (i = 0; i < LP_ORDER - 2; i++)

@@ -931,16 +930,16 @@ static void extrapolate_isf(float out[LP_ORDER_16k], float isf[LP_ORDER])

     i_max_corr++;

     for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)

-        out[i] = isf[i - 1] + isf[i - 1 - i_max_corr]

+        isf[i] = isf[i - 1] + isf[i - 1 - i_max_corr]

                             - isf[i - 2 - i_max_corr];

     /* Calculate an estimate for ISF(18) and scale ISF based on the error */

-    est   = 7965 + (out[2] - out[3] - out[4]) / 6.0;

-    scale = 0.5 * (FFMIN(est, 7600) - out[LP_ORDER - 2]) /

-            (out[LP_ORDER_16k - 2] - out[LP_ORDER - 2]);

+    est   = 7965 + (isf[2] - isf[3] - isf[4]) / 6.0;

+    scale = 0.5 * (FFMIN(est, 7600) - isf[LP_ORDER - 2]) /

+            (isf[LP_ORDER_16k - 2] - isf[LP_ORDER - 2]);

     for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)

-        diff_hi[i] = scale * (out[i] - out[i - 1]);

+        diff_hi[i] = scale * (isf[i] - isf[i - 1]);

     /* Stability insurance */

     for (i = LP_ORDER; i < LP_ORDER_16k - 1; i++)

@@ -952,11 +951,11 @@ static void extrapolate_isf(float out[LP_ORDER_16k], float isf[LP_ORDER])

         }

     for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)

-        out[i] = out[i - 1] + diff_hi[i] * (1.0f / (1 << 15));

+        isf[i] = isf[i - 1] + diff_hi[i] * (1.0f / (1 << 15));

     /* Scale the ISF vector for 16000 Hz */

     for (i = 0; i < LP_ORDER_16k - 1; i++)

-        out[i] *= 0.8;

+        isf[i] *= 0.8;

 }

 /**

@@ -1003,7 +1002,7 @@ static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples,

         ff_weighted_vector_sumf(e_isf, isf_past, isf, isfp_inter[subframe],

                                 1.0 - isfp_inter[subframe], LP_ORDER);

-        extrapolate_isf(e_isf, e_isf);

+        extrapolate_isf(e_isf);

         e_isf[LP_ORDER_16k - 1] *= 2.0;

         ff_acelp_lsf2lspd(e_isp, e_isf, LP_ORDER_16k);

@@ -1095,23 +1094,27 @@ static int amrwb_decode_frame(AVCodecContext *avctx, void *data,

     buf_out = (float *)ctx->avframe.data[0];

     header_size      = decode_mime_header(ctx, buf);

+    if (ctx->fr_cur_mode > MODE_SID) {

+        av_log(avctx, AV_LOG_ERROR,

+               "Invalid mode %d\n", ctx->fr_cur_mode);

+        return AVERROR_INVALIDDATA;

+    }

     expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1;

     if (buf_size < expected_fr_size) {

         av_log(avctx, AV_LOG_ERROR,

             "Frame too small (%d bytes). Truncated file?\n", buf_size);

         *got_frame_ptr = 0;

-        return buf_size;

+        return AVERROR_INVALIDDATA;

     }

     if (!ctx->fr_quality || ctx->fr_cur_mode > MODE_SID)

         av_log(avctx, AV_LOG_ERROR, "Encountered a bad or corrupted frame\n");

-    if (ctx->fr_cur_mode == MODE_SID) /* Comfort noise frame */

+    if (ctx->fr_cur_mode == MODE_SID) { /* Comfort noise frame */

         av_log_missing_feature(avctx, "SID mode", 1);

-

-    if (ctx->fr_cur_mode >= MODE_SID)

         return -1;

+    }

     ff_amr_bit_reorder((uint16_t *) &ctx->frame, sizeof(AMRWBFrame),

         buf + header_size, amr_bit_orderings_by_mode[ctx->fr_cur_mode]);

@@ -23,87 +23,87 @@ void ff_vp8_luma_dc_wht_dc_armv6(DCTELEM block[4][4][16], DCTELEM dc[16]);

 #define idct_funcs(opt) \

 void ff_vp8_luma_dc_wht_ ## opt(DCTELEM block[4][4][16], DCTELEM dc[16]); \

-void ff_vp8_idct_add_ ## opt(uint8_t *dst, DCTELEM block[16], int stride); \

-void ff_vp8_idct_dc_add_ ## opt(uint8_t *dst, DCTELEM block[16], int stride); \

-void ff_vp8_idct_dc_add4y_ ## opt(uint8_t *dst, DCTELEM block[4][16], int stride); \

-void ff_vp8_idct_dc_add4uv_ ## opt(uint8_t *dst, DCTELEM block[4][16], int stride)

+void ff_vp8_idct_add_ ## opt(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride); \

+void ff_vp8_idct_dc_add_ ## opt(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride); \

+void ff_vp8_idct_dc_add4y_ ## opt(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride); \

+void ff_vp8_idct_dc_add4uv_ ## opt(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride)

 idct_funcs(neon);

 idct_funcs(armv6);

-void ff_vp8_v_loop_filter16_neon(uint8_t *dst, int stride,

+void ff_vp8_v_loop_filter16_neon(uint8_t *dst, ptrdiff_t stride,

                                  int flim_E, int flim_I, int hev_thresh);

-void ff_vp8_h_loop_filter16_neon(uint8_t *dst, int stride,

+void ff_vp8_h_loop_filter16_neon(uint8_t *dst, ptrdiff_t stride,

                                  int flim_E, int flim_I, int hev_thresh);

-void ff_vp8_v_loop_filter8uv_neon(uint8_t *dstU, uint8_t *dstV, int stride,

+void ff_vp8_v_loop_filter8uv_neon(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,

                                   int flim_E, int flim_I, int hev_thresh);

-void ff_vp8_h_loop_filter8uv_neon(uint8_t *dstU, uint8_t *dstV, int stride,

+void ff_vp8_h_loop_filter8uv_neon(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,

                                   int flim_E, int flim_I, int hev_thresh);

-void ff_vp8_v_loop_filter16_inner_neon(uint8_t *dst, int stride,

+void ff_vp8_v_loop_filter16_inner_neon(uint8_t *dst, ptrdiff_t stride,

                                        int flim_E, int flim_I, int hev_thresh);

-void ff_vp8_h_loop_filter16_inner_neon(uint8_t *dst, int stride,

+void ff_vp8_h_loop_filter16_inner_neon(uint8_t *dst, ptrdiff_t stride,

                                        int flim_E, int flim_I, int hev_thresh);

 void ff_vp8_v_loop_filter8uv_inner_neon(uint8_t *dstU, uint8_t *dstV,

-                                        int stride, int flim_E, int flim_I,

+                                        ptrdiff_t stride, int flim_E, int flim_I,

                                         int hev_thresh);

 void ff_vp8_h_loop_filter8uv_inner_neon(uint8_t *dstU, uint8_t *dstV,

-                                        int stride, int flim_E, int flim_I,

+                                        ptrdiff_t stride, int flim_E, int flim_I,

                                         int hev_thresh);

-void ff_vp8_v_loop_filter_inner_armv6(uint8_t *dst, int stride,

+void ff_vp8_v_loop_filter_inner_armv6(uint8_t *dst, ptrdiff_t stride,

                                       int flim_E, int flim_I,

                                       int hev_thresh, int count);

-void ff_vp8_h_loop_filter_inner_armv6(uint8_t *dst, int stride,

+void ff_vp8_h_loop_filter_inner_armv6(uint8_t *dst, ptrdiff_t stride,

                                       int flim_E, int flim_I,

                                       int hev_thresh, int count);

-void ff_vp8_v_loop_filter_armv6(uint8_t *dst, int stride,

+void ff_vp8_v_loop_filter_armv6(uint8_t *dst, ptrdiff_t stride,

                                 int flim_E, int flim_I,

                                 int hev_thresh, int count);

-void ff_vp8_h_loop_filter_armv6(uint8_t *dst, int stride,

+void ff_vp8_h_loop_filter_armv6(uint8_t *dst, ptrdiff_t stride,

                                 int flim_E, int flim_I,

                                 int hev_thresh, int count);

-static void ff_vp8_v_loop_filter16_armv6(uint8_t *dst, int stride,

+static void ff_vp8_v_loop_filter16_armv6(uint8_t *dst, ptrdiff_t stride,

                                          int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_v_loop_filter_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);

 }

-static void ff_vp8_h_loop_filter16_armv6(uint8_t *dst, int stride,

+static void ff_vp8_h_loop_filter16_armv6(uint8_t *dst, ptrdiff_t stride,

                                          int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_h_loop_filter_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);

 }

-static void ff_vp8_v_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, int stride,

+static void ff_vp8_v_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,

                                           int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_v_loop_filter_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);

     ff_vp8_v_loop_filter_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);

 }

-static void ff_vp8_h_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, int stride,

+static void ff_vp8_h_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,

                                           int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_h_loop_filter_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);

     ff_vp8_h_loop_filter_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);

 }

-static void ff_vp8_v_loop_filter16_inner_armv6(uint8_t *dst, int stride,

+static void ff_vp8_v_loop_filter16_inner_armv6(uint8_t *dst, ptrdiff_t stride,

                                                int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_v_loop_filter_inner_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);

 }

-static void ff_vp8_h_loop_filter16_inner_armv6(uint8_t *dst, int stride,

+static void ff_vp8_h_loop_filter16_inner_armv6(uint8_t *dst, ptrdiff_t stride,

                                                int flim_E, int flim_I, int hev_thresh)

 {

     ff_vp8_h_loop_filter_inner_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);

 }

 static void ff_vp8_v_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,

-                                                int stride, int flim_E, int flim_I,

+                                                ptrdiff_t stride, int flim_E, int flim_I,

                                                 int hev_thresh)

 {

     ff_vp8_v_loop_filter_inner_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);

@@ -111,7 +111,7 @@ static void ff_vp8_v_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,

 }

 static void ff_vp8_h_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,

-                                                int stride, int flim_E, int flim_I,

+                                                ptrdiff_t stride, int flim_E, int flim_I,

                                                 int hev_thresh)

 {

     ff_vp8_h_loop_filter_inner_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);

@@ -119,16 +119,16 @@ static void ff_vp8_h_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,

 }

 #define simple_lf_funcs(opt) \

-void ff_vp8_v_loop_filter16_simple_ ## opt(uint8_t *dst, int stride, int flim); \

-void ff_vp8_h_loop_filter16_simple_ ## opt(uint8_t *dst, int stride, int flim)

+void ff_vp8_v_loop_filter16_simple_ ## opt(uint8_t *dst, ptrdiff_t stride, int flim); \

+void ff_vp8_h_loop_filter16_simple_ ## opt(uint8_t *dst, ptrdiff_t stride, int flim)

 simple_lf_funcs(neon);

 simple_lf_funcs(armv6);

-#define VP8_MC_OPT(n, opt)                                              \

-    void ff_put_vp8_##n##_##opt(uint8_t *dst, int dststride,            \

-                                uint8_t *src, int srcstride,            \

-                                int h, int x, int y)

+#define VP8_MC(n)                                                       \

+    void ff_put_vp8_##n##_neon(uint8_t *dst, ptrdiff_t dststride,       \

+                               uint8_t *src, ptrdiff_t srcstride,       \

+                               int h, int x, int y)

 #define VP8_MC(n) \

     VP8_MC_OPT(n, neon)

@@ -454,7 +454,7 @@ static int decode_frame(AVCodecContext *avctx,

         }

     }

-    *picture= *(AVFrame*)&a->picture;

+    *picture   = a->picture;

     *data_size = sizeof(AVPicture);

     emms_c();

@@ -51,7 +51,7 @@ avs_decode_frame(AVCodecContext * avctx,

     int buf_size = avpkt->size;

     AvsContext *const avs = avctx->priv_data;

     AVFrame *picture = data;

-    AVFrame *const p = (AVFrame *) & avs->picture;

+    AVFrame *const p =  &avs->picture;

     const uint8_t *table, *vect;

     uint8_t *out;

     int i, j, x, y, stride, vect_w = 3, vect_h = 3;

@@ -151,7 +151,7 @@ avs_decode_frame(AVCodecContext * avctx,

             align_get_bits(&change_map);

     }

-    *picture = *(AVFrame *) & avs->picture;

+    *picture   = avs->picture;

     *data_size = sizeof(AVPicture);

     return buf_size;

@@ -27,8 +27,8 @@

 static av_cold int bmp_decode_init(AVCodecContext *avctx){

     BMPContext *s = avctx->priv_data;

-    avcodec_get_frame_defaults((AVFrame*)&s->picture);

-    avctx->coded_frame = (AVFrame*)&s->picture;

+    avcodec_get_frame_defaults(&s->picture);

+    avctx->coded_frame = &s->picture;

     return 0;

 }

@@ -34,8 +34,8 @@ static const uint32_t rgb444_masks[]  = { 0x0F00, 0x00F0, 0x000F };

 static av_cold int bmp_encode_init(AVCodecContext *avctx){

     BMPContext *s = avctx->priv_data;

-    avcodec_get_frame_defaults((AVFrame*)&s->picture);

-    avctx->coded_frame = (AVFrame*)&s->picture;

+    avcodec_get_frame_defaults(&s->picture);

+    avctx->coded_frame = &s->picture;

     switch (avctx->pix_fmt) {

     case PIX_FMT_BGRA:

@@ -72,7 +72,7 @@ static int bmp_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                             const AVFrame *pict, int *got_packet)

 {

     BMPContext *s = avctx->priv_data;

-    AVFrame * const p= (AVFrame*)&s->picture;

+    AVFrame * const p = &s->picture;

     int n_bytes_image, n_bytes_per_row, n_bytes, i, n, hsize, ret;

     const uint32_t *pal = NULL;

     uint32_t palette256[256];

@@ -501,9 +501,9 @@ static int decode_pic(AVSContext *h) {

     }

     /* release last B frame */

     if(h->picture.f.data[0])

-        s->avctx->release_buffer(s->avctx, (AVFrame *)&h->picture);

+        s->avctx->release_buffer(s->avctx, &h->picture.f);

-    s->avctx->get_buffer(s->avctx, (AVFrame *)&h->picture);

+    s->avctx->get_buffer(s->avctx, &h->picture.f);

     ff_cavs_init_pic(h);

     h->picture.poc = get_bits(&s->gb,8)*2;

@@ -592,7 +592,7 @@ static int decode_pic(AVSContext *h) {

     }

     if(h->pic_type != AV_PICTURE_TYPE_B) {

         if(h->DPB[1].f.data[0])

-            s->avctx->release_buffer(s->avctx, (AVFrame *)&h->DPB[1]);

+            s->avctx->release_buffer(s->avctx, &h->DPB[1].f);

         h->DPB[1] = h->DPB[0];

         h->DPB[0] = h->picture;

         memset(&h->picture,0,sizeof(Picture));

@@ -656,7 +656,7 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,

     if (buf_size == 0) {

         if (!s->low_delay && h->DPB[0].f.data[0]) {

             *data_size = sizeof(AVPicture);

-            *picture = *(AVFrame *) &h->DPB[0];

+            *picture = h->DPB[0].f;

         }

         return 0;

     }

@@ -676,9 +676,9 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,

         case PIC_I_START_CODE:

             if(!h->got_keyframe) {

                 if(h->DPB[0].f.data[0])

-                    avctx->release_buffer(avctx, (AVFrame *)&h->DPB[0]);

+                    avctx->release_buffer(avctx, &h->DPB[0].f);

                 if(h->DPB[1].f.data[0])

-                    avctx->release_buffer(avctx, (AVFrame *)&h->DPB[1]);

+                    avctx->release_buffer(avctx, &h->DPB[1].f);

                 h->got_keyframe = 1;

             }

         case PIC_PB_START_CODE:

@@ -692,12 +692,12 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,

             *data_size = sizeof(AVPicture);

             if(h->pic_type != AV_PICTURE_TYPE_B) {

                 if(h->DPB[1].f.data[0]) {

-                    *picture = *(AVFrame *) &h->DPB[1];

+                    *picture = h->DPB[1].f;

                 } else {

                     *data_size = 0;

                 }

             } else

-                *picture = *(AVFrame *) &h->picture;

+                *picture = h->picture.f;

             break;

         case EXT_START_CODE:

             //mpeg_decode_extension(avctx,buf_ptr, input_size);

@@ -613,7 +613,7 @@ skip_mean_and_median:

                         if (s->avctx->codec_id == CODEC_ID_H264) {

                             // FIXME

                         } else {

-                            ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

+                            ff_thread_await_progress(&s->last_picture_ptr->f,

                                                      mb_y, 0);

                         }

                         if (!s->last_picture.f.motion_val[0] ||

@@ -786,7 +786,7 @@ static int is_intra_more_likely(MpegEncContext *s)

                 if (s->avctx->codec_id == CODEC_ID_H264) {

                     // FIXME

                 } else {

-                    ff_thread_await_progress((AVFrame *) s->last_picture_ptr,

+                    ff_thread_await_progress(&s->last_picture_ptr->f,

                                              mb_y, 0);

                 }

                 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);

@@ -1170,7 +1170,7 @@ void ff_er_frame_end(MpegEncContext *s)

                     if (s->avctx->codec_id == CODEC_ID_H264) {

                         // FIXME

                     } else {

-                        ff_thread_await_progress((AVFrame *) s->next_picture_ptr, mb_y, 0);

+                        ff_thread_await_progress(&s->next_picture_ptr->f, mb_y, 0);

                     }

                     s->mv[0][0][0] = s->next_picture.f.motion_val[0][xy][0] *  time_pb            / time_pp;

                     s->mv[0][0][1] = s->next_picture.f.motion_val[0][xy][1] *  time_pb            / time_pp;

@@ -62,7 +62,7 @@ static av_cold int decode_init(AVCodecContext *avctx)

     FrapsContext * const s = avctx->priv_data;

     avcodec_get_frame_defaults(&s->frame);

-    avctx->coded_frame = (AVFrame*)&s->frame;

+    avctx->coded_frame = &s->frame;

     s->avctx = avctx;

     s->tmpbuf = NULL;

@@ -132,7 +132,7 @@ static int decode_frame(AVCodecContext *avctx,

     int buf_size = avpkt->size;

     FrapsContext * const s = avctx->priv_data;

     AVFrame *frame = data;

-    AVFrame * const f = (AVFrame*)&s->frame;

+    AVFrame * const f = &s->frame;

     uint32_t header;

     unsigned int version,header_size;

     unsigned int x, y;

@@ -126,8 +126,8 @@ static int g722_decode_frame(AVCodecContext *avctx, void *data,

         c->prev_samples[c->prev_samples_pos++] = rlow - rhigh;

         ff_g722_apply_qmf(c->prev_samples + c->prev_samples_pos - 24,

                           &xout1, &xout2);

-        *out_buf++ = av_clip_int16(xout1 >> 12);

-        *out_buf++ = av_clip_int16(xout2 >> 12);

+        *out_buf++ = av_clip_int16(xout1 >> 11);

+        *out_buf++ = av_clip_int16(xout2 >> 11);

         if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {

             memmove(c->prev_samples, c->prev_samples + c->prev_samples_pos - 22,

                     22 * sizeof(c->prev_samples[0]));

@@ -136,8 +136,8 @@ static inline void filter_samples(G722Context *c, const int16_t *samples,

     c->prev_samples[c->prev_samples_pos++] = samples[0];

     c->prev_samples[c->prev_samples_pos++] = samples[1];

     ff_g722_apply_qmf(c->prev_samples + c->prev_samples_pos - 24, &xout1, &xout2);

-    *xlow  = xout1 + xout2 >> 13;

-    *xhigh = xout1 - xout2 >> 13;

+    *xlow  = xout1 + xout2 >> 14;

+    *xhigh = xout1 - xout2 >> 14;

     if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {

         memmove(c->prev_samples,

                 c->prev_samples + c->prev_samples_pos - 22,

@@ -160,7 +160,7 @@ static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                             const AVFrame *pict, int *got_packet)

 {

     GIFContext *s = avctx->priv_data;

-    AVFrame *const p = (AVFrame *)&s->picture;

+    AVFrame *const p = &s->picture;

     uint8_t *outbuf_ptr, *end;

     int ret;

@@ -628,7 +628,8 @@ retry:

 assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);

 assert(s->current_picture.f.pict_type == s->pict_type);

-    *pict= *(AVFrame*)s->current_picture_ptr;

+

+    *pict = s->current_picture_ptr->f;

     ff_print_debug_info(s, pict);

     *data_size = sizeof(AVFrame);

@@ -357,7 +357,7 @@ uint64_t time= rdtsc();

     if (buf_size == 0) {

         /* special case for last picture */

         if (s->low_delay==0 && s->next_picture_ptr) {

-            *pict= *(AVFrame*)s->next_picture_ptr;

+            *pict = s->next_picture_ptr->f;

             s->next_picture_ptr= NULL;

             *data_size = sizeof(AVFrame);

@@ -727,9 +727,9 @@ intrax8_decoded:

     assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);

     assert(s->current_picture.f.pict_type == s->pict_type);

     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

-        *pict= *(AVFrame*)s->current_picture_ptr;

+        *pict = s->current_picture_ptr->f;

     } else if (s->last_picture_ptr != NULL) {

-        *pict= *(AVFrame*)s->last_picture_ptr;

+        *pict = s->last_picture_ptr->f;

     }

     if(s->last_picture_ptr || s->low_delay){

@@ -367,14 +367,14 @@ static void await_references(H264Context *h){

                 nrefs[list]--;

                 if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields

-                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);

-                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);

+                    ff_thread_await_progress(&ref_pic->f, FFMIN((row >> 1) - !(row & 1), pic_height - 1), 1);

+                    ff_thread_await_progress(&ref_pic->f, FFMIN((row >> 1),              pic_height - 1), 0);

                 }else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame

-                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);

+                    ff_thread_await_progress(&ref_pic->f, FFMIN(row * 2 + ref_field, pic_height - 1), 0);

                 }else if(FIELD_PICTURE){

-                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);

+                    ff_thread_await_progress(&ref_pic->f, FFMIN(row, pic_height - 1), ref_field);

                 }else{

-                    ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);

+                    ff_thread_await_progress(&ref_pic->f, FFMIN(row, pic_height - 1), 0);

                 }

             }

         }

@@ -2507,8 +2507,9 @@ static int field_end(H264Context *h, int in_setup){

     s->mb_y= 0;

     if (!in_setup && !s->dropable)

-        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,

-                                 s->picture_structure==PICT_BOTTOM_FIELD);

+        ff_thread_report_progress(&s->current_picture_ptr->f,

+                                  (16 * s->mb_height >> FIELD_PICTURE) - 1,

+                                  s->picture_structure == PICT_BOTTOM_FIELD);

     if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)

         ff_vdpau_h264_set_reference_frames(s);

@@ -2906,8 +2907,8 @@ static int decode_slice_header(H264Context *h, H264Context *h0){

             h->prev_frame_num++;

             h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;

             s->current_picture_ptr->frame_num= h->prev_frame_num;

-            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);

-            ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);

+            ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);

+            ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 1);

             ff_generate_sliding_window_mmcos(h);

             if (ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index) < 0 &&

                 (s->avctx->err_recognition & AV_EF_EXPLODE))

@@ -3577,8 +3578,8 @@ static void decode_finish_row(H264Context *h){

     if (s->dropable) return;

-    ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,

-                             s->picture_structure==PICT_BOTTOM_FIELD);

+    ff_thread_report_progress(&s->current_picture_ptr->f, top + height - 1,

+                              s->picture_structure == PICT_BOTTOM_FIELD);

 }

 static int decode_slice(struct AVCodecContext *avctx, void *arg){

@@ -4067,7 +4068,7 @@ static int decode_frame(AVCodecContext *avctx,

         if(out){

             *data_size = sizeof(AVFrame);

-            *pict= *(AVFrame*)out;

+            *pict      = out->f;

         }

         return buf_index;

@@ -4121,7 +4122,7 @@ not_extra:

         *data_size = 0; /* Wait for second field. */

         if (h->next_output_pic && (h->next_output_pic->sync || h->sync>1)) {

                 *data_size = sizeof(AVFrame);

-                *pict = *(AVFrame*)h->next_output_pic;

+                *pict      = h->next_output_pic->f;

         }

     }

@@ -154,7 +154,8 @@ static void await_reference_mb_row(H264Context * const h, Picture *ref, int mb_y

     //FIXME it can be safe to access mb stuff

     //even if pixels aren't deblocked yet

-    ff_thread_await_progress((AVFrame*)ref, FFMIN(16*mb_y >> ref_field_picture, ref_height-1),

+    ff_thread_await_progress(&ref->f,

+                             FFMIN(16 * mb_y >> ref_field_picture, ref_height - 1),

                              ref_field_picture && ref_field);

 }

@@ -143,7 +143,7 @@ static int ir2_decode_frame(AVCodecContext *avctx,

     int buf_size = avpkt->size;

     Ir2Context * const s = avctx->priv_data;

     AVFrame *picture = data;

-    AVFrame * const p= (AVFrame*)&s->picture;

+    AVFrame * const p = &s->picture;

     int start;

     p->reference = 3;

@@ -188,7 +188,7 @@ static int ir2_decode_frame(AVCodecContext *avctx,

                          s->picture.data[1], s->picture.linesize[1], ir2_luma_table);

     }

-    *picture= *(AVFrame*)&s->picture;

+    *picture   = s->picture;

     *data_size = sizeof(AVPicture);

     return buf_size;

@@ -232,7 +232,7 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,

                              const AVFrame *pict, int *got_packet)

 {

     JpeglsContext * const s = avctx->priv_data;

-    AVFrame * const p= (AVFrame*)&s->picture;

+    AVFrame * const p = &s->picture;

     const int near = avctx->prediction_method;

     PutBitContext pb, pb2;

     GetBitContext gb;

@@ -45,7 +45,7 @@ static int encode_picture_lossless(AVCodecContext *avctx, AVPacket *pkt,

     MJpegContext * const m = s->mjpeg_ctx;

     const int width= s->width;

     const int height= s->height;

-    AVFrame * const p= (AVFrame*)&s->current_picture;

+    AVFrame * const p = &s->current_picture.f;

     const int predictor= avctx->prediction_method+1;

     const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];

     const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];

@@ -166,7 +166,7 @@ static int decode_frame(AVCodecContext *avctx,

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

     LOCOContext * const l = avctx->priv_data;

-    AVFrame * const p= (AVFrame*)&l->pic;

+    AVFrame * const p = &l->pic;

     int decoded;

     if(p->data[0])

@@ -243,7 +243,7 @@ static av_cold int decode_init(AVCodecContext *avctx){

 static av_cold int decode_init_thread_copy(AVCodecContext *avctx){

     MDECContext * const a = avctx->priv_data;

-    AVFrame *p = (AVFrame*)&a->picture;

+    AVFrame *p = &a->picture;

     avctx->coded_frame= p;

     a->avctx= avctx;

@@ -1577,7 +1577,7 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

             goto the_end;

         } else if (unescaped_buf_size > (1U<<29)) {

             av_log(avctx, AV_LOG_ERROR, "MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",

-                   start_code, unescaped_buf_ptr, buf_size);

+                   start_code, unescaped_buf_size, buf_size);

             return AVERROR_INVALIDDATA;

         } else {

             av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",

@@ -1952,7 +1952,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)

         ff_MPV_frame_end(s);

         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

-            *pict = *(AVFrame*)s->current_picture_ptr;

+            *pict = s->current_picture_ptr->f;

             ff_print_debug_info(s, pict);

         } else {

             if (avctx->active_thread_type & FF_THREAD_FRAME)

@@ -1960,7 +1960,7 @@ static int slice_end(AVCodecContext *avctx, AVFrame *pict)

             /* latency of 1 frame for I- and P-frames */

             /* XXX: use another variable than picture_number */

             if (s->last_picture_ptr != NULL) {

-                *pict = *(AVFrame*)s->last_picture_ptr;

+                *pict = s->last_picture_ptr->f;

                  ff_print_debug_info(s, pict);

             }

         }

@@ -2256,7 +2256,7 @@ static int mpeg_decode_frame(AVCodecContext *avctx,

     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {

         /* special case for last picture */

         if (s2->low_delay == 0 && s2->next_picture_ptr) {

-            *picture = *(AVFrame*)s2->next_picture_ptr;

+            *picture = s2->next_picture_ptr->f;

             s2->next_picture_ptr = NULL;

             *data_size = sizeof(AVFrame);

@@ -1313,7 +1313,7 @@ static int mpeg4_decode_mb(MpegEncContext *s,

                 s->last_mv[i][1][1]= 0;

             }

-            ff_thread_await_progress((AVFrame*)s->next_picture_ptr, s->mb_y, 0);

+            ff_thread_await_progress(&s->next_picture_ptr->f, s->mb_y, 0);

         }

         /* if we skipped it in the future P Frame than skip it now too */

@@ -1500,7 +1500,7 @@ end:

             if(s->pict_type==AV_PICTURE_TYPE_B){

                 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;

-                ff_thread_await_progress((AVFrame*)s->next_picture_ptr,

+                ff_thread_await_progress(&s->next_picture_ptr->f,

                                         (s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);

                 if (s->next_picture.f.mbskip_table[xy + delta])

                     return SLICE_OK;

@@ -232,9 +232,9 @@ static void free_frame_buffer(MpegEncContext *s, Picture *pic)

      * dimensions; ignore user defined callbacks for these

      */

     if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)

-        ff_thread_release_buffer(s->avctx, (AVFrame *) pic);

+        ff_thread_release_buffer(s->avctx, &pic->f);

     else

-        avcodec_default_release_buffer(s->avctx, (AVFrame *) pic);

+        avcodec_default_release_buffer(s->avctx, &pic->f);

     av_freep(&pic->f.hwaccel_picture_private);

 }

@@ -257,9 +257,9 @@ static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)

     }

     if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)

-        r = ff_thread_get_buffer(s->avctx, (AVFrame *) pic);

+        r = ff_thread_get_buffer(s->avctx, &pic->f);

     else

-        r = avcodec_default_get_buffer(s->avctx, (AVFrame *) pic);

+        r = avcodec_default_get_buffer(s->avctx, &pic->f);

     if (r < 0 || !pic->f.type || !pic->f.data[0]) {

         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",

@@ -729,7 +729,7 @@ av_cold int ff_MPV_common_init(MpegEncContext *s)

     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);

     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);

-    s->avctx->coded_frame = (AVFrame*)&s->current_picture;

+    s->avctx->coded_frame = &s->current_picture.f;

     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this

     for (y = 0; y < s->mb_height; y++)

@@ -781,7 +781,7 @@ av_cold int ff_MPV_common_init(MpegEncContext *s)

     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,

                       s->picture_count * sizeof(Picture), fail);

     for (i = 0; i < s->picture_count; i++) {

-        avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);

+        avcodec_get_frame_defaults(&s->picture[i].f);

     }

     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)

@@ -1247,10 +1247,8 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)

                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);

             }

-            ff_thread_report_progress((AVFrame *) s->last_picture_ptr,

-                                      INT_MAX, 0);

-            ff_thread_report_progress((AVFrame *) s->last_picture_ptr,

-                                      INT_MAX, 1);

+            ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);

+            ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);

         }

         if ((s->next_picture_ptr == NULL ||

              s->next_picture_ptr->f.data[0] == NULL) &&

@@ -1263,10 +1261,8 @@ int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)

             s->next_picture_ptr->f.key_frame = 0;

             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)

                 return -1;

-            ff_thread_report_progress((AVFrame *) s->next_picture_ptr,

-                                      INT_MAX, 0);

-            ff_thread_report_progress((AVFrame *) s->next_picture_ptr,

-                                      INT_MAX, 1);

+            ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);

+            ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);

         }

     }

@@ -1391,10 +1387,10 @@ void ff_MPV_frame_end(MpegEncContext *s)

     memset(&s->next_picture,    0, sizeof(Picture));

     memset(&s->current_picture, 0, sizeof(Picture));

 #endif

-    s->avctx->coded_frame = (AVFrame *) s->current_picture_ptr;

+    s->avctx->coded_frame = &s->current_picture_ptr->f;

     if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {

-        ff_thread_report_progress((AVFrame *) s->current_picture_ptr,

+        ff_thread_report_progress(&s->current_picture_ptr->f,

                                   s->mb_height - 1, 0);

     }

 }

@@ -2346,10 +2342,14 @@ void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],

                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {

                     if (s->mv_dir & MV_DIR_FORWARD) {

-                        ff_thread_await_progress((AVFrame*)s->last_picture_ptr, ff_MPV_lowest_referenced_row(s, 0), 0);

+                        ff_thread_await_progress(&s->last_picture_ptr->f,

+                                                 ff_MPV_lowest_referenced_row(s, 0),

+                                                 0);

                     }

                     if (s->mv_dir & MV_DIR_BACKWARD) {

-                        ff_thread_await_progress((AVFrame*)s->next_picture_ptr, ff_MPV_lowest_referenced_row(s, 1), 0);

+                        ff_thread_await_progress(&s->next_picture_ptr->f,

+                                                 ff_MPV_lowest_referenced_row(s, 1),

+                                                 0);

                     }

                 }

@@ -2556,9 +2556,9 @@ void ff_draw_horiz_band(MpegEncContext *s, int y, int h){

         int i;

         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))

-            src= (AVFrame*)s->current_picture_ptr;

+            src = &s->current_picture_ptr->f;

         else if(s->last_picture_ptr)

-            src= (AVFrame*)s->last_picture_ptr;

+            src = &s->last_picture_ptr->f;

         else

             return;

@@ -2867,5 +2867,5 @@ void ff_set_qscale(MpegEncContext * s, int qscale)

 void ff_MPV_report_decode_progress(MpegEncContext *s)

 {

     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)

-        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);

+        ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);

 }

@@ -981,7 +981,7 @@ static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)