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