split out ff_hwaccel_pixfmt_list_420[] over individual codecs.
[ffmpeg.git] / libavcodec / mpegvideo.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "libavutil/imgutils.h"
31 #include "avcodec.h"
32 #include "dsputil.h"
33 #include "h264chroma.h"
34 #include "internal.h"
35 #include "mathops.h"
36 #include "mpegvideo.h"
37 #include "mjpegenc.h"
38 #include "msmpeg4.h"
39 #include "xvmc_internal.h"
40 #include "thread.h"
41 #include <limits.h>
42
43 //#undef NDEBUG
44 //#include <assert.h>
45
46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
47                                    int16_t *block, int n, int qscale);
48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
49                                    int16_t *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
51                                    int16_t *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
53                                    int16_t *block, int n, int qscale);
54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
55                                    int16_t *block, int n, int qscale);
56 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
57                                   int16_t *block, int n, int qscale);
58 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
59                                   int16_t *block, int n, int qscale);
60
61
62 //#define DEBUG
63
64
65 static const uint8_t ff_default_chroma_qscale_table[32] = {
66 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
67      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
68     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
69 };
70
71 const uint8_t ff_mpeg1_dc_scale_table[128] = {
72 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
73     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81 };
82
83 static const uint8_t mpeg2_dc_scale_table1[128] = {
84 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
85     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93 };
94
95 static const uint8_t mpeg2_dc_scale_table2[128] = {
96 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
97     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105 };
106
107 static const uint8_t mpeg2_dc_scale_table3[128] = {
108 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
109     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
111     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117 };
118
119 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
120     ff_mpeg1_dc_scale_table,
121     mpeg2_dc_scale_table1,
122     mpeg2_dc_scale_table2,
123     mpeg2_dc_scale_table3,
124 };
125
126 const enum AVPixelFormat ff_pixfmt_list_420[] = {
127     AV_PIX_FMT_YUV420P,
128     AV_PIX_FMT_NONE
129 };
130
131 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
132                               int (*mv)[2][4][2],
133                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
134 {
135     MpegEncContext *s = opaque;
136
137     s->mv_dir     = mv_dir;
138     s->mv_type    = mv_type;
139     s->mb_intra   = mb_intra;
140     s->mb_skipped = mb_skipped;
141     s->mb_x       = mb_x;
142     s->mb_y       = mb_y;
143     memcpy(s->mv, mv, sizeof(*mv));
144
145     ff_init_block_index(s);
146     ff_update_block_index(s);
147
148     s->dsp.clear_blocks(s->block[0]);
149
150     s->dest[0] = s->current_picture.f.data[0] + (s->mb_y *  16                       * s->linesize)   + s->mb_x *  16;
151     s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
152     s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
153
154     assert(ref == 0);
155     ff_MPV_decode_mb(s, s->block);
156 }
157
158 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
159                                           const uint8_t *end,
160                                           uint32_t *av_restrict state)
161 {
162     int i;
163
164     assert(p <= end);
165     if (p >= end)
166         return end;
167
168     for (i = 0; i < 3; i++) {
169         uint32_t tmp = *state << 8;
170         *state = tmp + *(p++);
171         if (tmp == 0x100 || p == end)
172             return p;
173     }
174
175     while (p < end) {
176         if      (p[-1] > 1      ) p += 3;
177         else if (p[-2]          ) p += 2;
178         else if (p[-3]|(p[-1]-1)) p++;
179         else {
180             p++;
181             break;
182         }
183     }
184
185     p = FFMIN(p, end) - 4;
186     *state = AV_RB32(p);
187
188     return p + 4;
189 }
190
191 /* init common dct for both encoder and decoder */
192 av_cold int ff_dct_common_init(MpegEncContext *s)
193 {
194     ff_dsputil_init(&s->dsp, s->avctx);
195     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
196     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
197
198     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
199     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
200     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
201     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
202     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
203     if (s->flags & CODEC_FLAG_BITEXACT)
204         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
205     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
206
207 #if ARCH_X86
208     ff_MPV_common_init_x86(s);
209 #elif ARCH_ALPHA
210     ff_MPV_common_init_axp(s);
211 #elif ARCH_ARM
212     ff_MPV_common_init_arm(s);
213 #elif HAVE_ALTIVEC
214     ff_MPV_common_init_altivec(s);
215 #elif ARCH_BFIN
216     ff_MPV_common_init_bfin(s);
217 #endif
218
219     /* load & permutate scantables
220      * note: only wmv uses different ones
221      */
222     if (s->alternate_scan) {
223         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
224         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
225     } else {
226         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
227         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
228     }
229     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
230     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
231
232     return 0;
233 }
234
235 void ff_copy_picture(Picture *dst, Picture *src)
236 {
237     *dst = *src;
238     dst->f.type = FF_BUFFER_TYPE_COPY;
239 }
240
241 /**
242  * Release a frame buffer
243  */
244 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
245 {
246     pic->period_since_free = 0;
247     /* WM Image / Screen codecs allocate internal buffers with different
248      * dimensions / colorspaces; ignore user-defined callbacks for these. */
249     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
250         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
251         s->codec_id != AV_CODEC_ID_MSS2)
252         ff_thread_release_buffer(s->avctx, &pic->f);
253     else
254         avcodec_default_release_buffer(s->avctx, &pic->f);
255     av_freep(&pic->f.hwaccel_picture_private);
256 }
257
258 int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
259 {
260     int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
261
262     // edge emu needs blocksize + filter length - 1
263     // (= 17x17 for  halfpel / 21x21 for  h264)
264     // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
265     // at uvlinesize. It supports only YUV420 so 24x24 is enough
266     // linesize * interlaced * MBsize
267     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
268                       fail);
269
270     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
271                       fail)
272     s->me.temp         = s->me.scratchpad;
273     s->rd_scratchpad   = s->me.scratchpad;
274     s->b_scratchpad    = s->me.scratchpad;
275     s->obmc_scratchpad = s->me.scratchpad + 16;
276
277     return 0;
278 fail:
279     av_freep(&s->edge_emu_buffer);
280     return AVERROR(ENOMEM);
281 }
282
283 /**
284  * Allocate a frame buffer
285  */
286 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
287 {
288     int r, ret;
289
290     if (s->avctx->hwaccel) {
291         assert(!pic->f.hwaccel_picture_private);
292         if (s->avctx->hwaccel->priv_data_size) {
293             pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
294             if (!pic->f.hwaccel_picture_private) {
295                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
296                 return -1;
297             }
298         }
299     }
300
301     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
302         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
303         s->codec_id != AV_CODEC_ID_MSS2)
304         r = ff_thread_get_buffer(s->avctx, &pic->f);
305     else
306         r = avcodec_default_get_buffer(s->avctx, &pic->f);
307
308     if (r < 0 || !pic->f.type || !pic->f.data[0]) {
309         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
310                r, pic->f.type, pic->f.data[0]);
311         av_freep(&pic->f.hwaccel_picture_private);
312         return -1;
313     }
314
315     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
316                         s->uvlinesize != pic->f.linesize[1])) {
317         av_log(s->avctx, AV_LOG_ERROR,
318                "get_buffer() failed (stride changed)\n");
319         free_frame_buffer(s, pic);
320         return -1;
321     }
322
323     if (pic->f.linesize[1] != pic->f.linesize[2]) {
324         av_log(s->avctx, AV_LOG_ERROR,
325                "get_buffer() failed (uv stride mismatch)\n");
326         free_frame_buffer(s, pic);
327         return -1;
328     }
329
330     if (!s->edge_emu_buffer &&
331         (ret = ff_mpv_frame_size_alloc(s, pic->f.linesize[0])) < 0) {
332         av_log(s->avctx, AV_LOG_ERROR,
333                "get_buffer() failed to allocate context scratch buffers.\n");
334         free_frame_buffer(s, pic);
335         return ret;
336     }
337
338     return 0;
339 }
340
341 /**
342  * Allocate a Picture.
343  * The pixels are allocated/set by calling get_buffer() if shared = 0
344  */
345 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
346 {
347     const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
348
349     // the + 1 is needed so memset(,,stride*height) does not sig11
350
351     const int mb_array_size = s->mb_stride * s->mb_height;
352     const int b8_array_size = s->b8_stride * s->mb_height * 2;
353     const int b4_array_size = s->b4_stride * s->mb_height * 4;
354     int i;
355     int r = -1;
356
357     if (shared) {
358         assert(pic->f.data[0]);
359         assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
360         pic->f.type = FF_BUFFER_TYPE_SHARED;
361     } else {
362         assert(!pic->f.data[0]);
363
364         if (alloc_frame_buffer(s, pic) < 0)
365             return -1;
366
367         s->linesize   = pic->f.linesize[0];
368         s->uvlinesize = pic->f.linesize[1];
369     }
370
371     if (pic->f.qscale_table == NULL) {
372         if (s->encoding) {
373             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
374                               mb_array_size * sizeof(int16_t), fail)
375             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
376                               mb_array_size * sizeof(int16_t), fail)
377             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
378                               mb_array_size * sizeof(int8_t ), fail)
379         }
380
381         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
382                           mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
383         FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
384                           (big_mb_num + s->mb_stride) * sizeof(uint8_t),
385                           fail)
386         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
387                           (big_mb_num + s->mb_stride) * sizeof(uint32_t),
388                           fail)
389         pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
390         pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
391         if (s->out_format == FMT_H264) {
392             for (i = 0; i < 2; i++) {
393                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
394                                   2 * (b4_array_size + 4) * sizeof(int16_t),
395                                   fail)
396                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
397                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
398                                   4 * mb_array_size * sizeof(uint8_t), fail)
399             }
400             pic->f.motion_subsample_log2 = 2;
401         } else if (s->out_format == FMT_H263 || s->encoding ||
402                    (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
403             for (i = 0; i < 2; i++) {
404                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
405                                   2 * (b8_array_size + 4) * sizeof(int16_t),
406                                   fail)
407                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
408                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
409                                   4 * mb_array_size * sizeof(uint8_t), fail)
410             }
411             pic->f.motion_subsample_log2 = 3;
412         }
413         if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
414             FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
415                               64 * mb_array_size * sizeof(int16_t) * 6, fail)
416         }
417         pic->f.qstride = s->mb_stride;
418         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
419                           1 * sizeof(AVPanScan), fail)
420     }
421
422     pic->owner2 = s;
423
424     return 0;
425 fail: // for  the FF_ALLOCZ_OR_GOTO macro
426     if (r >= 0)
427         free_frame_buffer(s, pic);
428     return -1;
429 }
430
431 /**
432  * Deallocate a picture.
433  */
434 static void free_picture(MpegEncContext *s, Picture *pic)
435 {
436     int i;
437
438     if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
439         free_frame_buffer(s, pic);
440     }
441
442     av_freep(&pic->mb_var);
443     av_freep(&pic->mc_mb_var);
444     av_freep(&pic->mb_mean);
445     av_freep(&pic->f.mbskip_table);
446     av_freep(&pic->qscale_table_base);
447     pic->f.qscale_table = NULL;
448     av_freep(&pic->mb_type_base);
449     pic->f.mb_type = NULL;
450     av_freep(&pic->f.dct_coeff);
451     av_freep(&pic->f.pan_scan);
452     pic->f.mb_type = NULL;
453     for (i = 0; i < 2; i++) {
454         av_freep(&pic->motion_val_base[i]);
455         av_freep(&pic->f.ref_index[i]);
456         pic->f.motion_val[i] = NULL;
457     }
458
459     if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
460         for (i = 0; i < 4; i++) {
461             pic->f.base[i] =
462             pic->f.data[i] = NULL;
463         }
464         pic->f.type = 0;
465     }
466 }
467
468 static int init_duplicate_context(MpegEncContext *s)
469 {
470     int y_size = s->b8_stride * (2 * s->mb_height + 1);
471     int c_size = s->mb_stride * (s->mb_height + 1);
472     int yc_size = y_size + 2 * c_size;
473     int i;
474
475     s->edge_emu_buffer =
476     s->me.scratchpad   =
477     s->me.temp         =
478     s->rd_scratchpad   =
479     s->b_scratchpad    =
480     s->obmc_scratchpad = NULL;
481
482     if (s->encoding) {
483         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
484                           ME_MAP_SIZE * sizeof(uint32_t), fail)
485         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
486                           ME_MAP_SIZE * sizeof(uint32_t), fail)
487         if (s->avctx->noise_reduction) {
488             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
489                               2 * 64 * sizeof(int), fail)
490         }
491     }
492     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
493     s->block = s->blocks[0];
494
495     for (i = 0; i < 12; i++) {
496         s->pblocks[i] = &s->block[i];
497     }
498
499     if (s->out_format == FMT_H263) {
500         /* ac values */
501         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
502                           yc_size * sizeof(int16_t) * 16, fail);
503         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
504         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
505         s->ac_val[2] = s->ac_val[1] + c_size;
506     }
507
508     return 0;
509 fail:
510     return -1; // free() through ff_MPV_common_end()
511 }
512
513 static void free_duplicate_context(MpegEncContext *s)
514 {
515     if (s == NULL)
516         return;
517
518     av_freep(&s->edge_emu_buffer);
519     av_freep(&s->me.scratchpad);
520     s->me.temp =
521     s->rd_scratchpad =
522     s->b_scratchpad =
523     s->obmc_scratchpad = NULL;
524
525     av_freep(&s->dct_error_sum);
526     av_freep(&s->me.map);
527     av_freep(&s->me.score_map);
528     av_freep(&s->blocks);
529     av_freep(&s->ac_val_base);
530     s->block = NULL;
531 }
532
533 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
534 {
535 #define COPY(a) bak->a = src->a
536     COPY(edge_emu_buffer);
537     COPY(me.scratchpad);
538     COPY(me.temp);
539     COPY(rd_scratchpad);
540     COPY(b_scratchpad);
541     COPY(obmc_scratchpad);
542     COPY(me.map);
543     COPY(me.score_map);
544     COPY(blocks);
545     COPY(block);
546     COPY(start_mb_y);
547     COPY(end_mb_y);
548     COPY(me.map_generation);
549     COPY(pb);
550     COPY(dct_error_sum);
551     COPY(dct_count[0]);
552     COPY(dct_count[1]);
553     COPY(ac_val_base);
554     COPY(ac_val[0]);
555     COPY(ac_val[1]);
556     COPY(ac_val[2]);
557 #undef COPY
558 }
559
560 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
561 {
562     MpegEncContext bak;
563     int i, ret;
564     // FIXME copy only needed parts
565     // START_TIMER
566     backup_duplicate_context(&bak, dst);
567     memcpy(dst, src, sizeof(MpegEncContext));
568     backup_duplicate_context(dst, &bak);
569     for (i = 0; i < 12; i++) {
570         dst->pblocks[i] = &dst->block[i];
571     }
572     if (!dst->edge_emu_buffer &&
573         (ret = ff_mpv_frame_size_alloc(dst, dst->linesize)) < 0) {
574         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
575                "scratch buffers.\n");
576         return ret;
577     }
578     // STOP_TIMER("update_duplicate_context")
579     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
580     return 0;
581 }
582
583 int ff_mpeg_update_thread_context(AVCodecContext *dst,
584                                   const AVCodecContext *src)
585 {
586     int i;
587     int err;
588     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
589
590     if (dst == src)
591         return 0;
592
593     av_assert0(s != s1);
594
595     // FIXME can parameters change on I-frames?
596     // in that case dst may need a reinit
597     if (!s->context_initialized) {
598         memcpy(s, s1, sizeof(MpegEncContext));
599
600         s->avctx                 = dst;
601         s->bitstream_buffer      = NULL;
602         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
603
604         if (s1->context_initialized){
605             s->picture_range_start  += MAX_PICTURE_COUNT;
606             s->picture_range_end    += MAX_PICTURE_COUNT;
607             if((err = ff_MPV_common_init(s)) < 0){
608                 memset(s, 0, sizeof(MpegEncContext));
609                 s->avctx = dst;
610                 return err;
611             }
612         }
613     }
614
615     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
616         s->context_reinit = 0;
617         s->height = s1->height;
618         s->width  = s1->width;
619         if ((err = ff_MPV_common_frame_size_change(s)) < 0)
620             return err;
621     }
622
623     s->avctx->coded_height  = s1->avctx->coded_height;
624     s->avctx->coded_width   = s1->avctx->coded_width;
625     s->avctx->width         = s1->avctx->width;
626     s->avctx->height        = s1->avctx->height;
627
628     s->coded_picture_number = s1->coded_picture_number;
629     s->picture_number       = s1->picture_number;
630     s->input_picture_number = s1->input_picture_number;
631
632     av_assert0(!s->picture || s->picture != s1->picture);
633     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
634     memcpy(&s->last_picture, &s1->last_picture,
635            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
636
637     // reset s->picture[].f.extended_data to s->picture[].f.data
638     for (i = 0; i < s->picture_count; i++) {
639         s->picture[i].f.extended_data = s->picture[i].f.data;
640         s->picture[i].period_since_free ++;
641     }
642
643     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
644     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
645     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
646
647     // Error/bug resilience
648     s->next_p_frame_damaged = s1->next_p_frame_damaged;
649     s->workaround_bugs      = s1->workaround_bugs;
650     s->padding_bug_score    = s1->padding_bug_score;
651
652     // MPEG4 timing info
653     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
654            (char *) &s1->shape - (char *) &s1->time_increment_bits);
655
656     // B-frame info
657     s->max_b_frames = s1->max_b_frames;
658     s->low_delay    = s1->low_delay;
659     s->droppable    = s1->droppable;
660
661     // DivX handling (doesn't work)
662     s->divx_packed  = s1->divx_packed;
663
664     if (s1->bitstream_buffer) {
665         if (s1->bitstream_buffer_size +
666             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
667             av_fast_malloc(&s->bitstream_buffer,
668                            &s->allocated_bitstream_buffer_size,
669                            s1->allocated_bitstream_buffer_size);
670             s->bitstream_buffer_size = s1->bitstream_buffer_size;
671         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
672                s1->bitstream_buffer_size);
673         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
674                FF_INPUT_BUFFER_PADDING_SIZE);
675     }
676
677     // linesize dependend scratch buffer allocation
678     if (!s->edge_emu_buffer)
679         if (s1->linesize) {
680             if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
681                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
682                        "scratch buffers.\n");
683                 return AVERROR(ENOMEM);
684             }
685         } else {
686             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
687                    "be allocated due to unknown size.\n");
688         }
689
690     // MPEG2/interlacing info
691     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
692            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
693
694     if (!s1->first_field) {
695         s->last_pict_type = s1->pict_type;
696         if (s1->current_picture_ptr)
697             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
698
699         if (s1->pict_type != AV_PICTURE_TYPE_B) {
700             s->last_non_b_pict_type = s1->pict_type;
701         }
702     }
703
704     return 0;
705 }
706
707 /**
708  * Set the given MpegEncContext to common defaults
709  * (same for encoding and decoding).
710  * The changed fields will not depend upon the
711  * prior state of the MpegEncContext.
712  */
713 void ff_MPV_common_defaults(MpegEncContext *s)
714 {
715     s->y_dc_scale_table      =
716     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
717     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
718     s->progressive_frame     = 1;
719     s->progressive_sequence  = 1;
720     s->picture_structure     = PICT_FRAME;
721
722     s->coded_picture_number  = 0;
723     s->picture_number        = 0;
724     s->input_picture_number  = 0;
725
726     s->picture_in_gop_number = 0;
727
728     s->f_code                = 1;
729     s->b_code                = 1;
730
731     s->picture_range_start   = 0;
732     s->picture_range_end     = MAX_PICTURE_COUNT;
733
734     s->slice_context_count   = 1;
735 }
736
737 /**
738  * Set the given MpegEncContext to defaults for decoding.
739  * the changed fields will not depend upon
740  * the prior state of the MpegEncContext.
741  */
742 void ff_MPV_decode_defaults(MpegEncContext *s)
743 {
744     ff_MPV_common_defaults(s);
745 }
746
747 static int init_er(MpegEncContext *s)
748 {
749     ERContext *er = &s->er;
750     int mb_array_size = s->mb_height * s->mb_stride;
751     int i;
752
753     er->avctx       = s->avctx;
754     er->dsp         = &s->dsp;
755
756     er->mb_index2xy = s->mb_index2xy;
757     er->mb_num      = s->mb_num;
758     er->mb_width    = s->mb_width;
759     er->mb_height   = s->mb_height;
760     er->mb_stride   = s->mb_stride;
761     er->b8_stride   = s->b8_stride;
762
763     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
764     er->error_status_table = av_mallocz(mb_array_size);
765     if (!er->er_temp_buffer || !er->error_status_table)
766         goto fail;
767
768     er->mbskip_table  = s->mbskip_table;
769     er->mbintra_table = s->mbintra_table;
770
771     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
772         er->dc_val[i] = s->dc_val[i];
773
774     er->decode_mb = mpeg_er_decode_mb;
775     er->opaque    = s;
776
777     return 0;
778 fail:
779     av_freep(&er->er_temp_buffer);
780     av_freep(&er->error_status_table);
781     return AVERROR(ENOMEM);
782 }
783
784 /**
785  * Initialize and allocates MpegEncContext fields dependent on the resolution.
786  */
787 static int init_context_frame(MpegEncContext *s)
788 {
789     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
790
791     s->mb_width   = (s->width + 15) / 16;
792     s->mb_stride  = s->mb_width + 1;
793     s->b8_stride  = s->mb_width * 2 + 1;
794     s->b4_stride  = s->mb_width * 4 + 1;
795     mb_array_size = s->mb_height * s->mb_stride;
796     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
797
798     /* set default edge pos, will be overriden
799      * in decode_header if needed */
800     s->h_edge_pos = s->mb_width * 16;
801     s->v_edge_pos = s->mb_height * 16;
802
803     s->mb_num     = s->mb_width * s->mb_height;
804
805     s->block_wrap[0] =
806     s->block_wrap[1] =
807     s->block_wrap[2] =
808     s->block_wrap[3] = s->b8_stride;
809     s->block_wrap[4] =
810     s->block_wrap[5] = s->mb_stride;
811
812     y_size  = s->b8_stride * (2 * s->mb_height + 1);
813     c_size  = s->mb_stride * (s->mb_height + 1);
814     yc_size = y_size + 2   * c_size;
815
816     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
817     for (y = 0; y < s->mb_height; y++)
818         for (x = 0; x < s->mb_width; x++)
819             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
820
821     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
822
823     if (s->encoding) {
824         /* Allocate MV tables */
825         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
826         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
827         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
828         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
829         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
830         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
831         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
832         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
833         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
834         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
835         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
836         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
837
838         /* Allocate MB type table */
839         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
840
841         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
842
843         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
844                          mb_array_size * sizeof(float), fail);
845         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
846                          mb_array_size * sizeof(float), fail);
847
848     }
849
850     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
851         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
852         /* interlaced direct mode decoding tables */
853         for (i = 0; i < 2; i++) {
854             int j, k;
855             for (j = 0; j < 2; j++) {
856                 for (k = 0; k < 2; k++) {
857                     FF_ALLOCZ_OR_GOTO(s->avctx,
858                                       s->b_field_mv_table_base[i][j][k],
859                                       mv_table_size * 2 * sizeof(int16_t),
860                                       fail);
861                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
862                                                    s->mb_stride + 1;
863                 }
864                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
865                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
866                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
867             }
868             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
869         }
870     }
871     if (s->out_format == FMT_H263) {
872         /* cbp values */
873         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
874         s->coded_block = s->coded_block_base + s->b8_stride + 1;
875
876         /* cbp, ac_pred, pred_dir */
877         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
878         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
879     }
880
881     if (s->h263_pred || s->h263_plus || !s->encoding) {
882         /* dc values */
883         // MN: we need these for  error resilience of intra-frames
884         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
885         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
886         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
887         s->dc_val[2] = s->dc_val[1] + c_size;
888         for (i = 0; i < yc_size; i++)
889             s->dc_val_base[i] = 1024;
890     }
891
892     /* which mb is a intra block */
893     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
894     memset(s->mbintra_table, 1, mb_array_size);
895
896     /* init macroblock skip table */
897     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
898     // Note the + 1 is for  a quicker mpeg4 slice_end detection
899
900     return init_er(s);
901 fail:
902     return AVERROR(ENOMEM);
903 }
904
905 /**
906  * init common structure for both encoder and decoder.
907  * this assumes that some variables like width/height are already set
908  */
909 av_cold int ff_MPV_common_init(MpegEncContext *s)
910 {
911     int i;
912     int nb_slices = (HAVE_THREADS &&
913                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
914                     s->avctx->thread_count : 1;
915
916     if (s->encoding && s->avctx->slices)
917         nb_slices = s->avctx->slices;
918
919     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
920         s->mb_height = (s->height + 31) / 32 * 2;
921     else if (s->codec_id != AV_CODEC_ID_H264)
922         s->mb_height = (s->height + 15) / 16;
923
924     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
925         av_log(s->avctx, AV_LOG_ERROR,
926                "decoding to AV_PIX_FMT_NONE is not supported.\n");
927         return -1;
928     }
929
930     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
931         int max_slices;
932         if (s->mb_height)
933             max_slices = FFMIN(MAX_THREADS, s->mb_height);
934         else
935             max_slices = MAX_THREADS;
936         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
937                " reducing to %d\n", nb_slices, max_slices);
938         nb_slices = max_slices;
939     }
940
941     if ((s->width || s->height) &&
942         av_image_check_size(s->width, s->height, 0, s->avctx))
943         return -1;
944
945     ff_dct_common_init(s);
946
947     s->flags  = s->avctx->flags;
948     s->flags2 = s->avctx->flags2;
949
950     /* set chroma shifts */
951     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
952
953     /* convert fourcc to upper case */
954     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
955     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
956
957     s->avctx->coded_frame = &s->current_picture.f;
958
959     if (s->encoding) {
960         if (s->msmpeg4_version) {
961             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
962                                 2 * 2 * (MAX_LEVEL + 1) *
963                                 (MAX_RUN + 1) * 2 * sizeof(int), fail);
964         }
965         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
966
967         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
968         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
969         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
970         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
971         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
972         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
973         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
974         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
975
976         if (s->avctx->noise_reduction) {
977             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
978         }
979     }
980
981     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
982     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
983                       s->picture_count * sizeof(Picture), fail);
984     for (i = 0; i < s->picture_count; i++) {
985         avcodec_get_frame_defaults(&s->picture[i].f);
986     }
987
988         if (init_context_frame(s))
989             goto fail;
990
991         s->parse_context.state = -1;
992
993         s->context_initialized = 1;
994         s->thread_context[0]   = s;
995
996 //     if (s->width && s->height) {
997         if (nb_slices > 1) {
998             for (i = 1; i < nb_slices; i++) {
999                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1000                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1001             }
1002
1003             for (i = 0; i < nb_slices; i++) {
1004                 if (init_duplicate_context(s->thread_context[i]) < 0)
1005                     goto fail;
1006                     s->thread_context[i]->start_mb_y =
1007                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1008                     s->thread_context[i]->end_mb_y   =
1009                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1010             }
1011         } else {
1012             if (init_duplicate_context(s) < 0)
1013                 goto fail;
1014             s->start_mb_y = 0;
1015             s->end_mb_y   = s->mb_height;
1016         }
1017         s->slice_context_count = nb_slices;
1018 //     }
1019
1020     return 0;
1021  fail:
1022     ff_MPV_common_end(s);
1023     return -1;
1024 }
1025
1026 /**
1027  * Frees and resets MpegEncContext fields depending on the resolution.
1028  * Is used during resolution changes to avoid a full reinitialization of the
1029  * codec.
1030  */
1031 static int free_context_frame(MpegEncContext *s)
1032 {
1033     int i, j, k;
1034
1035     av_freep(&s->mb_type);
1036     av_freep(&s->p_mv_table_base);
1037     av_freep(&s->b_forw_mv_table_base);
1038     av_freep(&s->b_back_mv_table_base);
1039     av_freep(&s->b_bidir_forw_mv_table_base);
1040     av_freep(&s->b_bidir_back_mv_table_base);
1041     av_freep(&s->b_direct_mv_table_base);
1042     s->p_mv_table            = NULL;
1043     s->b_forw_mv_table       = NULL;
1044     s->b_back_mv_table       = NULL;
1045     s->b_bidir_forw_mv_table = NULL;
1046     s->b_bidir_back_mv_table = NULL;
1047     s->b_direct_mv_table     = NULL;
1048     for (i = 0; i < 2; i++) {
1049         for (j = 0; j < 2; j++) {
1050             for (k = 0; k < 2; k++) {
1051                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1052                 s->b_field_mv_table[i][j][k] = NULL;
1053             }
1054             av_freep(&s->b_field_select_table[i][j]);
1055             av_freep(&s->p_field_mv_table_base[i][j]);
1056             s->p_field_mv_table[i][j] = NULL;
1057         }
1058         av_freep(&s->p_field_select_table[i]);
1059     }
1060
1061     av_freep(&s->dc_val_base);
1062     av_freep(&s->coded_block_base);
1063     av_freep(&s->mbintra_table);
1064     av_freep(&s->cbp_table);
1065     av_freep(&s->pred_dir_table);
1066
1067     av_freep(&s->mbskip_table);
1068
1069     av_freep(&s->er.error_status_table);
1070     av_freep(&s->er.er_temp_buffer);
1071     av_freep(&s->mb_index2xy);
1072     av_freep(&s->lambda_table);
1073
1074     av_freep(&s->cplx_tab);
1075     av_freep(&s->bits_tab);
1076
1077     s->linesize = s->uvlinesize = 0;
1078
1079     for (i = 0; i < 3; i++)
1080         av_freep(&s->visualization_buffer[i]);
1081
1082     return 0;
1083 }
1084
1085 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1086 {
1087     int i, err = 0;
1088
1089     if (s->slice_context_count > 1) {
1090         for (i = 0; i < s->slice_context_count; i++) {
1091             free_duplicate_context(s->thread_context[i]);
1092         }
1093         for (i = 1; i < s->slice_context_count; i++) {
1094             av_freep(&s->thread_context[i]);
1095         }
1096     } else
1097         free_duplicate_context(s);
1098
1099     free_context_frame(s);
1100
1101     if (s->picture)
1102         for (i = 0; i < s->picture_count; i++) {
1103                 s->picture[i].needs_realloc = 1;
1104         }
1105
1106     s->last_picture_ptr         =
1107     s->next_picture_ptr         =
1108     s->current_picture_ptr      = NULL;
1109
1110     // init
1111     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1112         s->mb_height = (s->height + 31) / 32 * 2;
1113     else if (s->codec_id != AV_CODEC_ID_H264)
1114         s->mb_height = (s->height + 15) / 16;
1115
1116     if ((s->width || s->height) &&
1117         av_image_check_size(s->width, s->height, 0, s->avctx))
1118         return AVERROR_INVALIDDATA;
1119
1120     if ((err = init_context_frame(s)))
1121         goto fail;
1122
1123     s->thread_context[0]   = s;
1124
1125     if (s->width && s->height) {
1126         int nb_slices = s->slice_context_count;
1127         if (nb_slices > 1) {
1128             for (i = 1; i < nb_slices; i++) {
1129                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1130                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1131             }
1132
1133             for (i = 0; i < nb_slices; i++) {
1134                 if (init_duplicate_context(s->thread_context[i]) < 0)
1135                     goto fail;
1136                     s->thread_context[i]->start_mb_y =
1137                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1138                     s->thread_context[i]->end_mb_y   =
1139                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1140             }
1141         } else {
1142             if (init_duplicate_context(s) < 0)
1143                 goto fail;
1144             s->start_mb_y = 0;
1145             s->end_mb_y   = s->mb_height;
1146         }
1147         s->slice_context_count = nb_slices;
1148     }
1149
1150     return 0;
1151  fail:
1152     ff_MPV_common_end(s);
1153     return err;
1154 }
1155
1156 /* init common structure for both encoder and decoder */
1157 void ff_MPV_common_end(MpegEncContext *s)
1158 {
1159     int i;
1160
1161     if (s->slice_context_count > 1) {
1162         for (i = 0; i < s->slice_context_count; i++) {
1163             free_duplicate_context(s->thread_context[i]);
1164         }
1165         for (i = 1; i < s->slice_context_count; i++) {
1166             av_freep(&s->thread_context[i]);
1167         }
1168         s->slice_context_count = 1;
1169     } else free_duplicate_context(s);
1170
1171     av_freep(&s->parse_context.buffer);
1172     s->parse_context.buffer_size = 0;
1173
1174     av_freep(&s->bitstream_buffer);
1175     s->allocated_bitstream_buffer_size = 0;
1176
1177     av_freep(&s->avctx->stats_out);
1178     av_freep(&s->ac_stats);
1179
1180     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1181     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1182     s->q_chroma_intra_matrix=   NULL;
1183     s->q_chroma_intra_matrix16= NULL;
1184     av_freep(&s->q_intra_matrix);
1185     av_freep(&s->q_inter_matrix);
1186     av_freep(&s->q_intra_matrix16);
1187     av_freep(&s->q_inter_matrix16);
1188     av_freep(&s->input_picture);
1189     av_freep(&s->reordered_input_picture);
1190     av_freep(&s->dct_offset);
1191
1192     if (s->picture && !s->avctx->internal->is_copy) {
1193         for (i = 0; i < s->picture_count; i++) {
1194             free_picture(s, &s->picture[i]);
1195         }
1196     }
1197     av_freep(&s->picture);
1198
1199     free_context_frame(s);
1200
1201     if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1202         avcodec_default_free_buffers(s->avctx);
1203
1204     s->context_initialized      = 0;
1205     s->last_picture_ptr         =
1206     s->next_picture_ptr         =
1207     s->current_picture_ptr      = NULL;
1208     s->linesize = s->uvlinesize = 0;
1209 }
1210
1211 void ff_init_rl(RLTable *rl,
1212                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1213 {
1214     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1215     uint8_t index_run[MAX_RUN + 1];
1216     int last, run, level, start, end, i;
1217
1218     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1219     if (static_store && rl->max_level[0])
1220         return;
1221
1222     /* compute max_level[], max_run[] and index_run[] */
1223     for (last = 0; last < 2; last++) {
1224         if (last == 0) {
1225             start = 0;
1226             end = rl->last;
1227         } else {
1228             start = rl->last;
1229             end = rl->n;
1230         }
1231
1232         memset(max_level, 0, MAX_RUN + 1);
1233         memset(max_run, 0, MAX_LEVEL + 1);
1234         memset(index_run, rl->n, MAX_RUN + 1);
1235         for (i = start; i < end; i++) {
1236             run   = rl->table_run[i];
1237             level = rl->table_level[i];
1238             if (index_run[run] == rl->n)
1239                 index_run[run] = i;
1240             if (level > max_level[run])
1241                 max_level[run] = level;
1242             if (run > max_run[level])
1243                 max_run[level] = run;
1244         }
1245         if (static_store)
1246             rl->max_level[last] = static_store[last];
1247         else
1248             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1249         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1250         if (static_store)
1251             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1252         else
1253             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1254         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1255         if (static_store)
1256             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1257         else
1258             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1259         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1260     }
1261 }
1262
1263 void ff_init_vlc_rl(RLTable *rl)
1264 {
1265     int i, q;
1266
1267     for (q = 0; q < 32; q++) {
1268         int qmul = q * 2;
1269         int qadd = (q - 1) | 1;
1270
1271         if (q == 0) {
1272             qmul = 1;
1273             qadd = 0;
1274         }
1275         for (i = 0; i < rl->vlc.table_size; i++) {
1276             int code = rl->vlc.table[i][0];
1277             int len  = rl->vlc.table[i][1];
1278             int level, run;
1279
1280             if (len == 0) { // illegal code
1281                 run   = 66;
1282                 level = MAX_LEVEL;
1283             } else if (len < 0) { // more bits needed
1284                 run   = 0;
1285                 level = code;
1286             } else {
1287                 if (code == rl->n) { // esc
1288                     run   = 66;
1289                     level =  0;
1290                 } else {
1291                     run   = rl->table_run[code] + 1;
1292                     level = rl->table_level[code] * qmul + qadd;
1293                     if (code >= rl->last) run += 192;
1294                 }
1295             }
1296             rl->rl_vlc[q][i].len   = len;
1297             rl->rl_vlc[q][i].level = level;
1298             rl->rl_vlc[q][i].run   = run;
1299         }
1300     }
1301 }
1302
1303 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1304 {
1305     int i;
1306
1307     /* release non reference frames */
1308     for (i = 0; i < s->picture_count; i++) {
1309         if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1310             (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1311             (remove_current || &s->picture[i] !=  s->current_picture_ptr)
1312             /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1313             free_frame_buffer(s, &s->picture[i]);
1314         }
1315     }
1316 }
1317
1318 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1319 {
1320     if (   (s->avctx->active_thread_type & FF_THREAD_FRAME)
1321         && pic->f.qscale_table //check if the frame has anything allocated
1322         && pic->period_since_free < s->avctx->thread_count)
1323         return 0;
1324     if (pic->f.data[0] == NULL)
1325         return 1;
1326     if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))
1327         if (!pic->owner2 || pic->owner2 == s)
1328             return 1;
1329     return 0;
1330 }
1331
1332 static int find_unused_picture(MpegEncContext *s, int shared)
1333 {
1334     int i;
1335
1336     if (shared) {
1337         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1338             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1339                 return i;
1340         }
1341     } else {
1342         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1343             if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1344                 return i; // FIXME
1345         }
1346         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1347             if (pic_is_unused(s, &s->picture[i]))
1348                 return i;
1349         }
1350     }
1351
1352     av_log(s->avctx, AV_LOG_FATAL,
1353            "Internal error, picture buffer overflow\n");
1354     /* We could return -1, but the codec would crash trying to draw into a
1355      * non-existing frame anyway. This is safer than waiting for a random crash.
1356      * Also the return of this is never useful, an encoder must only allocate
1357      * as much as allowed in the specification. This has no relationship to how
1358      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1359      * enough for such valid streams).
1360      * Plus, a decoder has to check stream validity and remove frames if too
1361      * many reference frames are around. Waiting for "OOM" is not correct at
1362      * all. Similarly, missing reference frames have to be replaced by
1363      * interpolated/MC frames, anything else is a bug in the codec ...
1364      */
1365     abort();
1366     return -1;
1367 }
1368
1369 int ff_find_unused_picture(MpegEncContext *s, int shared)
1370 {
1371     int ret = find_unused_picture(s, shared);
1372
1373     if (ret >= 0 && ret < s->picture_range_end) {
1374         if (s->picture[ret].needs_realloc) {
1375             s->picture[ret].needs_realloc = 0;
1376             free_picture(s, &s->picture[ret]);
1377             avcodec_get_frame_defaults(&s->picture[ret].f);
1378         }
1379     }
1380     return ret;
1381 }
1382
1383 static void update_noise_reduction(MpegEncContext *s)
1384 {
1385     int intra, i;
1386
1387     for (intra = 0; intra < 2; intra++) {
1388         if (s->dct_count[intra] > (1 << 16)) {
1389             for (i = 0; i < 64; i++) {
1390                 s->dct_error_sum[intra][i] >>= 1;
1391             }
1392             s->dct_count[intra] >>= 1;
1393         }
1394
1395         for (i = 0; i < 64; i++) {
1396             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1397                                        s->dct_count[intra] +
1398                                        s->dct_error_sum[intra][i] / 2) /
1399                                       (s->dct_error_sum[intra][i] + 1);
1400         }
1401     }
1402 }
1403
1404 /**
1405  * generic function for encode/decode called after coding/decoding
1406  * the header and before a frame is coded/decoded.
1407  */
1408 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1409 {
1410     int i;
1411     Picture *pic;
1412     s->mb_skipped = 0;
1413
1414     if (!ff_thread_can_start_frame(avctx)) {
1415         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1416         return -1;
1417     }
1418
1419     /* mark & release old frames */
1420     if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1421         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1422             s->last_picture_ptr != s->next_picture_ptr &&
1423             s->last_picture_ptr->f.data[0]) {
1424             if (s->last_picture_ptr->owner2 == s)
1425                 free_frame_buffer(s, s->last_picture_ptr);
1426         }
1427
1428         /* release forgotten pictures */
1429         /* if (mpeg124/h263) */
1430         if (!s->encoding) {
1431             for (i = 0; i < s->picture_count; i++) {
1432                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1433                     &s->picture[i] != s->last_picture_ptr &&
1434                     &s->picture[i] != s->next_picture_ptr &&
1435                     s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1436                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1437                         av_log(avctx, AV_LOG_ERROR,
1438                                "releasing zombie picture\n");
1439                     free_frame_buffer(s, &s->picture[i]);
1440                 }
1441             }
1442         }
1443     }
1444
1445     if (!s->encoding) {
1446         ff_release_unused_pictures(s, 1);
1447
1448         if (s->current_picture_ptr &&
1449             s->current_picture_ptr->f.data[0] == NULL) {
1450             // we already have a unused image
1451             // (maybe it was set before reading the header)
1452             pic = s->current_picture_ptr;
1453         } else {
1454             i   = ff_find_unused_picture(s, 0);
1455             if (i < 0) {
1456                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1457                 return i;
1458             }
1459             pic = &s->picture[i];
1460         }
1461
1462         pic->f.reference = 0;
1463         if (!s->droppable) {
1464             if (s->codec_id == AV_CODEC_ID_H264)
1465                 pic->f.reference = s->picture_structure;
1466             else if (s->pict_type != AV_PICTURE_TYPE_B)
1467                 pic->f.reference = 3;
1468         }
1469
1470         pic->f.coded_picture_number = s->coded_picture_number++;
1471
1472         if (ff_alloc_picture(s, pic, 0) < 0)
1473             return -1;
1474
1475         s->current_picture_ptr = pic;
1476         // FIXME use only the vars from current_pic
1477         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1478         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1479             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1480             if (s->picture_structure != PICT_FRAME)
1481                 s->current_picture_ptr->f.top_field_first =
1482                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1483         }
1484         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1485                                                      !s->progressive_sequence;
1486         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1487     }
1488
1489     s->current_picture_ptr->f.pict_type = s->pict_type;
1490     // if (s->flags && CODEC_FLAG_QSCALE)
1491     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1492     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1493
1494     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1495
1496     if (s->pict_type != AV_PICTURE_TYPE_B) {
1497         s->last_picture_ptr = s->next_picture_ptr;
1498         if (!s->droppable)
1499             s->next_picture_ptr = s->current_picture_ptr;
1500     }
1501     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1502             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1503             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1504             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1505             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1506             s->pict_type, s->droppable);
1507
1508     if (s->codec_id != AV_CODEC_ID_H264) {
1509         if ((s->last_picture_ptr == NULL ||
1510              s->last_picture_ptr->f.data[0] == NULL) &&
1511             (s->pict_type != AV_PICTURE_TYPE_I ||
1512              s->picture_structure != PICT_FRAME)) {
1513             int h_chroma_shift, v_chroma_shift;
1514             av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1515                                              &h_chroma_shift, &v_chroma_shift);
1516             if (s->pict_type != AV_PICTURE_TYPE_I)
1517                 av_log(avctx, AV_LOG_ERROR,
1518                        "warning: first frame is no keyframe\n");
1519             else if (s->picture_structure != PICT_FRAME)
1520                 av_log(avctx, AV_LOG_INFO,
1521                        "allocate dummy last picture for field based first keyframe\n");
1522
1523             /* Allocate a dummy frame */
1524             i = ff_find_unused_picture(s, 0);
1525             if (i < 0) {
1526                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1527                 return i;
1528             }
1529             s->last_picture_ptr = &s->picture[i];
1530             s->last_picture_ptr->f.key_frame = 0;
1531             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1532                 s->last_picture_ptr = NULL;
1533                 return -1;
1534             }
1535
1536             memset(s->last_picture_ptr->f.data[0], 0x80,
1537                    avctx->height * s->last_picture_ptr->f.linesize[0]);
1538             memset(s->last_picture_ptr->f.data[1], 0x80,
1539                    (avctx->height >> v_chroma_shift) *
1540                    s->last_picture_ptr->f.linesize[1]);
1541             memset(s->last_picture_ptr->f.data[2], 0x80,
1542                    (avctx->height >> v_chroma_shift) *
1543                    s->last_picture_ptr->f.linesize[2]);
1544
1545             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1546                 for(i=0; i<avctx->height; i++)
1547                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1548             }
1549
1550             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1551             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1552             s->last_picture_ptr->f.reference = 3;
1553         }
1554         if ((s->next_picture_ptr == NULL ||
1555              s->next_picture_ptr->f.data[0] == NULL) &&
1556             s->pict_type == AV_PICTURE_TYPE_B) {
1557             /* Allocate a dummy frame */
1558             i = ff_find_unused_picture(s, 0);
1559             if (i < 0) {
1560                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1561                 return i;
1562             }
1563             s->next_picture_ptr = &s->picture[i];
1564             s->next_picture_ptr->f.key_frame = 0;
1565             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1566                 s->next_picture_ptr = NULL;
1567                 return -1;
1568             }
1569             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1570             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1571             s->next_picture_ptr->f.reference = 3;
1572         }
1573     }
1574
1575     memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1576     memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1577     if (s->last_picture_ptr)
1578         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1579     if (s->next_picture_ptr)
1580         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1581
1582     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1583         if (s->next_picture_ptr)
1584             s->next_picture_ptr->owner2 = s;
1585         if (s->last_picture_ptr)
1586             s->last_picture_ptr->owner2 = s;
1587     }
1588
1589     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1590                                                  s->last_picture_ptr->f.data[0]));
1591
1592     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1593         int i;
1594         for (i = 0; i < 4; i++) {
1595             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1596                 s->current_picture.f.data[i] +=
1597                     s->current_picture.f.linesize[i];
1598             }
1599             s->current_picture.f.linesize[i] *= 2;
1600             s->last_picture.f.linesize[i]    *= 2;
1601             s->next_picture.f.linesize[i]    *= 2;
1602         }
1603     }
1604
1605     s->err_recognition = avctx->err_recognition;
1606
1607     /* set dequantizer, we can't do it during init as
1608      * it might change for mpeg4 and we can't do it in the header
1609      * decode as init is not called for mpeg4 there yet */
1610     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1611         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1612         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1613     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1614         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1615         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1616     } else {
1617         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1618         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1619     }
1620
1621     if (s->dct_error_sum) {
1622         assert(s->avctx->noise_reduction && s->encoding);
1623         update_noise_reduction(s);
1624     }
1625
1626     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1627         return ff_xvmc_field_start(s, avctx);
1628
1629     return 0;
1630 }
1631
1632 /* generic function for encode/decode called after a
1633  * frame has been coded/decoded. */
1634 void ff_MPV_frame_end(MpegEncContext *s)
1635 {
1636     int i;
1637     /* redraw edges for the frame if decoding didn't complete */
1638     // just to make sure that all data is rendered.
1639     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1640         ff_xvmc_field_end(s);
1641    } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1642               !s->avctx->hwaccel &&
1643               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1644               s->unrestricted_mv &&
1645               s->current_picture.f.reference &&
1646               !s->intra_only &&
1647               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1648               !s->avctx->lowres
1649             ) {
1650         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1651         int hshift = desc->log2_chroma_w;
1652         int vshift = desc->log2_chroma_h;
1653         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1654                           s->h_edge_pos, s->v_edge_pos,
1655                           EDGE_WIDTH, EDGE_WIDTH,
1656                           EDGE_TOP | EDGE_BOTTOM);
1657         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1658                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1659                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1660                           EDGE_TOP | EDGE_BOTTOM);
1661         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1662                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1663                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1664                           EDGE_TOP | EDGE_BOTTOM);
1665     }
1666
1667     emms_c();
1668
1669     s->last_pict_type                 = s->pict_type;
1670     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1671     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1672         s->last_non_b_pict_type = s->pict_type;
1673     }
1674 #if 0
1675     /* copy back current_picture variables */
1676     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1677         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1678             s->picture[i] = s->current_picture;
1679             break;
1680         }
1681     }
1682     assert(i < MAX_PICTURE_COUNT);
1683 #endif
1684
1685     if (s->encoding) {
1686         /* release non-reference frames */
1687         for (i = 0; i < s->picture_count; i++) {
1688             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1689                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1690                 free_frame_buffer(s, &s->picture[i]);
1691             }
1692         }
1693     }
1694     // clear copies, to avoid confusion
1695 #if 0
1696     memset(&s->last_picture,    0, sizeof(Picture));
1697     memset(&s->next_picture,    0, sizeof(Picture));
1698     memset(&s->current_picture, 0, sizeof(Picture));
1699 #endif
1700     s->avctx->coded_frame = &s->current_picture_ptr->f;
1701
1702     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1703         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1704     }
1705 }
1706
1707 /**
1708  * Draw a line from (ex, ey) -> (sx, sy).
1709  * @param w width of the image
1710  * @param h height of the image
1711  * @param stride stride/linesize of the image
1712  * @param color color of the arrow
1713  */
1714 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1715                       int w, int h, int stride, int color)
1716 {
1717     int x, y, fr, f;
1718
1719     sx = av_clip(sx, 0, w - 1);
1720     sy = av_clip(sy, 0, h - 1);
1721     ex = av_clip(ex, 0, w - 1);
1722     ey = av_clip(ey, 0, h - 1);
1723
1724     buf[sy * stride + sx] += color;
1725
1726     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1727         if (sx > ex) {
1728             FFSWAP(int, sx, ex);
1729             FFSWAP(int, sy, ey);
1730         }
1731         buf += sx + sy * stride;
1732         ex  -= sx;
1733         f    = ((ey - sy) << 16) / ex;
1734         for (x = 0; x <= ex; x++) {
1735             y  = (x * f) >> 16;
1736             fr = (x * f) & 0xFFFF;
1737             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1738             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1739         }
1740     } else {
1741         if (sy > ey) {
1742             FFSWAP(int, sx, ex);
1743             FFSWAP(int, sy, ey);
1744         }
1745         buf += sx + sy * stride;
1746         ey  -= sy;
1747         if (ey)
1748             f = ((ex - sx) << 16) / ey;
1749         else
1750             f = 0;
1751         for(y= 0; y <= ey; y++){
1752             x  = (y*f) >> 16;
1753             fr = (y*f) & 0xFFFF;
1754             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1755             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1756         }
1757     }
1758 }
1759
1760 /**
1761  * Draw an arrow from (ex, ey) -> (sx, sy).
1762  * @param w width of the image
1763  * @param h height of the image
1764  * @param stride stride/linesize of the image
1765  * @param color color of the arrow
1766  */
1767 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1768                        int ey, int w, int h, int stride, int color)
1769 {
1770     int dx,dy;
1771
1772     sx = av_clip(sx, -100, w + 100);
1773     sy = av_clip(sy, -100, h + 100);
1774     ex = av_clip(ex, -100, w + 100);
1775     ey = av_clip(ey, -100, h + 100);
1776
1777     dx = ex - sx;
1778     dy = ey - sy;
1779
1780     if (dx * dx + dy * dy > 3 * 3) {
1781         int rx =  dx + dy;
1782         int ry = -dx + dy;
1783         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1784
1785         // FIXME subpixel accuracy
1786         rx = ROUNDED_DIV(rx * 3 << 4, length);
1787         ry = ROUNDED_DIV(ry * 3 << 4, length);
1788
1789         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1790         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1791     }
1792     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1793 }
1794
1795 /**
1796  * Print debugging info for the given picture.
1797  */
1798 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1799 {
1800     if (   s->avctx->hwaccel || !pict || !pict->mb_type
1801         || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1802         return;
1803
1804
1805     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1806         int x,y;
1807
1808         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1809                av_get_picture_type_char(pict->pict_type));
1810         for (y = 0; y < s->mb_height; y++) {
1811             for (x = 0; x < s->mb_width; x++) {
1812                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1813                     int count = s->mbskip_table[x + y * s->mb_stride];
1814                     if (count > 9)
1815                         count = 9;
1816                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1817                 }
1818                 if (s->avctx->debug & FF_DEBUG_QP) {
1819                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1820                            pict->qscale_table[x + y * s->mb_stride]);
1821                 }
1822                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1823                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1824                     // Type & MV direction
1825                     if (IS_PCM(mb_type))
1826                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1827                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1828                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1829                     else if (IS_INTRA4x4(mb_type))
1830                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1831                     else if (IS_INTRA16x16(mb_type))
1832                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1833                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1834                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1835                     else if (IS_DIRECT(mb_type))
1836                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1837                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1838                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1839                     else if (IS_GMC(mb_type))
1840                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1841                     else if (IS_SKIP(mb_type))
1842                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1843                     else if (!USES_LIST(mb_type, 1))
1844                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1845                     else if (!USES_LIST(mb_type, 0))
1846                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1847                     else {
1848                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1849                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1850                     }
1851
1852                     // segmentation
1853                     if (IS_8X8(mb_type))
1854                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1855                     else if (IS_16X8(mb_type))
1856                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1857                     else if (IS_8X16(mb_type))
1858                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1859                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1860                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1861                     else
1862                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1863
1864
1865                     if (IS_INTERLACED(mb_type))
1866                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1867                     else
1868                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1869                 }
1870             }
1871             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1872         }
1873     }
1874
1875     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1876         (s->avctx->debug_mv)) {
1877         const int shift = 1 + s->quarter_sample;
1878         int mb_y;
1879         uint8_t *ptr;
1880         int i;
1881         int h_chroma_shift, v_chroma_shift, block_height;
1882         const int width          = s->avctx->width;
1883         const int height         = s->avctx->height;
1884         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1885         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1886                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1887         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1888
1889         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1890
1891         for (i = 0; i < 3; i++) {
1892             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1893                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1894             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1895             memcpy(s->visualization_buffer[i], pict->data[i], size);
1896             pict->data[i] = s->visualization_buffer[i];
1897         }
1898         pict->type   = FF_BUFFER_TYPE_COPY;
1899         pict->opaque= NULL;
1900         ptr          = pict->data[0];
1901         block_height = 16 >> v_chroma_shift;
1902
1903         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1904             int mb_x;
1905             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1906                 const int mb_index = mb_x + mb_y * s->mb_stride;
1907                 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1908                     int type;
1909                     for (type = 0; type < 3; type++) {
1910                         int direction = 0;
1911                         switch (type) {
1912                         case 0:
1913                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1914                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1915                                 continue;
1916                             direction = 0;
1917                             break;
1918                         case 1:
1919                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1920                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1921                                 continue;
1922                             direction = 0;
1923                             break;
1924                         case 2:
1925                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1926                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1927                                 continue;
1928                             direction = 1;
1929                             break;
1930                         }
1931                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1932                             continue;
1933
1934                         if (IS_8X8(pict->mb_type[mb_index])) {
1935                             int i;
1936                             for (i = 0; i < 4; i++) {
1937                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1938                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1939                                 int xy = (mb_x * 2 + (i & 1) +
1940                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1941                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1942                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1943                                 draw_arrow(ptr, sx, sy, mx, my, width,
1944                                            height, s->linesize, 100);
1945                             }
1946                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1947                             int i;
1948                             for (i = 0; i < 2; i++) {
1949                                 int sx = mb_x * 16 + 8;
1950                                 int sy = mb_y * 16 + 4 + 8 * i;
1951                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1952                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1953                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1954
1955                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1956                                     my *= 2;
1957
1958                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1959                                        height, s->linesize, 100);
1960                             }
1961                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1962                             int i;
1963                             for (i = 0; i < 2; i++) {
1964                                 int sx = mb_x * 16 + 4 + 8 * i;
1965                                 int sy = mb_y * 16 + 8;
1966                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1967                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1968                                 int my = pict->motion_val[direction][xy][1] >> shift;
1969
1970                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1971                                     my *= 2;
1972
1973                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1974                                            height, s->linesize, 100);
1975                             }
1976                         } else {
1977                               int sx= mb_x * 16 + 8;
1978                               int sy= mb_y * 16 + 8;
1979                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1980                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1981                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1982                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1983                         }
1984                     }
1985                 }
1986                 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1987                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1988                                  0x0101010101010101ULL;
1989                     int y;
1990                     for (y = 0; y < block_height; y++) {
1991                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1992                                       (block_height * mb_y + y) *
1993                                       pict->linesize[1]) = c;
1994                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1995                                       (block_height * mb_y + y) *
1996                                       pict->linesize[2]) = c;
1997                     }
1998                 }
1999                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2000                     pict->motion_val[0]) {
2001                     int mb_type = pict->mb_type[mb_index];
2002                     uint64_t u,v;
2003                     int y;
2004 #define COLOR(theta, r) \
2005     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2006     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2007
2008
2009                     u = v = 128;
2010                     if (IS_PCM(mb_type)) {
2011                         COLOR(120, 48)
2012                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2013                                IS_INTRA16x16(mb_type)) {
2014                         COLOR(30, 48)
2015                     } else if (IS_INTRA4x4(mb_type)) {
2016                         COLOR(90, 48)
2017                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2018                         // COLOR(120, 48)
2019                     } else if (IS_DIRECT(mb_type)) {
2020                         COLOR(150, 48)
2021                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2022                         COLOR(170, 48)
2023                     } else if (IS_GMC(mb_type)) {
2024                         COLOR(190, 48)
2025                     } else if (IS_SKIP(mb_type)) {
2026                         // COLOR(180, 48)
2027                     } else if (!USES_LIST(mb_type, 1)) {
2028                         COLOR(240, 48)
2029                     } else if (!USES_LIST(mb_type, 0)) {
2030                         COLOR(0, 48)
2031                     } else {
2032                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2033                         COLOR(300,48)
2034                     }
2035
2036                     u *= 0x0101010101010101ULL;
2037                     v *= 0x0101010101010101ULL;
2038                     for (y = 0; y < block_height; y++) {
2039                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2040                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2041                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2042                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2043                     }
2044
2045                     // segmentation
2046                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2047                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2048                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2049                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2050                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2051                     }
2052                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2053                         for (y = 0; y < 16; y++)
2054                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2055                                           pict->linesize[0]] ^= 0x80;
2056                     }
2057                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2058                         int dm = 1 << (mv_sample_log2 - 2);
2059                         for (i = 0; i < 4; i++) {
2060                             int sx = mb_x * 16 + 8 * (i & 1);
2061                             int sy = mb_y * 16 + 8 * (i >> 1);
2062                             int xy = (mb_x * 2 + (i & 1) +
2063                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2064                             // FIXME bidir
2065                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
2066                             if (mv[0] != mv[dm] ||
2067                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2068                                 for (y = 0; y < 8; y++)
2069                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2070                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2071                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2072                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2073                         }
2074                     }
2075
2076                     if (IS_INTERLACED(mb_type) &&
2077                         s->codec_id == AV_CODEC_ID_H264) {
2078                         // hmm
2079                     }
2080                 }
2081                 s->mbskip_table[mb_index] = 0;
2082             }
2083         }
2084     }
2085 }
2086
2087 static inline int hpel_motion_lowres(MpegEncContext *s,
2088                                      uint8_t *dest, uint8_t *src,
2089                                      int field_based, int field_select,
2090                                      int src_x, int src_y,
2091                                      int width, int height, int stride,
2092                                      int h_edge_pos, int v_edge_pos,
2093                                      int w, int h, h264_chroma_mc_func *pix_op,
2094                                      int motion_x, int motion_y)
2095 {
2096     const int lowres   = s->avctx->lowres;
2097     const int op_index = FFMIN(lowres, 2);
2098     const int s_mask   = (2 << lowres) - 1;
2099     int emu = 0;
2100     int sx, sy;
2101
2102     if (s->quarter_sample) {
2103         motion_x /= 2;
2104         motion_y /= 2;
2105     }
2106
2107     sx = motion_x & s_mask;
2108     sy = motion_y & s_mask;
2109     src_x += motion_x >> lowres + 1;
2110     src_y += motion_y >> lowres + 1;
2111
2112     src   += src_y * stride + src_x;
2113
2114     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2115         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2116         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2117                                 (h + 1) << field_based, src_x,
2118                                 src_y   << field_based,
2119                                 h_edge_pos,
2120                                 v_edge_pos);
2121         src = s->edge_emu_buffer;
2122         emu = 1;
2123     }
2124
2125     sx = (sx << 2) >> lowres;
2126     sy = (sy << 2) >> lowres;
2127     if (field_select)
2128         src += s->linesize;
2129     pix_op[op_index](dest, src, stride, h, sx, sy);
2130     return emu;
2131 }
2132
2133 /* apply one mpeg motion vector to the three components */
2134 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2135                                                 uint8_t *dest_y,
2136                                                 uint8_t *dest_cb,
2137                                                 uint8_t *dest_cr,
2138                                                 int field_based,
2139                                                 int bottom_field,
2140                                                 int field_select,
2141                                                 uint8_t **ref_picture,
2142                                                 h264_chroma_mc_func *pix_op,
2143                                                 int motion_x, int motion_y,
2144                                                 int h, int mb_y)
2145 {
2146     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2147     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2148         uvsx, uvsy;
2149     const int lowres     = s->avctx->lowres;
2150     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2151     const int block_s    = 8>>lowres;
2152     const int s_mask     = (2 << lowres) - 1;
2153     const int h_edge_pos = s->h_edge_pos >> lowres;
2154     const int v_edge_pos = s->v_edge_pos >> lowres;
2155     linesize   = s->current_picture.f.linesize[0] << field_based;
2156     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2157
2158     // FIXME obviously not perfect but qpel will not work in lowres anyway
2159     if (s->quarter_sample) {
2160         motion_x /= 2;
2161         motion_y /= 2;
2162     }
2163
2164     if(field_based){
2165         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2166     }
2167
2168     sx = motion_x & s_mask;
2169     sy = motion_y & s_mask;
2170     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2171     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2172
2173     if (s->out_format == FMT_H263) {
2174         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2175         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2176         uvsrc_x = src_x >> 1;
2177         uvsrc_y = src_y >> 1;
2178     } else if (s->out_format == FMT_H261) {
2179         // even chroma mv's are full pel in H261
2180         mx      = motion_x / 4;
2181         my      = motion_y / 4;
2182         uvsx    = (2 * mx) & s_mask;
2183         uvsy    = (2 * my) & s_mask;
2184         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2185         uvsrc_y =    mb_y * block_s + (my >> lowres);
2186     } else {
2187         if(s->chroma_y_shift){
2188             mx      = motion_x / 2;
2189             my      = motion_y / 2;
2190             uvsx    = mx & s_mask;
2191             uvsy    = my & s_mask;
2192             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2193             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2194         } else {
2195             if(s->chroma_x_shift){
2196             //Chroma422
2197                 mx = motion_x / 2;
2198                 uvsx = mx & s_mask;
2199                 uvsy = motion_y & s_mask;
2200                 uvsrc_y = src_y;
2201                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2202             } else {
2203             //Chroma444
2204                 uvsx = motion_x & s_mask;
2205                 uvsy = motion_y & s_mask;
2206                 uvsrc_x = src_x;
2207                 uvsrc_y = src_y;
2208             }
2209         }
2210     }
2211
2212     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2213     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2214     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2215
2216     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2217         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2218         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2219                                 linesize >> field_based, 17, 17 + field_based,
2220                                 src_x, src_y << field_based, h_edge_pos,
2221                                 v_edge_pos);
2222         ptr_y = s->edge_emu_buffer;
2223         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2224             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2225             s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2226                                     9 + field_based,
2227                                     uvsrc_x, uvsrc_y << field_based,
2228                                     h_edge_pos >> 1, v_edge_pos >> 1);
2229             s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2230                                     9 + field_based,
2231                                     uvsrc_x, uvsrc_y << field_based,
2232                                     h_edge_pos >> 1, v_edge_pos >> 1);
2233             ptr_cb = uvbuf;
2234             ptr_cr = uvbuf + 16;
2235         }
2236     }
2237
2238     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2239     if (bottom_field) {
2240         dest_y  += s->linesize;
2241         dest_cb += s->uvlinesize;
2242         dest_cr += s->uvlinesize;
2243     }
2244
2245     if (field_select) {
2246         ptr_y   += s->linesize;
2247         ptr_cb  += s->uvlinesize;
2248         ptr_cr  += s->uvlinesize;
2249     }
2250
2251     sx = (sx << 2) >> lowres;
2252     sy = (sy << 2) >> lowres;
2253     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2254
2255     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2256         uvsx = (uvsx << 2) >> lowres;
2257         uvsy = (uvsy << 2) >> lowres;
2258         if (h >> s->chroma_y_shift) {
2259             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2260             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2261         }
2262     }
2263     // FIXME h261 lowres loop filter
2264 }
2265
2266 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2267                                             uint8_t *dest_cb, uint8_t *dest_cr,
2268                                             uint8_t **ref_picture,
2269                                             h264_chroma_mc_func * pix_op,
2270                                             int mx, int my)
2271 {
2272     const int lowres     = s->avctx->lowres;
2273     const int op_index   = FFMIN(lowres, 2);
2274     const int block_s    = 8 >> lowres;
2275     const int s_mask     = (2 << lowres) - 1;
2276     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2277     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2278     int emu = 0, src_x, src_y, offset, sx, sy;
2279     uint8_t *ptr;
2280
2281     if (s->quarter_sample) {
2282         mx /= 2;
2283         my /= 2;
2284     }
2285
2286     /* In case of 8X8, we construct a single chroma motion vector
2287        with a special rounding */
2288     mx = ff_h263_round_chroma(mx);
2289     my = ff_h263_round_chroma(my);
2290
2291     sx = mx & s_mask;
2292     sy = my & s_mask;
2293     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2294     src_y = s->mb_y * block_s + (my >> lowres + 1);
2295
2296     offset = src_y * s->uvlinesize + src_x;
2297     ptr = ref_picture[1] + offset;
2298     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2299         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2300             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2301             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2302                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2303             ptr = s->edge_emu_buffer;
2304             emu = 1;
2305         }
2306     }
2307     sx = (sx << 2) >> lowres;
2308     sy = (sy << 2) >> lowres;
2309     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2310
2311     ptr = ref_picture[2] + offset;
2312     if (emu) {
2313         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2314                                 src_x, src_y, h_edge_pos, v_edge_pos);
2315         ptr = s->edge_emu_buffer;
2316     }
2317     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2318 }
2319
2320 /**
2321  * motion compensation of a single macroblock
2322  * @param s context
2323  * @param dest_y luma destination pointer
2324  * @param dest_cb chroma cb/u destination pointer
2325  * @param dest_cr chroma cr/v destination pointer
2326  * @param dir direction (0->forward, 1->backward)
2327  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2328  * @param pix_op halfpel motion compensation function (average or put normally)
2329  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2330  */
2331 static inline void MPV_motion_lowres(MpegEncContext *s,
2332                                      uint8_t *dest_y, uint8_t *dest_cb,
2333                                      uint8_t *dest_cr,
2334                                      int dir, uint8_t **ref_picture,
2335                                      h264_chroma_mc_func *pix_op)
2336 {
2337     int mx, my;
2338     int mb_x, mb_y, i;
2339     const int lowres  = s->avctx->lowres;
2340     const int block_s = 8 >>lowres;
2341
2342     mb_x = s->mb_x;
2343     mb_y = s->mb_y;
2344
2345     switch (s->mv_type) {
2346     case MV_TYPE_16X16:
2347         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2348                            0, 0, 0,
2349                            ref_picture, pix_op,
2350                            s->mv[dir][0][0], s->mv[dir][0][1],
2351                            2 * block_s, mb_y);
2352         break;
2353     case MV_TYPE_8X8:
2354         mx = 0;
2355         my = 0;
2356         for (i = 0; i < 4; i++) {
2357             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2358                                s->linesize) * block_s,
2359                                ref_picture[0], 0, 0,
2360                                (2 * mb_x + (i & 1)) * block_s,
2361                                (2 * mb_y + (i >> 1)) * block_s,
2362                                s->width, s->height, s->linesize,
2363                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2364                                block_s, block_s, pix_op,
2365                                s->mv[dir][i][0], s->mv[dir][i][1]);
2366
2367             mx += s->mv[dir][i][0];
2368             my += s->mv[dir][i][1];
2369         }
2370
2371         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2372             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2373                                      pix_op, mx, my);
2374         break;
2375     case MV_TYPE_FIELD:
2376         if (s->picture_structure == PICT_FRAME) {
2377             /* top field */
2378             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2379                                1, 0, s->field_select[dir][0],
2380                                ref_picture, pix_op,
2381                                s->mv[dir][0][0], s->mv[dir][0][1],
2382                                block_s, mb_y);
2383             /* bottom field */
2384             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2385                                1, 1, s->field_select[dir][1],
2386                                ref_picture, pix_op,
2387                                s->mv[dir][1][0], s->mv[dir][1][1],
2388                                block_s, mb_y);
2389         } else {
2390             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2391                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2392                 ref_picture = s->current_picture_ptr->f.data;
2393
2394             }
2395             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2396                                0, 0, s->field_select[dir][0],
2397                                ref_picture, pix_op,
2398                                s->mv[dir][0][0],
2399                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2400             }
2401         break;
2402     case MV_TYPE_16X8:
2403         for (i = 0; i < 2; i++) {
2404             uint8_t **ref2picture;
2405
2406             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2407                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2408                 ref2picture = ref_picture;
2409             } else {
2410                 ref2picture = s->current_picture_ptr->f.data;
2411             }
2412
2413             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2414                                0, 0, s->field_select[dir][i],
2415                                ref2picture, pix_op,
2416                                s->mv[dir][i][0], s->mv[dir][i][1] +
2417                                2 * block_s * i, block_s, mb_y >> 1);
2418
2419             dest_y  +=  2 * block_s *  s->linesize;
2420             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2421             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2422         }
2423         break;
2424     case MV_TYPE_DMV:
2425         if (s->picture_structure == PICT_FRAME) {
2426             for (i = 0; i < 2; i++) {
2427                 int j;
2428                 for (j = 0; j < 2; j++) {
2429                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2430                                        1, j, j ^ i,
2431                                        ref_picture, pix_op,
2432                                        s->mv[dir][2 * i + j][0],
2433                                        s->mv[dir][2 * i + j][1],
2434                                        block_s, mb_y);
2435                 }
2436                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2437             }
2438         } else {
2439             for (i = 0; i < 2; i++) {
2440                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2441                                    0, 0, s->picture_structure != i + 1,
2442                                    ref_picture, pix_op,
2443                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2444                                    2 * block_s, mb_y >> 1);
2445
2446                 // after put we make avg of the same block
2447                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2448
2449                 // opposite parity is always in the same
2450                 // frame if this is second field
2451                 if (!s->first_field) {
2452                     ref_picture = s->current_picture_ptr->f.data;
2453                 }
2454             }
2455         }
2456         break;
2457     default:
2458         av_assert2(0);
2459     }
2460 }
2461
2462 /**
2463  * find the lowest MB row referenced in the MVs
2464  */
2465 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2466 {
2467     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2468     int my, off, i, mvs;
2469
2470     if (s->picture_structure != PICT_FRAME || s->mcsel)
2471         goto unhandled;
2472
2473     switch (s->mv_type) {
2474         case MV_TYPE_16X16:
2475             mvs = 1;
2476             break;
2477         case MV_TYPE_16X8:
2478             mvs = 2;
2479             break;
2480         case MV_TYPE_8X8:
2481             mvs = 4;
2482             break;
2483         default:
2484             goto unhandled;
2485     }
2486
2487     for (i = 0; i < mvs; i++) {
2488         my = s->mv[dir][i][1]<<qpel_shift;
2489         my_max = FFMAX(my_max, my);
2490         my_min = FFMIN(my_min, my);
2491     }
2492
2493     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2494
2495     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2496 unhandled:
2497     return s->mb_height-1;
2498 }
2499
2500 /* put block[] to dest[] */
2501 static inline void put_dct(MpegEncContext *s,
2502                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2503 {
2504     s->dct_unquantize_intra(s, block, i, qscale);
2505     s->dsp.idct_put (dest, line_size, block);
2506 }
2507
2508 /* add block[] to dest[] */
2509 static inline void add_dct(MpegEncContext *s,
2510                            int16_t *block, int i, uint8_t *dest, int line_size)
2511 {
2512     if (s->block_last_index[i] >= 0) {
2513         s->dsp.idct_add (dest, line_size, block);
2514     }
2515 }
2516
2517 static inline void add_dequant_dct(MpegEncContext *s,
2518                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2519 {
2520     if (s->block_last_index[i] >= 0) {
2521         s->dct_unquantize_inter(s, block, i, qscale);
2522
2523         s->dsp.idct_add (dest, line_size, block);
2524     }
2525 }
2526
2527 /**
2528  * Clean dc, ac, coded_block for the current non-intra MB.
2529  */
2530 void ff_clean_intra_table_entries(MpegEncContext *s)
2531 {
2532     int wrap = s->b8_stride;
2533     int xy = s->block_index[0];
2534
2535     s->dc_val[0][xy           ] =
2536     s->dc_val[0][xy + 1       ] =
2537     s->dc_val[0][xy     + wrap] =
2538     s->dc_val[0][xy + 1 + wrap] = 1024;
2539     /* ac pred */
2540     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2541     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2542     if (s->msmpeg4_version>=3) {
2543         s->coded_block[xy           ] =
2544         s->coded_block[xy + 1       ] =
2545         s->coded_block[xy     + wrap] =
2546         s->coded_block[xy + 1 + wrap] = 0;
2547     }
2548     /* chroma */
2549     wrap = s->mb_stride;
2550     xy = s->mb_x + s->mb_y * wrap;
2551     s->dc_val[1][xy] =
2552     s->dc_val[2][xy] = 1024;
2553     /* ac pred */
2554     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2555     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2556
2557     s->mbintra_table[xy]= 0;
2558 }
2559
2560 /* generic function called after a macroblock has been parsed by the
2561    decoder or after it has been encoded by the encoder.
2562
2563    Important variables used:
2564    s->mb_intra : true if intra macroblock
2565    s->mv_dir   : motion vector direction
2566    s->mv_type  : motion vector type
2567    s->mv       : motion vector
2568    s->interlaced_dct : true if interlaced dct used (mpeg2)
2569  */
2570 static av_always_inline
2571 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2572                             int lowres_flag, int is_mpeg12)
2573 {
2574     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2575     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2576         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2577         return;
2578     }
2579
2580     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2581        /* save DCT coefficients */
2582        int i,j;
2583        int16_t *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2584        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2585        for(i=0; i<6; i++){
2586            for(j=0; j<64; j++){
2587                *dct++ = block[i][s->dsp.idct_permutation[j]];
2588                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2589            }
2590            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2591        }
2592     }
2593
2594     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2595
2596     /* update DC predictors for P macroblocks */
2597     if (!s->mb_intra) {
2598         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2599             if(s->mbintra_table[mb_xy])
2600                 ff_clean_intra_table_entries(s);
2601         } else {
2602             s->last_dc[0] =
2603             s->last_dc[1] =
2604             s->last_dc[2] = 128 << s->intra_dc_precision;
2605         }
2606     }
2607     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2608         s->mbintra_table[mb_xy]=1;
2609
2610     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2611         uint8_t *dest_y, *dest_cb, *dest_cr;
2612         int dct_linesize, dct_offset;
2613         op_pixels_func (*op_pix)[4];
2614         qpel_mc_func (*op_qpix)[16];
2615         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2616         const int uvlinesize = s->current_picture.f.linesize[1];
2617         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2618         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2619
2620         /* avoid copy if macroblock skipped in last frame too */
2621         /* skip only during decoding as we might trash the buffers during encoding a bit */
2622         if(!s->encoding){
2623             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2624
2625             if (s->mb_skipped) {
2626                 s->mb_skipped= 0;
2627                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2628                 *mbskip_ptr = 1;
2629             } else if(!s->current_picture.f.reference) {
2630                 *mbskip_ptr = 1;
2631             } else{
2632                 *mbskip_ptr = 0; /* not skipped */
2633             }
2634         }
2635
2636         dct_linesize = linesize << s->interlaced_dct;
2637         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2638
2639         if(readable){
2640             dest_y=  s->dest[0];
2641             dest_cb= s->dest[1];
2642             dest_cr= s->dest[2];
2643         }else{
2644             dest_y = s->b_scratchpad;
2645             dest_cb= s->b_scratchpad+16*linesize;
2646             dest_cr= s->b_scratchpad+32*linesize;
2647         }
2648
2649         if (!s->mb_intra) {
2650             /* motion handling */
2651             /* decoding or more than one mb_type (MC was already done otherwise) */
2652             if(!s->encoding){
2653
2654                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2655                     if (s->mv_dir & MV_DIR_FORWARD) {
2656                         ff_thread_await_progress(&s->last_picture_ptr->f,
2657                                                  ff_MPV_lowest_referenced_row(s, 0),
2658                                                  0);
2659                     }
2660                     if (s->mv_dir & MV_DIR_BACKWARD) {
2661                         ff_thread_await_progress(&s->next_picture_ptr->f,
2662                                                  ff_MPV_lowest_referenced_row(s, 1),
2663                                                  0);
2664                     }
2665                 }
2666
2667                 if(lowres_flag){
2668                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2669
2670                     if (s->mv_dir & MV_DIR_FORWARD) {
2671                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2672                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2673                     }
2674                     if (s->mv_dir & MV_DIR_BACKWARD) {
2675                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2676                     }
2677                 }else{
2678                     op_qpix= s->me.qpel_put;
2679                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2680                         op_pix = s->dsp.put_pixels_tab;
2681                     }else{
2682                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2683                     }
2684                     if (s->mv_dir & MV_DIR_FORWARD) {
2685                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2686                         op_pix = s->dsp.avg_pixels_tab;
2687                         op_qpix= s->me.qpel_avg;
2688                     }
2689                     if (s->mv_dir & MV_DIR_BACKWARD) {
2690                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2691                     }
2692                 }
2693             }
2694
2695             /* skip dequant / idct if we are really late ;) */
2696             if(s->avctx->skip_idct){
2697                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2698                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2699                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2700                     goto skip_idct;
2701             }
2702
2703             /* add dct residue */
2704             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2705                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2706                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2707                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2708                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2709                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2710
2711                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2712                     if (s->chroma_y_shift){
2713                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2714                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2715                     }else{
2716                         dct_linesize >>= 1;
2717                         dct_offset >>=1;
2718                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2719                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2720                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2721                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2722                     }
2723                 }
2724             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2725                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2726                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2727                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2728                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2729
2730                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2731                     if(s->chroma_y_shift){//Chroma420
2732                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2733                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2734                     }else{
2735                         //chroma422
2736                         dct_linesize = uvlinesize << s->interlaced_dct;
2737                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2738
2739                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2740                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2741                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2742                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2743                         if(!s->chroma_x_shift){//Chroma444
2744                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2745                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2746                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2747                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2748                         }
2749                     }
2750                 }//fi gray
2751             }
2752             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2753                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2754             }
2755         } else {
2756             /* dct only in intra block */
2757             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2758                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2759                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2760                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2761                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2762
2763                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2764                     if(s->chroma_y_shift){
2765                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2766                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2767                     }else{
2768                         dct_offset >>=1;
2769                         dct_linesize >>=1;
2770                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2771                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2772                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2773                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2774                     }
2775                 }
2776             }else{
2777                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2778                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2779                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2780                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2781
2782                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2783                     if(s->chroma_y_shift){
2784                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2785                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2786                     }else{
2787
2788                         dct_linesize = uvlinesize << s->interlaced_dct;
2789                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2790
2791                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2792                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2793                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2794                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2795                         if(!s->chroma_x_shift){//Chroma444
2796                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2797                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2798                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2799                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2800                         }
2801                     }
2802                 }//gray
2803             }
2804         }
2805 skip_idct:
2806         if(!readable){
2807             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2808             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2809             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2810         }
2811     }
2812 }
2813
2814 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2815 #if !CONFIG_SMALL
2816     if(s->out_format == FMT_MPEG1) {
2817         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2818         else                 MPV_decode_mb_internal(s, block, 0, 1);
2819     } else
2820 #endif
2821     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2822     else                  MPV_decode_mb_internal(s, block, 0, 0);
2823 }
2824
2825 /**
2826  * @param h is the normal height, this will be reduced automatically if needed for the last row
2827  */
2828 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2829                         Picture *last, int y, int h, int picture_structure,
2830                         int first_field, int draw_edges, int low_delay,
2831                         int v_edge_pos, int h_edge_pos)
2832 {
2833     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2834     int hshift = desc->log2_chroma_w;
2835     int vshift = desc->log2_chroma_h;
2836     const int field_pic = picture_structure != PICT_FRAME;
2837     if(field_pic){
2838         h <<= 1;
2839         y <<= 1;
2840     }
2841
2842     if (!avctx->hwaccel &&
2843         !(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
2844         draw_edges &&
2845         cur->f.reference &&
2846         !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2847         int *linesize = cur->f.linesize;
2848         int sides = 0, edge_h;
2849         if (y==0) sides |= EDGE_TOP;
2850         if (y + h >= v_edge_pos)
2851             sides |= EDGE_BOTTOM;
2852
2853         edge_h= FFMIN(h, v_edge_pos - y);
2854
2855         dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2856                         linesize[0], h_edge_pos, edge_h,
2857                         EDGE_WIDTH, EDGE_WIDTH, sides);
2858         dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2859                         linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2860                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2861         dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2862                         linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2863                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2864     }
2865
2866     h = FFMIN(h, avctx->height - y);
2867
2868     if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2869
2870     if (avctx->draw_horiz_band) {
2871         AVFrame *src;
2872         int offset[AV_NUM_DATA_POINTERS];
2873         int i;
2874
2875         if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2876            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2877             src = &cur->f;
2878         else if (last)
2879             src = &last->f;
2880         else
2881             return;
2882
2883         if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2884             picture_structure == PICT_FRAME    &&
2885             avctx->codec_id != AV_CODEC_ID_H264  &&
2886             avctx->codec_id != AV_CODEC_ID_SVQ3) {
2887             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2888                 offset[i] = 0;
2889         }else{
2890             offset[0]= y * src->linesize[0];
2891             offset[1]=
2892             offset[2]= (y >> vshift) * src->linesize[1];
2893             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2894                 offset[i] = 0;
2895         }
2896
2897         emms_c();
2898
2899         avctx->draw_horiz_band(avctx, src, offset,
2900                                y, picture_structure, h);
2901     }
2902 }
2903
2904 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2905 {
2906     int draw_edges = s->unrestricted_mv && !s->intra_only;
2907     ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
2908                        &s->last_picture, y, h, s->picture_structure,
2909                        s->first_field, draw_edges, s->low_delay,
2910                        s->v_edge_pos, s->h_edge_pos);
2911 }
2912
2913 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2914     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2915     const int uvlinesize = s->current_picture.f.linesize[1];
2916     const int mb_size= 4 - s->avctx->lowres;
2917
2918     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2919     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2920     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2921     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2922     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2923     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2924     //block_index is not used by mpeg2, so it is not affected by chroma_format
2925
2926     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2927     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2928     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2929
2930     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2931     {
2932         if(s->picture_structure==PICT_FRAME){
2933         s->dest[0] += s->mb_y *   linesize << mb_size;
2934         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2935         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2936         }else{
2937             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2938             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2939             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2940             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2941         }
2942     }
2943 }
2944
2945 /**
2946  * Permute an 8x8 block.
2947  * @param block the block which will be permuted according to the given permutation vector
2948  * @param permutation the permutation vector
2949  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2950  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2951  *                  (inverse) permutated to scantable order!
2952  */
2953 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2954 {
2955     int i;
2956     int16_t temp[64];
2957
2958     if(last<=0) return;
2959     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2960
2961     for(i=0; i<=last; i++){
2962         const int j= scantable[i];
2963         temp[j]= block[j];
2964         block[j]=0;
2965     }
2966
2967     for(i=0; i<=last; i++){
2968         const int j= scantable[i];
2969         const int perm_j= permutation[j];
2970         block[perm_j]= temp[j];
2971     }
2972 }
2973
2974 void ff_mpeg_flush(AVCodecContext *avctx){
2975     int i;
2976     MpegEncContext *s = avctx->priv_data;
2977
2978     if(s==NULL || s->picture==NULL)
2979         return;
2980
2981     for(i=0; i<s->picture_count; i++){
2982        if (s->picture[i].f.data[0] &&
2983            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2984             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2985         free_frame_buffer(s, &s->picture[i]);
2986     }
2987     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2988
2989     s->mb_x= s->mb_y= 0;
2990     s->closed_gop= 0;
2991
2992     s->parse_context.state= -1;
2993     s->parse_context.frame_start_found= 0;
2994     s->parse_context.overread= 0;
2995     s->parse_context.overread_index= 0;
2996     s->parse_context.index= 0;
2997     s->parse_context.last_index= 0;
2998     s->bitstream_buffer_size=0;
2999     s->pp_time=0;
3000 }
3001
3002 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
3003                                    int16_t *block, int n, int qscale)
3004 {
3005     int i, level, nCoeffs;
3006     const uint16_t *quant_matrix;
3007
3008     nCoeffs= s->block_last_index[n];
3009
3010     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3011     /* XXX: only mpeg1 */
3012     quant_matrix = s->intra_matrix;
3013     for(i=1;i<=nCoeffs;i++) {
3014         int j= s->intra_scantable.permutated[i];
3015         level = block[j];
3016         if (level) {
3017             if (level < 0) {
3018                 level = -level;
3019                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3020                 level = (level - 1) | 1;
3021                 level = -level;
3022             } else {
3023                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3024                 level = (level - 1) | 1;
3025             }
3026             block[j] = level;
3027         }
3028     }
3029 }
3030
3031 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
3032                                    int16_t *block, int n, int qscale)
3033 {
3034     int i, level, nCoeffs;
3035     const uint16_t *quant_matrix;
3036
3037     nCoeffs= s->block_last_index[n];
3038
3039     quant_matrix = s->inter_matrix;
3040     for(i=0; i<=nCoeffs; i++) {
3041         int j= s->intra_scantable.permutated[i];
3042         level = block[j];
3043         if (level) {
3044             if (level < 0) {
3045                 level = -level;
3046                 level = (((level << 1) + 1) * qscale *
3047                          ((int) (quant_matrix[j]))) >> 4;
3048                 level = (level - 1) | 1;
3049                 level = -level;
3050             } else {
3051                 level = (((level << 1) + 1) * qscale *
3052                          ((int) (quant_matrix[j]))) >> 4;
3053                 level = (level - 1) | 1;
3054             }
3055             block[j] = level;
3056         }
3057     }
3058 }
3059
3060 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
3061                                    int16_t *block, int n, int qscale)
3062 {
3063     int i, level, nCoeffs;
3064     const uint16_t *quant_matrix;
3065
3066     if(s->alternate_scan) nCoeffs= 63;
3067     else nCoeffs= s->block_last_index[n];
3068
3069     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3070     quant_matrix = s->intra_matrix;
3071     for(i=1;i<=nCoeffs;i++) {
3072         int j= s->intra_scantable.permutated[i];
3073         level = block[j];
3074         if (level) {
3075             if (level < 0) {
3076                 level = -level;
3077                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3078                 level = -level;
3079             } else {
3080                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3081             }
3082             block[j] = level;
3083         }
3084     }
3085 }
3086
3087 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
3088                                    int16_t *block, int n, int qscale)
3089 {
3090     int i, level, nCoeffs;
3091     const uint16_t *quant_matrix;
3092     int sum=-1;
3093
3094     if(s->alternate_scan) nCoeffs= 63;
3095     else nCoeffs= s->block_last_index[n];
3096
3097     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3098     sum += block[0];
3099     quant_matrix = s->intra_matrix;
3100     for(i=1;i<=nCoeffs;i++) {
3101         int j= s->intra_scantable.permutated[i];
3102         level = block[j];
3103         if (level) {
3104             if (level < 0) {
3105                 level = -level;
3106                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3107                 level = -level;
3108             } else {
3109                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3110             }
3111             block[j] = level;
3112             sum+=level;
3113         }
3114     }
3115     block[63]^=sum&1;
3116 }
3117
3118 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3119                                    int16_t *block, int n, int qscale)
3120 {
3121     int i, level, nCoeffs;
3122     const uint16_t *quant_matrix;
3123     int sum=-1;
3124
3125     if(s->alternate_scan) nCoeffs= 63;
3126     else nCoeffs= s->block_last_index[n];
3127
3128     quant_matrix = s->inter_matrix;
3129     for(i=0; i<=nCoeffs; i++) {
3130         int j= s->intra_scantable.permutated[i];
3131         level = block[j];
3132         if (level) {
3133             if (level < 0) {
3134                 level = -level;
3135                 level = (((level << 1) + 1) * qscale *
3136                          ((int) (quant_matrix[j]))) >> 4;
3137                 level = -level;
3138             } else {
3139                 level = (((level << 1) + 1) * qscale *
3140                          ((int) (quant_matrix[j]))) >> 4;
3141             }
3142             block[j] = level;
3143             sum+=level;
3144         }
3145     }
3146     block[63]^=sum&1;
3147 }
3148
3149 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3150                                   int16_t *block, int n, int qscale)
3151 {
3152     int i, level, qmul, qadd;
3153     int nCoeffs;
3154
3155     assert(s->block_last_index[n]>=0);
3156
3157     qmul = qscale << 1;
3158
3159     if (!s->h263_aic) {
3160         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3161         qadd = (qscale - 1) | 1;
3162     }else{
3163         qadd = 0;
3164     }
3165     if(s->ac_pred)
3166         nCoeffs=63;
3167     else
3168         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3169
3170     for(i=1; i<=nCoeffs; i++) {
3171         level = block[i];
3172         if (level) {
3173             if (level < 0) {
3174                 level = level * qmul - qadd;
3175             } else {
3176                 level = level * qmul + qadd;
3177             }
3178             block[i] = level;
3179         }
3180     }
3181 }
3182
3183 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3184                                   int16_t *block, int n, int qscale)
3185 {
3186     int i, level, qmul, qadd;
3187     int nCoeffs;
3188
3189     assert(s->block_last_index[n]>=0);
3190
3191     qadd = (qscale - 1) | 1;
3192     qmul = qscale << 1;
3193
3194     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3195
3196     for(i=0; i<=nCoeffs; i++) {
3197         level = block[i];
3198         if (level) {
3199             if (level < 0) {
3200                 level = level * qmul - qadd;
3201             } else {
3202                 level = level * qmul + qadd;
3203             }
3204             block[i] = level;
3205         }
3206     }
3207 }
3208
3209 /**
3210  * set qscale and update qscale dependent variables.
3211  */
3212 void ff_set_qscale(MpegEncContext * s, int qscale)
3213 {
3214     if (qscale < 1)
3215         qscale = 1;
3216     else if (qscale > 31)
3217         qscale = 31;
3218
3219     s->qscale = qscale;
3220     s->chroma_qscale= s->chroma_qscale_table[qscale];
3221
3222     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3223     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3224 }
3225
3226 void ff_MPV_report_decode_progress(MpegEncContext *s)
3227 {
3228     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3229         ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
3230 }
3231
3232 void ff_mpeg_er_frame_start(MpegEncContext *s)
3233 {
3234     ERContext *er = &s->er;
3235
3236     er->cur_pic  = s->current_picture_ptr;
3237     er->last_pic = s->last_picture_ptr;
3238     er->next_pic = s->next_picture_ptr;
3239
3240     er->pp_time           = s->pp_time;
3241     er->pb_time           = s->pb_time;
3242     er->quarter_sample    = s->quarter_sample;
3243     er->partitioned_frame = s->partitioned_frame;
3244
3245     ff_er_frame_start(er);
3246 }