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